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 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. We should make this smarter one
3686          * day... */
3687
3688         l = strlen(s);
3689         if (l < 2)
3690                 return strdup(s);
3691
3692         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3693                 return strndup(s+1, l-2);
3694
3695         return strdup(s);
3696 }
3697
3698 char *normalize_env_assignment(const char *s) {
3699         _cleanup_free_ char *value = NULL;
3700         const char *eq;
3701         char *p, *name;
3702
3703         eq = strchr(s, '=');
3704         if (!eq) {
3705                 char *r, *t;
3706
3707                 r = strdup(s);
3708                 if (!r)
3709                         return NULL;
3710
3711                 t = strstrip(r);
3712                 if (t != r)
3713                         memmove(r, t, strlen(t) + 1);
3714
3715                 return r;
3716         }
3717
3718         name = strndupa(s, eq - s);
3719         p = strdupa(eq + 1);
3720
3721         value = unquote(strstrip(p), QUOTES);
3722         if (!value)
3723                 return NULL;
3724
3725         return strjoin(strstrip(name), "=", value, NULL);
3726 }
3727
3728 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3729         siginfo_t dummy;
3730
3731         assert(pid >= 1);
3732
3733         if (!status)
3734                 status = &dummy;
3735
3736         for (;;) {
3737                 zero(*status);
3738
3739                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3740
3741                         if (errno == EINTR)
3742                                 continue;
3743
3744                         return -errno;
3745                 }
3746
3747                 return 0;
3748         }
3749 }
3750
3751 /*
3752  * Return values:
3753  * < 0 : wait_for_terminate() failed to get the state of the
3754  *       process, the process was terminated by a signal, or
3755  *       failed for an unknown reason.
3756  * >=0 : The process terminated normally, and its exit code is
3757  *       returned.
3758  *
3759  * That is, success is indicated by a return value of zero, and an
3760  * error is indicated by a non-zero value.
3761  *
3762  * A warning is emitted if the process terminates abnormally,
3763  * and also if it returns non-zero unless check_exit_code is true.
3764  */
3765 int wait_for_terminate_and_warn(const char *name, pid_t pid, bool check_exit_code) {
3766         int r;
3767         siginfo_t status;
3768
3769         assert(name);
3770         assert(pid > 1);
3771
3772         r = wait_for_terminate(pid, &status);
3773         if (r < 0)
3774                 return log_warning_errno(r, "Failed to wait for %s: %m", name);
3775
3776         if (status.si_code == CLD_EXITED) {
3777                 if (status.si_status != 0)
3778                         log_full(check_exit_code ? LOG_WARNING : LOG_DEBUG,
3779                                  "%s failed with error code %i.", name, status.si_status);
3780                 else
3781                         log_debug("%s succeeded.", name);
3782
3783                 return status.si_status;
3784         } else if (status.si_code == CLD_KILLED ||
3785                    status.si_code == CLD_DUMPED) {
3786
3787                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3788                 return -EPROTO;
3789         }
3790
3791         log_warning("%s failed due to unknown reason.", name);
3792         return -EPROTO;
3793 }
3794
3795 noreturn void freeze(void) {
3796
3797         /* Make sure nobody waits for us on a socket anymore */
3798         close_all_fds(NULL, 0);
3799
3800         sync();
3801
3802         for (;;)
3803                 pause();
3804 }
3805
3806 bool null_or_empty(struct stat *st) {
3807         assert(st);
3808
3809         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3810                 return true;
3811
3812         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3813                 return true;
3814
3815         return false;
3816 }
3817
3818 int null_or_empty_path(const char *fn) {
3819         struct stat st;
3820
3821         assert(fn);
3822
3823         if (stat(fn, &st) < 0)
3824                 return -errno;
3825
3826         return null_or_empty(&st);
3827 }
3828
3829 int null_or_empty_fd(int fd) {
3830         struct stat st;
3831
3832         assert(fd >= 0);
3833
3834         if (fstat(fd, &st) < 0)
3835                 return -errno;
3836
3837         return null_or_empty(&st);
3838 }
3839
3840 DIR *xopendirat(int fd, const char *name, int flags) {
3841         int nfd;
3842         DIR *d;
3843
3844         assert(!(flags & O_CREAT));
3845
3846         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3847         if (nfd < 0)
3848                 return NULL;
3849
3850         d = fdopendir(nfd);
3851         if (!d) {
3852                 safe_close(nfd);
3853                 return NULL;
3854         }
3855
3856         return d;
3857 }
3858
3859 int signal_from_string_try_harder(const char *s) {
3860         int signo;
3861         assert(s);
3862
3863         signo = signal_from_string(s);
3864         if (signo <= 0)
3865                 if (startswith(s, "SIG"))
3866                         return signal_from_string(s+3);
3867
3868         return signo;
3869 }
3870
3871 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3872         _cleanup_free_ char *t = NULL, *u = NULL;
3873         size_t enc_len;
3874
3875         u = unquote(tagvalue, "\"\'");
3876         if (!u)
3877                 return NULL;
3878
3879         enc_len = strlen(u) * 4 + 1;
3880         t = new(char, enc_len);
3881         if (!t)
3882                 return NULL;
3883
3884         if (encode_devnode_name(u, t, enc_len) < 0)
3885                 return NULL;
3886
3887         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3888 }
3889
3890 char *fstab_node_to_udev_node(const char *p) {
3891         assert(p);
3892
3893         if (startswith(p, "LABEL="))
3894                 return tag_to_udev_node(p+6, "label");
3895
3896         if (startswith(p, "UUID="))
3897                 return tag_to_udev_node(p+5, "uuid");
3898
3899         if (startswith(p, "PARTUUID="))
3900                 return tag_to_udev_node(p+9, "partuuid");
3901
3902         if (startswith(p, "PARTLABEL="))
3903                 return tag_to_udev_node(p+10, "partlabel");
3904
3905         return strdup(p);
3906 }
3907
3908 bool tty_is_vc(const char *tty) {
3909         assert(tty);
3910
3911         return vtnr_from_tty(tty) >= 0;
3912 }
3913
3914 bool tty_is_console(const char *tty) {
3915         assert(tty);
3916
3917         if (startswith(tty, "/dev/"))
3918                 tty += 5;
3919
3920         return streq(tty, "console");
3921 }
3922
3923 int vtnr_from_tty(const char *tty) {
3924         int i, r;
3925
3926         assert(tty);
3927
3928         if (startswith(tty, "/dev/"))
3929                 tty += 5;
3930
3931         if (!startswith(tty, "tty") )
3932                 return -EINVAL;
3933
3934         if (tty[3] < '0' || tty[3] > '9')
3935                 return -EINVAL;
3936
3937         r = safe_atoi(tty+3, &i);
3938         if (r < 0)
3939                 return r;
3940
3941         if (i < 0 || i > 63)
3942                 return -EINVAL;
3943
3944         return i;
3945 }
3946
3947 char *resolve_dev_console(char **active) {
3948         char *tty;
3949
3950         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3951          * (i.e. not read-only-mounted which is a sign for container setups) */
3952
3953         if (path_is_read_only_fs("/sys") > 0)
3954                 return NULL;
3955
3956         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3957                 return NULL;
3958
3959         /* If multiple log outputs are configured the last one is what
3960          * /dev/console points to */
3961         tty = strrchr(*active, ' ');
3962         if (tty)
3963                 tty++;
3964         else
3965                 tty = *active;
3966
3967         if (streq(tty, "tty0")) {
3968                 char *tmp;
3969
3970                 /* Get the active VC (e.g. tty1) */
3971                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3972                         free(*active);
3973                         tty = *active = tmp;
3974                 }
3975         }
3976
3977         return tty;
3978 }
3979
3980 bool tty_is_vc_resolve(const char *tty) {
3981         _cleanup_free_ char *active = NULL;
3982
3983         assert(tty);
3984
3985         if (startswith(tty, "/dev/"))
3986                 tty += 5;
3987
3988         if (streq(tty, "console")) {
3989                 tty = resolve_dev_console(&active);
3990                 if (!tty)
3991                         return false;
3992         }
3993
3994         return tty_is_vc(tty);
3995 }
3996
3997 const char *default_term_for_tty(const char *tty) {
3998         assert(tty);
3999
4000         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt220";
4001 }
4002
4003 bool dirent_is_file(const struct dirent *de) {
4004         assert(de);
4005
4006         if (hidden_file(de->d_name))
4007                 return false;
4008
4009         if (de->d_type != DT_REG &&
4010             de->d_type != DT_LNK &&
4011             de->d_type != DT_UNKNOWN)
4012                 return false;
4013
4014         return true;
4015 }
4016
4017 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4018         assert(de);
4019
4020         if (de->d_type != DT_REG &&
4021             de->d_type != DT_LNK &&
4022             de->d_type != DT_UNKNOWN)
4023                 return false;
4024
4025         if (hidden_file_allow_backup(de->d_name))
4026                 return false;
4027
4028         return endswith(de->d_name, suffix);
4029 }
4030
4031 static int do_execute(char **directories, usec_t timeout, char *argv[]) {
4032         _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
4033         _cleanup_set_free_free_ Set *seen = NULL;
4034         char **directory;
4035
4036         /* We fork this all off from a child process so that we can
4037          * somewhat cleanly make use of SIGALRM to set a time limit */
4038
4039         reset_all_signal_handlers();
4040         reset_signal_mask();
4041
4042         assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4043
4044         pids = hashmap_new(NULL);
4045         if (!pids)
4046                 return log_oom();
4047
4048         seen = set_new(&string_hash_ops);
4049         if (!seen)
4050                 return log_oom();
4051
4052         STRV_FOREACH(directory, directories) {
4053                 _cleanup_closedir_ DIR *d;
4054                 struct dirent *de;
4055
4056                 d = opendir(*directory);
4057                 if (!d) {
4058                         if (errno == ENOENT)
4059                                 continue;
4060
4061                         return log_error_errno(errno, "Failed to open directory %s: %m", *directory);
4062                 }
4063
4064                 FOREACH_DIRENT(de, d, break) {
4065                         _cleanup_free_ char *path = NULL;
4066                         pid_t pid;
4067                         int r;
4068
4069                         if (!dirent_is_file(de))
4070                                 continue;
4071
4072                         if (set_contains(seen, de->d_name)) {
4073                                 log_debug("%1$s/%2$s skipped (%2$s was already seen).", *directory, de->d_name);
4074                                 continue;
4075                         }
4076
4077                         r = set_put_strdup(seen, de->d_name);
4078                         if (r < 0)
4079                                 return log_oom();
4080
4081                         path = strjoin(*directory, "/", de->d_name, NULL);
4082                         if (!path)
4083                                 return log_oom();
4084
4085                         if (null_or_empty_path(path)) {
4086                                 log_debug("%s is empty (a mask).", path);
4087                                 continue;
4088                         }
4089
4090                         pid = fork();
4091                         if (pid < 0) {
4092                                 log_error_errno(errno, "Failed to fork: %m");
4093                                 continue;
4094                         } else if (pid == 0) {
4095                                 char *_argv[2];
4096
4097                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4098
4099                                 if (!argv) {
4100                                         _argv[0] = path;
4101                                         _argv[1] = NULL;
4102                                         argv = _argv;
4103                                 } else
4104                                         argv[0] = path;
4105
4106                                 execv(path, argv);
4107                                 return log_error_errno(errno, "Failed to execute %s: %m", path);
4108                         }
4109
4110                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
4111
4112                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
4113                         if (r < 0)
4114                                 return log_oom();
4115                         path = NULL;
4116                 }
4117         }
4118
4119         /* Abort execution of this process after the timout. We simply
4120          * rely on SIGALRM as default action terminating the process,
4121          * and turn on alarm(). */
4122
4123         if (timeout != USEC_INFINITY)
4124                 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
4125
4126         while (!hashmap_isempty(pids)) {
4127                 _cleanup_free_ char *path = NULL;
4128                 pid_t pid;
4129
4130                 pid = PTR_TO_UINT(hashmap_first_key(pids));
4131                 assert(pid > 0);
4132
4133                 path = hashmap_remove(pids, UINT_TO_PTR(pid));
4134                 assert(path);
4135
4136                 wait_for_terminate_and_warn(path, pid, true);
4137         }
4138
4139         return 0;
4140 }
4141
4142 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]) {
4143         pid_t executor_pid;
4144         int r;
4145         char *name;
4146         char **dirs = (char**) directories;
4147
4148         assert(!strv_isempty(dirs));
4149
4150         name = basename(dirs[0]);
4151         assert(!isempty(name));
4152
4153         /* Executes all binaries in the directories in parallel and waits
4154          * for them to finish. Optionally a timeout is applied. If a file
4155          * with the same name exists in more than one directory, the
4156          * earliest one wins. */
4157
4158         executor_pid = fork();
4159         if (executor_pid < 0) {
4160                 log_error_errno(errno, "Failed to fork: %m");
4161                 return;
4162
4163         } else if (executor_pid == 0) {
4164                 r = do_execute(dirs, timeout, argv);
4165                 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
4166         }
4167
4168         wait_for_terminate_and_warn(name, executor_pid, true);
4169 }
4170
4171 int kill_and_sigcont(pid_t pid, int sig) {
4172         int r;
4173
4174         r = kill(pid, sig) < 0 ? -errno : 0;
4175
4176         if (r >= 0)
4177                 kill(pid, SIGCONT);
4178
4179         return r;
4180 }
4181
4182 bool nulstr_contains(const char*nulstr, const char *needle) {
4183         const char *i;
4184
4185         if (!nulstr)
4186                 return false;
4187
4188         NULSTR_FOREACH(i, nulstr)
4189                 if (streq(i, needle))
4190                         return true;
4191
4192         return false;
4193 }
4194
4195 bool plymouth_running(void) {
4196         return access("/run/plymouth/pid", F_OK) >= 0;
4197 }
4198
4199 char* strshorten(char *s, size_t l) {
4200         assert(s);
4201
4202         if (l < strlen(s))
4203                 s[l] = 0;
4204
4205         return s;
4206 }
4207
4208 static bool hostname_valid_char(char c) {
4209         return
4210                 (c >= 'a' && c <= 'z') ||
4211                 (c >= 'A' && c <= 'Z') ||
4212                 (c >= '0' && c <= '9') ||
4213                 c == '-' ||
4214                 c == '_' ||
4215                 c == '.';
4216 }
4217
4218 bool hostname_is_valid(const char *s) {
4219         const char *p;
4220         bool dot;
4221
4222         if (isempty(s))
4223                 return false;
4224
4225         /* Doesn't accept empty hostnames, hostnames with trailing or
4226          * leading dots, and hostnames with multiple dots in a
4227          * sequence. Also ensures that the length stays below
4228          * HOST_NAME_MAX. */
4229
4230         for (p = s, dot = true; *p; p++) {
4231                 if (*p == '.') {
4232                         if (dot)
4233                                 return false;
4234
4235                         dot = true;
4236                 } else {
4237                         if (!hostname_valid_char(*p))
4238                                 return false;
4239
4240                         dot = false;
4241                 }
4242         }
4243
4244         if (dot)
4245                 return false;
4246
4247         if (p-s > HOST_NAME_MAX)
4248                 return false;
4249
4250         return true;
4251 }
4252
4253 char* hostname_cleanup(char *s, bool lowercase) {
4254         char *p, *d;
4255         bool dot;
4256
4257         for (p = s, d = s, dot = true; *p; p++) {
4258                 if (*p == '.') {
4259                         if (dot)
4260                                 continue;
4261
4262                         *(d++) = '.';
4263                         dot = true;
4264                 } else if (hostname_valid_char(*p)) {
4265                         *(d++) = lowercase ? tolower(*p) : *p;
4266                         dot = false;
4267                 }
4268
4269         }
4270
4271         if (dot && d > s)
4272                 d[-1] = 0;
4273         else
4274                 *d = 0;
4275
4276         strshorten(s, HOST_NAME_MAX);
4277
4278         return s;
4279 }
4280
4281 bool machine_name_is_valid(const char *s) {
4282
4283         if (!hostname_is_valid(s))
4284                 return false;
4285
4286         /* Machine names should be useful hostnames, but also be
4287          * useful in unit names, hence we enforce a stricter length
4288          * limitation. */
4289
4290         if (strlen(s) > 64)
4291                 return false;
4292
4293         return true;
4294 }
4295
4296 int pipe_eof(int fd) {
4297         struct pollfd pollfd = {
4298                 .fd = fd,
4299                 .events = POLLIN|POLLHUP,
4300         };
4301
4302         int r;
4303
4304         r = poll(&pollfd, 1, 0);
4305         if (r < 0)
4306                 return -errno;
4307
4308         if (r == 0)
4309                 return 0;
4310
4311         return pollfd.revents & POLLHUP;
4312 }
4313
4314 int fd_wait_for_event(int fd, int event, usec_t t) {
4315
4316         struct pollfd pollfd = {
4317                 .fd = fd,
4318                 .events = event,
4319         };
4320
4321         struct timespec ts;
4322         int r;
4323
4324         r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
4325         if (r < 0)
4326                 return -errno;
4327
4328         if (r == 0)
4329                 return 0;
4330
4331         return pollfd.revents;
4332 }
4333
4334 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4335         FILE *f;
4336         char *t;
4337         int r, fd;
4338
4339         assert(path);
4340         assert(_f);
4341         assert(_temp_path);
4342
4343         r = tempfn_xxxxxx(path, &t);
4344         if (r < 0)
4345                 return r;
4346
4347         fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
4348         if (fd < 0) {
4349                 free(t);
4350                 return -errno;
4351         }
4352
4353         f = fdopen(fd, "we");
4354         if (!f) {
4355                 unlink(t);
4356                 free(t);
4357                 return -errno;
4358         }
4359
4360         *_f = f;
4361         *_temp_path = t;
4362
4363         return 0;
4364 }
4365
4366 int terminal_vhangup_fd(int fd) {
4367         assert(fd >= 0);
4368
4369         if (ioctl(fd, TIOCVHANGUP) < 0)
4370                 return -errno;
4371
4372         return 0;
4373 }
4374
4375 int terminal_vhangup(const char *name) {
4376         _cleanup_close_ int fd;
4377
4378         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4379         if (fd < 0)
4380                 return fd;
4381
4382         return terminal_vhangup_fd(fd);
4383 }
4384
4385 int vt_disallocate(const char *name) {
4386         int fd, r;
4387         unsigned u;
4388
4389         /* Deallocate the VT if possible. If not possible
4390          * (i.e. because it is the active one), at least clear it
4391          * entirely (including the scrollback buffer) */
4392
4393         if (!startswith(name, "/dev/"))
4394                 return -EINVAL;
4395
4396         if (!tty_is_vc(name)) {
4397                 /* So this is not a VT. I guess we cannot deallocate
4398                  * it then. But let's at least clear the screen */
4399
4400                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4401                 if (fd < 0)
4402                         return fd;
4403
4404                 loop_write(fd,
4405                            "\033[r"    /* clear scrolling region */
4406                            "\033[H"    /* move home */
4407                            "\033[2J",  /* clear screen */
4408                            10, false);
4409                 safe_close(fd);
4410
4411                 return 0;
4412         }
4413
4414         if (!startswith(name, "/dev/tty"))
4415                 return -EINVAL;
4416
4417         r = safe_atou(name+8, &u);
4418         if (r < 0)
4419                 return r;
4420
4421         if (u <= 0)
4422                 return -EINVAL;
4423
4424         /* Try to deallocate */
4425         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4426         if (fd < 0)
4427                 return fd;
4428
4429         r = ioctl(fd, VT_DISALLOCATE, u);
4430         safe_close(fd);
4431
4432         if (r >= 0)
4433                 return 0;
4434
4435         if (errno != EBUSY)
4436                 return -errno;
4437
4438         /* Couldn't deallocate, so let's clear it fully with
4439          * scrollback */
4440         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4441         if (fd < 0)
4442                 return fd;
4443
4444         loop_write(fd,
4445                    "\033[r"   /* clear scrolling region */
4446                    "\033[H"   /* move home */
4447                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4448                    10, false);
4449         safe_close(fd);
4450
4451         return 0;
4452 }
4453
4454 int symlink_atomic(const char *from, const char *to) {
4455         _cleanup_free_ char *t = NULL;
4456         int r;
4457
4458         assert(from);
4459         assert(to);
4460
4461         r = tempfn_random(to, &t);
4462         if (r < 0)
4463                 return r;
4464
4465         if (symlink(from, t) < 0)
4466                 return -errno;
4467
4468         if (rename(t, to) < 0) {
4469                 unlink_noerrno(t);
4470                 return -errno;
4471         }
4472
4473         return 0;
4474 }
4475
4476 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
4477         _cleanup_free_ char *t = NULL;
4478         int r;
4479
4480         assert(path);
4481
4482         r = tempfn_random(path, &t);
4483         if (r < 0)
4484                 return r;
4485
4486         if (mknod(t, mode, dev) < 0)
4487                 return -errno;
4488
4489         if (rename(t, path) < 0) {
4490                 unlink_noerrno(t);
4491                 return -errno;
4492         }
4493
4494         return 0;
4495 }
4496
4497 int mkfifo_atomic(const char *path, mode_t mode) {
4498         _cleanup_free_ char *t = NULL;
4499         int r;
4500
4501         assert(path);
4502
4503         r = tempfn_random(path, &t);
4504         if (r < 0)
4505                 return r;
4506
4507         if (mkfifo(t, mode) < 0)
4508                 return -errno;
4509
4510         if (rename(t, path) < 0) {
4511                 unlink_noerrno(t);
4512                 return -errno;
4513         }
4514
4515         return 0;
4516 }
4517
4518 bool display_is_local(const char *display) {
4519         assert(display);
4520
4521         return
4522                 display[0] == ':' &&
4523                 display[1] >= '0' &&
4524                 display[1] <= '9';
4525 }
4526
4527 int socket_from_display(const char *display, char **path) {
4528         size_t k;
4529         char *f, *c;
4530
4531         assert(display);
4532         assert(path);
4533
4534         if (!display_is_local(display))
4535                 return -EINVAL;
4536
4537         k = strspn(display+1, "0123456789");
4538
4539         f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4540         if (!f)
4541                 return -ENOMEM;
4542
4543         c = stpcpy(f, "/tmp/.X11-unix/X");
4544         memcpy(c, display+1, k);
4545         c[k] = 0;
4546
4547         *path = f;
4548
4549         return 0;
4550 }
4551
4552 int get_user_creds(
4553                 const char **username,
4554                 uid_t *uid, gid_t *gid,
4555                 const char **home,
4556                 const char **shell) {
4557
4558         struct passwd *p;
4559         uid_t u;
4560
4561         assert(username);
4562         assert(*username);
4563
4564         /* We enforce some special rules for uid=0: in order to avoid
4565          * NSS lookups for root we hardcode its data. */
4566
4567         if (streq(*username, "root") || streq(*username, "0")) {
4568                 *username = "root";
4569
4570                 if (uid)
4571                         *uid = 0;
4572
4573                 if (gid)
4574                         *gid = 0;
4575
4576                 if (home)
4577                         *home = "/root";
4578
4579                 if (shell)
4580                         *shell = "/bin/sh";
4581
4582                 return 0;
4583         }
4584
4585         if (parse_uid(*username, &u) >= 0) {
4586                 errno = 0;
4587                 p = getpwuid(u);
4588
4589                 /* If there are multiple users with the same id, make
4590                  * sure to leave $USER to the configured value instead
4591                  * of the first occurrence in the database. However if
4592                  * the uid was configured by a numeric uid, then let's
4593                  * pick the real username from /etc/passwd. */
4594                 if (p)
4595                         *username = p->pw_name;
4596         } else {
4597                 errno = 0;
4598                 p = getpwnam(*username);
4599         }
4600
4601         if (!p)
4602                 return errno > 0 ? -errno : -ESRCH;
4603
4604         if (uid)
4605                 *uid = p->pw_uid;
4606
4607         if (gid)
4608                 *gid = p->pw_gid;
4609
4610         if (home)
4611                 *home = p->pw_dir;
4612
4613         if (shell)
4614                 *shell = p->pw_shell;
4615
4616         return 0;
4617 }
4618
4619 char* uid_to_name(uid_t uid) {
4620         struct passwd *p;
4621         char *r;
4622
4623         if (uid == 0)
4624                 return strdup("root");
4625
4626         p = getpwuid(uid);
4627         if (p)
4628                 return strdup(p->pw_name);
4629
4630         if (asprintf(&r, UID_FMT, uid) < 0)
4631                 return NULL;
4632
4633         return r;
4634 }
4635
4636 char* gid_to_name(gid_t gid) {
4637         struct group *p;
4638         char *r;
4639
4640         if (gid == 0)
4641                 return strdup("root");
4642
4643         p = getgrgid(gid);
4644         if (p)
4645                 return strdup(p->gr_name);
4646
4647         if (asprintf(&r, GID_FMT, gid) < 0)
4648                 return NULL;
4649
4650         return r;
4651 }
4652
4653 int get_group_creds(const char **groupname, gid_t *gid) {
4654         struct group *g;
4655         gid_t id;
4656
4657         assert(groupname);
4658
4659         /* We enforce some special rules for gid=0: in order to avoid
4660          * NSS lookups for root we hardcode its data. */
4661
4662         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4663                 *groupname = "root";
4664
4665                 if (gid)
4666                         *gid = 0;
4667
4668                 return 0;
4669         }
4670
4671         if (parse_gid(*groupname, &id) >= 0) {
4672                 errno = 0;
4673                 g = getgrgid(id);
4674
4675                 if (g)
4676                         *groupname = g->gr_name;
4677         } else {
4678                 errno = 0;
4679                 g = getgrnam(*groupname);
4680         }
4681
4682         if (!g)
4683                 return errno > 0 ? -errno : -ESRCH;
4684
4685         if (gid)
4686                 *gid = g->gr_gid;
4687
4688         return 0;
4689 }
4690
4691 int in_gid(gid_t gid) {
4692         gid_t *gids;
4693         int ngroups_max, r, i;
4694
4695         if (getgid() == gid)
4696                 return 1;
4697
4698         if (getegid() == gid)
4699                 return 1;
4700
4701         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4702         assert(ngroups_max > 0);
4703
4704         gids = alloca(sizeof(gid_t) * ngroups_max);
4705
4706         r = getgroups(ngroups_max, gids);
4707         if (r < 0)
4708                 return -errno;
4709
4710         for (i = 0; i < r; i++)
4711                 if (gids[i] == gid)
4712                         return 1;
4713
4714         return 0;
4715 }
4716
4717 int in_group(const char *name) {
4718         int r;
4719         gid_t gid;
4720
4721         r = get_group_creds(&name, &gid);
4722         if (r < 0)
4723                 return r;
4724
4725         return in_gid(gid);
4726 }
4727
4728 int glob_exists(const char *path) {
4729         _cleanup_globfree_ glob_t g = {};
4730         int k;
4731
4732         assert(path);
4733
4734         errno = 0;
4735         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4736
4737         if (k == GLOB_NOMATCH)
4738                 return 0;
4739         else if (k == GLOB_NOSPACE)
4740                 return -ENOMEM;
4741         else if (k == 0)
4742                 return !strv_isempty(g.gl_pathv);
4743         else
4744                 return errno ? -errno : -EIO;
4745 }
4746
4747 int glob_extend(char ***strv, const char *path) {
4748         _cleanup_globfree_ glob_t g = {};
4749         int k;
4750         char **p;
4751
4752         errno = 0;
4753         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4754
4755         if (k == GLOB_NOMATCH)
4756                 return -ENOENT;
4757         else if (k == GLOB_NOSPACE)
4758                 return -ENOMEM;
4759         else if (k != 0 || strv_isempty(g.gl_pathv))
4760                 return errno ? -errno : -EIO;
4761
4762         STRV_FOREACH(p, g.gl_pathv) {
4763                 k = strv_extend(strv, *p);
4764                 if (k < 0)
4765                         break;
4766         }
4767
4768         return k;
4769 }
4770
4771 int dirent_ensure_type(DIR *d, struct dirent *de) {
4772         struct stat st;
4773
4774         assert(d);
4775         assert(de);
4776
4777         if (de->d_type != DT_UNKNOWN)
4778                 return 0;
4779
4780         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4781                 return -errno;
4782
4783         de->d_type =
4784                 S_ISREG(st.st_mode)  ? DT_REG  :
4785                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4786                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4787                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4788                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4789                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4790                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4791                                        DT_UNKNOWN;
4792
4793         return 0;
4794 }
4795
4796 int get_files_in_directory(const char *path, char ***list) {
4797         _cleanup_closedir_ DIR *d = NULL;
4798         size_t bufsize = 0, n = 0;
4799         _cleanup_strv_free_ char **l = NULL;
4800
4801         assert(path);
4802
4803         /* Returns all files in a directory in *list, and the number
4804          * of files as return value. If list is NULL returns only the
4805          * number. */
4806
4807         d = opendir(path);
4808         if (!d)
4809                 return -errno;
4810
4811         for (;;) {
4812                 struct dirent *de;
4813
4814                 errno = 0;
4815                 de = readdir(d);
4816                 if (!de && errno != 0)
4817                         return -errno;
4818                 if (!de)
4819                         break;
4820
4821                 dirent_ensure_type(d, de);
4822
4823                 if (!dirent_is_file(de))
4824                         continue;
4825
4826                 if (list) {
4827                         /* one extra slot is needed for the terminating NULL */
4828                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
4829                                 return -ENOMEM;
4830
4831                         l[n] = strdup(de->d_name);
4832                         if (!l[n])
4833                                 return -ENOMEM;
4834
4835                         l[++n] = NULL;
4836                 } else
4837                         n++;
4838         }
4839
4840         if (list) {
4841                 *list = l;
4842                 l = NULL; /* avoid freeing */
4843         }
4844
4845         return n;
4846 }
4847
4848 char *strjoin(const char *x, ...) {
4849         va_list ap;
4850         size_t l;
4851         char *r, *p;
4852
4853         va_start(ap, x);
4854
4855         if (x) {
4856                 l = strlen(x);
4857
4858                 for (;;) {
4859                         const char *t;
4860                         size_t n;
4861
4862                         t = va_arg(ap, const char *);
4863                         if (!t)
4864                                 break;
4865
4866                         n = strlen(t);
4867                         if (n > ((size_t) -1) - l) {
4868                                 va_end(ap);
4869                                 return NULL;
4870                         }
4871
4872                         l += n;
4873                 }
4874         } else
4875                 l = 0;
4876
4877         va_end(ap);
4878
4879         r = new(char, l+1);
4880         if (!r)
4881                 return NULL;
4882
4883         if (x) {
4884                 p = stpcpy(r, x);
4885
4886                 va_start(ap, x);
4887
4888                 for (;;) {
4889                         const char *t;
4890
4891                         t = va_arg(ap, const char *);
4892                         if (!t)
4893                                 break;
4894
4895                         p = stpcpy(p, t);
4896                 }
4897
4898                 va_end(ap);
4899         } else
4900                 r[0] = 0;
4901
4902         return r;
4903 }
4904
4905 bool is_main_thread(void) {
4906         static thread_local int cached = 0;
4907
4908         if (_unlikely_(cached == 0))
4909                 cached = getpid() == gettid() ? 1 : -1;
4910
4911         return cached > 0;
4912 }
4913
4914 int block_get_whole_disk(dev_t d, dev_t *ret) {
4915         char *p, *s;
4916         int r;
4917         unsigned n, m;
4918
4919         assert(ret);
4920
4921         /* If it has a queue this is good enough for us */
4922         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4923                 return -ENOMEM;
4924
4925         r = access(p, F_OK);
4926         free(p);
4927
4928         if (r >= 0) {
4929                 *ret = d;
4930                 return 0;
4931         }
4932
4933         /* If it is a partition find the originating device */
4934         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4935                 return -ENOMEM;
4936
4937         r = access(p, F_OK);
4938         free(p);
4939
4940         if (r < 0)
4941                 return -ENOENT;
4942
4943         /* Get parent dev_t */
4944         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4945                 return -ENOMEM;
4946
4947         r = read_one_line_file(p, &s);
4948         free(p);
4949
4950         if (r < 0)
4951                 return r;
4952
4953         r = sscanf(s, "%u:%u", &m, &n);
4954         free(s);
4955
4956         if (r != 2)
4957                 return -EINVAL;
4958
4959         /* Only return this if it is really good enough for us. */
4960         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4961                 return -ENOMEM;
4962
4963         r = access(p, F_OK);
4964         free(p);
4965
4966         if (r >= 0) {
4967                 *ret = makedev(m, n);
4968                 return 0;
4969         }
4970
4971         return -ENOENT;
4972 }
4973
4974 static const char *const ioprio_class_table[] = {
4975         [IOPRIO_CLASS_NONE] = "none",
4976         [IOPRIO_CLASS_RT] = "realtime",
4977         [IOPRIO_CLASS_BE] = "best-effort",
4978         [IOPRIO_CLASS_IDLE] = "idle"
4979 };
4980
4981 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4982
4983 static const char *const sigchld_code_table[] = {
4984         [CLD_EXITED] = "exited",
4985         [CLD_KILLED] = "killed",
4986         [CLD_DUMPED] = "dumped",
4987         [CLD_TRAPPED] = "trapped",
4988         [CLD_STOPPED] = "stopped",
4989         [CLD_CONTINUED] = "continued",
4990 };
4991
4992 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4993
4994 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4995         [LOG_FAC(LOG_KERN)] = "kern",
4996         [LOG_FAC(LOG_USER)] = "user",
4997         [LOG_FAC(LOG_MAIL)] = "mail",
4998         [LOG_FAC(LOG_DAEMON)] = "daemon",
4999         [LOG_FAC(LOG_AUTH)] = "auth",
5000         [LOG_FAC(LOG_SYSLOG)] = "syslog",
5001         [LOG_FAC(LOG_LPR)] = "lpr",
5002         [LOG_FAC(LOG_NEWS)] = "news",
5003         [LOG_FAC(LOG_UUCP)] = "uucp",
5004         [LOG_FAC(LOG_CRON)] = "cron",
5005         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5006         [LOG_FAC(LOG_FTP)] = "ftp",
5007         [LOG_FAC(LOG_LOCAL0)] = "local0",
5008         [LOG_FAC(LOG_LOCAL1)] = "local1",
5009         [LOG_FAC(LOG_LOCAL2)] = "local2",
5010         [LOG_FAC(LOG_LOCAL3)] = "local3",
5011         [LOG_FAC(LOG_LOCAL4)] = "local4",
5012         [LOG_FAC(LOG_LOCAL5)] = "local5",
5013         [LOG_FAC(LOG_LOCAL6)] = "local6",
5014         [LOG_FAC(LOG_LOCAL7)] = "local7"
5015 };
5016
5017 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
5018
5019 static const char *const log_level_table[] = {
5020         [LOG_EMERG] = "emerg",
5021         [LOG_ALERT] = "alert",
5022         [LOG_CRIT] = "crit",
5023         [LOG_ERR] = "err",
5024         [LOG_WARNING] = "warning",
5025         [LOG_NOTICE] = "notice",
5026         [LOG_INFO] = "info",
5027         [LOG_DEBUG] = "debug"
5028 };
5029
5030 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
5031
5032 static const char* const sched_policy_table[] = {
5033         [SCHED_OTHER] = "other",
5034         [SCHED_BATCH] = "batch",
5035         [SCHED_IDLE] = "idle",
5036         [SCHED_FIFO] = "fifo",
5037         [SCHED_RR] = "rr"
5038 };
5039
5040 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
5041
5042 static const char* const rlimit_table[_RLIMIT_MAX] = {
5043         [RLIMIT_CPU] = "LimitCPU",
5044         [RLIMIT_FSIZE] = "LimitFSIZE",
5045         [RLIMIT_DATA] = "LimitDATA",
5046         [RLIMIT_STACK] = "LimitSTACK",
5047         [RLIMIT_CORE] = "LimitCORE",
5048         [RLIMIT_RSS] = "LimitRSS",
5049         [RLIMIT_NOFILE] = "LimitNOFILE",
5050         [RLIMIT_AS] = "LimitAS",
5051         [RLIMIT_NPROC] = "LimitNPROC",
5052         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5053         [RLIMIT_LOCKS] = "LimitLOCKS",
5054         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5055         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5056         [RLIMIT_NICE] = "LimitNICE",
5057         [RLIMIT_RTPRIO] = "LimitRTPRIO",
5058         [RLIMIT_RTTIME] = "LimitRTTIME"
5059 };
5060
5061 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5062
5063 static const char* const ip_tos_table[] = {
5064         [IPTOS_LOWDELAY] = "low-delay",
5065         [IPTOS_THROUGHPUT] = "throughput",
5066         [IPTOS_RELIABILITY] = "reliability",
5067         [IPTOS_LOWCOST] = "low-cost",
5068 };
5069
5070 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
5071
5072 static const char *const __signal_table[] = {
5073         [SIGHUP] = "HUP",
5074         [SIGINT] = "INT",
5075         [SIGQUIT] = "QUIT",
5076         [SIGILL] = "ILL",
5077         [SIGTRAP] = "TRAP",
5078         [SIGABRT] = "ABRT",
5079         [SIGBUS] = "BUS",
5080         [SIGFPE] = "FPE",
5081         [SIGKILL] = "KILL",
5082         [SIGUSR1] = "USR1",
5083         [SIGSEGV] = "SEGV",
5084         [SIGUSR2] = "USR2",
5085         [SIGPIPE] = "PIPE",
5086         [SIGALRM] = "ALRM",
5087         [SIGTERM] = "TERM",
5088 #ifdef SIGSTKFLT
5089         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
5090 #endif
5091         [SIGCHLD] = "CHLD",
5092         [SIGCONT] = "CONT",
5093         [SIGSTOP] = "STOP",
5094         [SIGTSTP] = "TSTP",
5095         [SIGTTIN] = "TTIN",
5096         [SIGTTOU] = "TTOU",
5097         [SIGURG] = "URG",
5098         [SIGXCPU] = "XCPU",
5099         [SIGXFSZ] = "XFSZ",
5100         [SIGVTALRM] = "VTALRM",
5101         [SIGPROF] = "PROF",
5102         [SIGWINCH] = "WINCH",
5103         [SIGIO] = "IO",
5104         [SIGPWR] = "PWR",
5105         [SIGSYS] = "SYS"
5106 };
5107
5108 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5109
5110 const char *signal_to_string(int signo) {
5111         static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
5112         const char *name;
5113
5114         name = __signal_to_string(signo);
5115         if (name)
5116                 return name;
5117
5118         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5119                 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
5120         else
5121                 snprintf(buf, sizeof(buf), "%d", signo);
5122
5123         return buf;
5124 }
5125
5126 int signal_from_string(const char *s) {
5127         int signo;
5128         int offset = 0;
5129         unsigned u;
5130
5131         signo = __signal_from_string(s);
5132         if (signo > 0)
5133                 return signo;
5134
5135         if (startswith(s, "RTMIN+")) {
5136                 s += 6;
5137                 offset = SIGRTMIN;
5138         }
5139         if (safe_atou(s, &u) >= 0) {
5140                 signo = (int) u + offset;
5141                 if (signo > 0 && signo < _NSIG)
5142                         return signo;
5143         }
5144         return -EINVAL;
5145 }
5146
5147 bool kexec_loaded(void) {
5148        bool loaded = false;
5149        char *s;
5150
5151        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5152                if (s[0] == '1')
5153                        loaded = true;
5154                free(s);
5155        }
5156        return loaded;
5157 }
5158
5159 int prot_from_flags(int flags) {
5160
5161         switch (flags & O_ACCMODE) {
5162
5163         case O_RDONLY:
5164                 return PROT_READ;
5165
5166         case O_WRONLY:
5167                 return PROT_WRITE;
5168
5169         case O_RDWR:
5170                 return PROT_READ|PROT_WRITE;
5171
5172         default:
5173                 return -EINVAL;
5174         }
5175 }
5176
5177 char *format_bytes(char *buf, size_t l, off_t t) {
5178         unsigned i;
5179
5180         static const struct {
5181                 const char *suffix;
5182                 off_t factor;
5183         } table[] = {
5184                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5185                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5186                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5187                 { "G", 1024ULL*1024ULL*1024ULL },
5188                 { "M", 1024ULL*1024ULL },
5189                 { "K", 1024ULL },
5190         };
5191
5192         if (t == (off_t) -1)
5193                 return NULL;
5194
5195         for (i = 0; i < ELEMENTSOF(table); i++) {
5196
5197                 if (t >= table[i].factor) {
5198                         snprintf(buf, l,
5199                                  "%llu.%llu%s",
5200                                  (unsigned long long) (t / table[i].factor),
5201                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5202                                  table[i].suffix);
5203
5204                         goto finish;
5205                 }
5206         }
5207
5208         snprintf(buf, l, "%lluB", (unsigned long long) t);
5209
5210 finish:
5211         buf[l-1] = 0;
5212         return buf;
5213
5214 }
5215
5216 void* memdup(const void *p, size_t l) {
5217         void *r;
5218
5219         assert(p);
5220
5221         r = malloc(l);
5222         if (!r)
5223                 return NULL;
5224
5225         memcpy(r, p, l);
5226         return r;
5227 }
5228
5229 int fd_inc_sndbuf(int fd, size_t n) {
5230         int r, value;
5231         socklen_t l = sizeof(value);
5232
5233         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5234         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5235                 return 0;
5236
5237         /* If we have the privileges we will ignore the kernel limit. */
5238
5239         value = (int) n;
5240         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
5241                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
5242                         return -errno;
5243
5244         return 1;
5245 }
5246
5247 int fd_inc_rcvbuf(int fd, size_t n) {
5248         int r, value;
5249         socklen_t l = sizeof(value);
5250
5251         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5252         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5253                 return 0;
5254
5255         /* If we have the privileges we will ignore the kernel limit. */
5256
5257         value = (int) n;
5258         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
5259                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
5260                         return -errno;
5261         return 1;
5262 }
5263
5264 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5265         bool stdout_is_tty, stderr_is_tty;
5266         pid_t parent_pid, agent_pid;
5267         sigset_t ss, saved_ss;
5268         unsigned n, i;
5269         va_list ap;
5270         char **l;
5271
5272         assert(pid);
5273         assert(path);
5274
5275         /* Spawns a temporary TTY agent, making sure it goes away when
5276          * we go away */
5277
5278         parent_pid = getpid();
5279
5280         /* First we temporarily block all signals, so that the new
5281          * child has them blocked initially. This way, we can be sure
5282          * that SIGTERMs are not lost we might send to the agent. */
5283         assert_se(sigfillset(&ss) >= 0);
5284         assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
5285
5286         agent_pid = fork();
5287         if (agent_pid < 0) {
5288                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5289                 return -errno;
5290         }
5291
5292         if (agent_pid != 0) {
5293                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5294                 *pid = agent_pid;
5295                 return 0;
5296         }
5297
5298         /* In the child:
5299          *
5300          * Make sure the agent goes away when the parent dies */
5301         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5302                 _exit(EXIT_FAILURE);
5303
5304         /* Make sure we actually can kill the agent, if we need to, in
5305          * case somebody invoked us from a shell script that trapped
5306          * SIGTERM or so... */
5307         reset_all_signal_handlers();
5308         reset_signal_mask();
5309
5310         /* Check whether our parent died before we were able
5311          * to set the death signal and unblock the signals */
5312         if (getppid() != parent_pid)
5313                 _exit(EXIT_SUCCESS);
5314
5315         /* Don't leak fds to the agent */
5316         close_all_fds(except, n_except);
5317
5318         stdout_is_tty = isatty(STDOUT_FILENO);
5319         stderr_is_tty = isatty(STDERR_FILENO);
5320
5321         if (!stdout_is_tty || !stderr_is_tty) {
5322                 int fd;
5323
5324                 /* Detach from stdout/stderr. and reopen
5325                  * /dev/tty for them. This is important to
5326                  * ensure that when systemctl is started via
5327                  * popen() or a similar call that expects to
5328                  * read EOF we actually do generate EOF and
5329                  * not delay this indefinitely by because we
5330                  * keep an unused copy of stdin around. */
5331                 fd = open("/dev/tty", O_WRONLY);
5332                 if (fd < 0) {
5333                         log_error_errno(errno, "Failed to open /dev/tty: %m");
5334                         _exit(EXIT_FAILURE);
5335                 }
5336
5337                 if (!stdout_is_tty)
5338                         dup2(fd, STDOUT_FILENO);
5339
5340                 if (!stderr_is_tty)
5341                         dup2(fd, STDERR_FILENO);
5342
5343                 if (fd > 2)
5344                         close(fd);
5345         }
5346
5347         /* Count arguments */
5348         va_start(ap, path);
5349         for (n = 0; va_arg(ap, char*); n++)
5350                 ;
5351         va_end(ap);
5352
5353         /* Allocate strv */
5354         l = alloca(sizeof(char *) * (n + 1));
5355
5356         /* Fill in arguments */
5357         va_start(ap, path);
5358         for (i = 0; i <= n; i++)
5359                 l[i] = va_arg(ap, char*);
5360         va_end(ap);
5361
5362         execv(path, l);
5363         _exit(EXIT_FAILURE);
5364 }
5365
5366 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5367         struct rlimit highest, fixed;
5368
5369         assert(rlim);
5370
5371         if (setrlimit(resource, rlim) >= 0)
5372                 return 0;
5373
5374         if (errno != EPERM)
5375                 return -errno;
5376
5377         /* So we failed to set the desired setrlimit, then let's try
5378          * to get as close as we can */
5379         assert_se(getrlimit(resource, &highest) == 0);
5380
5381         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5382         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5383
5384         if (setrlimit(resource, &fixed) < 0)
5385                 return -errno;
5386
5387         return 0;
5388 }
5389
5390 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5391         _cleanup_fclose_ FILE *f = NULL;
5392         char *value = NULL;
5393         int r;
5394         bool done = false;
5395         size_t l;
5396         const char *path;
5397
5398         assert(pid >= 0);
5399         assert(field);
5400         assert(_value);
5401
5402         path = procfs_file_alloca(pid, "environ");
5403
5404         f = fopen(path, "re");
5405         if (!f)
5406                 return -errno;
5407
5408         l = strlen(field);
5409         r = 0;
5410
5411         do {
5412                 char line[LINE_MAX];
5413                 unsigned i;
5414
5415                 for (i = 0; i < sizeof(line)-1; i++) {
5416                         int c;
5417
5418                         c = getc(f);
5419                         if (_unlikely_(c == EOF)) {
5420                                 done = true;
5421                                 break;
5422                         } else if (c == 0)
5423                                 break;
5424
5425                         line[i] = c;
5426                 }
5427                 line[i] = 0;
5428
5429                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5430                         value = strdup(line + l + 1);
5431                         if (!value)
5432                                 return -ENOMEM;
5433
5434                         r = 1;
5435                         break;
5436                 }
5437
5438         } while (!done);
5439
5440         *_value = value;
5441         return r;
5442 }
5443
5444 bool http_etag_is_valid(const char *etag) {
5445         if (isempty(etag))
5446                 return false;
5447
5448         if (!endswith(etag, "\""))
5449                 return false;
5450
5451         if (!startswith(etag, "\"") && !startswith(etag, "W/\""))
5452                 return false;
5453
5454         return true;
5455 }
5456
5457 bool http_url_is_valid(const char *url) {
5458         const char *p;
5459
5460         if (isempty(url))
5461                 return false;
5462
5463         p = startswith(url, "http://");
5464         if (!p)
5465                 p = startswith(url, "https://");
5466         if (!p)
5467                 return false;
5468
5469         if (isempty(p))
5470                 return false;
5471
5472         return ascii_is_valid(p);
5473 }
5474
5475 bool documentation_url_is_valid(const char *url) {
5476         const char *p;
5477
5478         if (isempty(url))
5479                 return false;
5480
5481         if (http_url_is_valid(url))
5482                 return true;
5483
5484         p = startswith(url, "file:/");
5485         if (!p)
5486                 p = startswith(url, "info:");
5487         if (!p)
5488                 p = startswith(url, "man:");
5489
5490         if (isempty(p))
5491                 return false;
5492
5493         return ascii_is_valid(p);
5494 }
5495
5496 bool in_initrd(void) {
5497         static int saved = -1;
5498         struct statfs s;
5499
5500         if (saved >= 0)
5501                 return saved;
5502
5503         /* We make two checks here:
5504          *
5505          * 1. the flag file /etc/initrd-release must exist
5506          * 2. the root file system must be a memory file system
5507          *
5508          * The second check is extra paranoia, since misdetecting an
5509          * initrd can have bad bad consequences due the initrd
5510          * emptying when transititioning to the main systemd.
5511          */
5512
5513         saved = access("/etc/initrd-release", F_OK) >= 0 &&
5514                 statfs("/", &s) >= 0 &&
5515                 is_temporary_fs(&s);
5516
5517         return saved;
5518 }
5519
5520 void warn_melody(void) {
5521         _cleanup_close_ int fd = -1;
5522
5523         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5524         if (fd < 0)
5525                 return;
5526
5527         /* Yeah, this is synchronous. Kinda sucks. But well... */
5528
5529         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5530         usleep(125*USEC_PER_MSEC);
5531
5532         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5533         usleep(125*USEC_PER_MSEC);
5534
5535         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5536         usleep(125*USEC_PER_MSEC);
5537
5538         ioctl(fd, KIOCSOUND, 0);
5539 }
5540
5541 int make_console_stdio(void) {
5542         int fd, r;
5543
5544         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5545
5546         fd = acquire_terminal("/dev/console", false, true, true, USEC_INFINITY);
5547         if (fd < 0)
5548                 return log_error_errno(fd, "Failed to acquire terminal: %m");
5549
5550         r = make_stdio(fd);
5551         if (r < 0)
5552                 return log_error_errno(r, "Failed to duplicate terminal fd: %m");
5553
5554         return 0;
5555 }
5556
5557 int get_home_dir(char **_h) {
5558         struct passwd *p;
5559         const char *e;
5560         char *h;
5561         uid_t u;
5562
5563         assert(_h);
5564
5565         /* Take the user specified one */
5566         e = secure_getenv("HOME");
5567         if (e && path_is_absolute(e)) {
5568                 h = strdup(e);
5569                 if (!h)
5570                         return -ENOMEM;
5571
5572                 *_h = h;
5573                 return 0;
5574         }
5575
5576         /* Hardcode home directory for root to avoid NSS */
5577         u = getuid();
5578         if (u == 0) {
5579                 h = strdup("/root");
5580                 if (!h)
5581                         return -ENOMEM;
5582
5583                 *_h = h;
5584                 return 0;
5585         }
5586
5587         /* Check the database... */
5588         errno = 0;
5589         p = getpwuid(u);
5590         if (!p)
5591                 return errno > 0 ? -errno : -ESRCH;
5592
5593         if (!path_is_absolute(p->pw_dir))
5594                 return -EINVAL;
5595
5596         h = strdup(p->pw_dir);
5597         if (!h)
5598                 return -ENOMEM;
5599
5600         *_h = h;
5601         return 0;
5602 }
5603
5604 int get_shell(char **_s) {
5605         struct passwd *p;
5606         const char *e;
5607         char *s;
5608         uid_t u;
5609
5610         assert(_s);
5611
5612         /* Take the user specified one */
5613         e = getenv("SHELL");
5614         if (e) {
5615                 s = strdup(e);
5616                 if (!s)
5617                         return -ENOMEM;
5618
5619                 *_s = s;
5620                 return 0;
5621         }
5622
5623         /* Hardcode home directory for root to avoid NSS */
5624         u = getuid();
5625         if (u == 0) {
5626                 s = strdup("/bin/sh");
5627                 if (!s)
5628                         return -ENOMEM;
5629
5630                 *_s = s;
5631                 return 0;
5632         }
5633
5634         /* Check the database... */
5635         errno = 0;
5636         p = getpwuid(u);
5637         if (!p)
5638                 return errno > 0 ? -errno : -ESRCH;
5639
5640         if (!path_is_absolute(p->pw_shell))
5641                 return -EINVAL;
5642
5643         s = strdup(p->pw_shell);
5644         if (!s)
5645                 return -ENOMEM;
5646
5647         *_s = s;
5648         return 0;
5649 }
5650
5651 bool filename_is_valid(const char *p) {
5652
5653         if (isempty(p))
5654                 return false;
5655
5656         if (strchr(p, '/'))
5657                 return false;
5658
5659         if (streq(p, "."))
5660                 return false;
5661
5662         if (streq(p, ".."))
5663                 return false;
5664
5665         if (strlen(p) > FILENAME_MAX)
5666                 return false;
5667
5668         return true;
5669 }
5670
5671 bool string_is_safe(const char *p) {
5672         const char *t;
5673
5674         if (!p)
5675                 return false;
5676
5677         for (t = p; *t; t++) {
5678                 if (*t > 0 && *t < ' ')
5679                         return false;
5680
5681                 if (strchr("\\\"\'\0x7f", *t))
5682                         return false;
5683         }
5684
5685         return true;
5686 }
5687
5688 /**
5689  * Check if a string contains control characters. If 'ok' is non-NULL
5690  * it may be a string containing additional CCs to be considered OK.
5691  */
5692 bool string_has_cc(const char *p, const char *ok) {
5693         const char *t;
5694
5695         assert(p);
5696
5697         for (t = p; *t; t++) {
5698                 if (ok && strchr(ok, *t))
5699                         continue;
5700
5701                 if (*t > 0 && *t < ' ')
5702                         return true;
5703
5704                 if (*t == 127)
5705                         return true;
5706         }
5707
5708         return false;
5709 }
5710
5711 bool path_is_safe(const char *p) {
5712
5713         if (isempty(p))
5714                 return false;
5715
5716         if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5717                 return false;
5718
5719         if (strlen(p) > PATH_MAX)
5720                 return false;
5721
5722         /* The following two checks are not really dangerous, but hey, they still are confusing */
5723         if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5724                 return false;
5725
5726         if (strstr(p, "//"))
5727                 return false;
5728
5729         return true;
5730 }
5731
5732 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5733 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5734                  int (*compar) (const void *, const void *, void *), void *arg) {
5735         size_t l, u, idx;
5736         const void *p;
5737         int comparison;
5738
5739         l = 0;
5740         u = nmemb;
5741         while (l < u) {
5742                 idx = (l + u) / 2;
5743                 p = (void *)(((const char *) base) + (idx * size));
5744                 comparison = compar(key, p, arg);
5745                 if (comparison < 0)
5746                         u = idx;
5747                 else if (comparison > 0)
5748                         l = idx + 1;
5749                 else
5750                         return (void *)p;
5751         }
5752         return NULL;
5753 }
5754
5755 void init_gettext(void) {
5756         setlocale(LC_ALL, "");
5757         textdomain(GETTEXT_PACKAGE);
5758 }
5759
5760 bool is_locale_utf8(void) {
5761         const char *set;
5762         static int cached_answer = -1;
5763
5764         if (cached_answer >= 0)
5765                 goto out;
5766
5767         if (!setlocale(LC_ALL, "")) {
5768                 cached_answer = true;
5769                 goto out;
5770         }
5771
5772         set = nl_langinfo(CODESET);
5773         if (!set) {
5774                 cached_answer = true;
5775                 goto out;
5776         }
5777
5778         if (streq(set, "UTF-8")) {
5779                 cached_answer = true;
5780                 goto out;
5781         }
5782
5783         /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5784          * unset and everything can do to UTF-8 nowadays. */
5785         set = setlocale(LC_CTYPE, NULL);
5786         if (!set) {
5787                 cached_answer = true;
5788                 goto out;
5789         }
5790
5791         /* Check result, but ignore the result if C was set
5792          * explicitly. */
5793         cached_answer =
5794                 streq(set, "C") &&
5795                 !getenv("LC_ALL") &&
5796                 !getenv("LC_CTYPE") &&
5797                 !getenv("LANG");
5798
5799 out:
5800         return (bool) cached_answer;
5801 }
5802
5803 const char *draw_special_char(DrawSpecialChar ch) {
5804         static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5805
5806                 /* UTF-8 */ {
5807                         [DRAW_TREE_VERTICAL]      = "\342\224\202 ",            /* │  */
5808                         [DRAW_TREE_BRANCH]        = "\342\224\234\342\224\200", /* ├─ */
5809                         [DRAW_TREE_RIGHT]         = "\342\224\224\342\224\200", /* └─ */
5810                         [DRAW_TREE_SPACE]         = "  ",                       /*    */
5811                         [DRAW_TRIANGULAR_BULLET]  = "\342\200\243",             /* ‣ */
5812                         [DRAW_BLACK_CIRCLE]       = "\342\227\217",             /* ● */
5813                         [DRAW_ARROW]              = "\342\206\222",             /* → */
5814                         [DRAW_DASH]               = "\342\200\223",             /* – */
5815                 },
5816
5817                 /* ASCII fallback */ {
5818                         [DRAW_TREE_VERTICAL]      = "| ",
5819                         [DRAW_TREE_BRANCH]        = "|-",
5820                         [DRAW_TREE_RIGHT]         = "`-",
5821                         [DRAW_TREE_SPACE]         = "  ",
5822                         [DRAW_TRIANGULAR_BULLET]  = ">",
5823                         [DRAW_BLACK_CIRCLE]       = "*",
5824                         [DRAW_ARROW]              = "->",
5825                         [DRAW_DASH]               = "-",
5826                 }
5827         };
5828
5829         return draw_table[!is_locale_utf8()][ch];
5830 }
5831
5832 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5833         const char *f;
5834         char *t, *r;
5835         size_t l, old_len, new_len;
5836
5837         assert(text);
5838         assert(old_string);
5839         assert(new_string);
5840
5841         old_len = strlen(old_string);
5842         new_len = strlen(new_string);
5843
5844         l = strlen(text);
5845         r = new(char, l+1);
5846         if (!r)
5847                 return NULL;
5848
5849         f = text;
5850         t = r;
5851         while (*f) {
5852                 char *a;
5853                 size_t d, nl;
5854
5855                 if (!startswith(f, old_string)) {
5856                         *(t++) = *(f++);
5857                         continue;
5858                 }
5859
5860                 d = t - r;
5861                 nl = l - old_len + new_len;
5862                 a = realloc(r, nl + 1);
5863                 if (!a)
5864                         goto oom;
5865
5866                 l = nl;
5867                 r = a;
5868                 t = r + d;
5869
5870                 t = stpcpy(t, new_string);
5871                 f += old_len;
5872         }
5873
5874         *t = 0;
5875         return r;
5876
5877 oom:
5878         free(r);
5879         return NULL;
5880 }
5881
5882 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5883         const char *i, *begin = NULL;
5884         enum {
5885                 STATE_OTHER,
5886                 STATE_ESCAPE,
5887                 STATE_BRACKET
5888         } state = STATE_OTHER;
5889         char *obuf = NULL;
5890         size_t osz = 0, isz;
5891         FILE *f;
5892
5893         assert(ibuf);
5894         assert(*ibuf);
5895
5896         /* Strips ANSI color and replaces TABs by 8 spaces */
5897
5898         isz = _isz ? *_isz : strlen(*ibuf);
5899
5900         f = open_memstream(&obuf, &osz);
5901         if (!f)
5902                 return NULL;
5903
5904         for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5905
5906                 switch (state) {
5907
5908                 case STATE_OTHER:
5909                         if (i >= *ibuf + isz) /* EOT */
5910                                 break;
5911                         else if (*i == '\x1B')
5912                                 state = STATE_ESCAPE;
5913                         else if (*i == '\t')
5914                                 fputs("        ", f);
5915                         else
5916                                 fputc(*i, f);
5917                         break;
5918
5919                 case STATE_ESCAPE:
5920                         if (i >= *ibuf + isz) { /* EOT */
5921                                 fputc('\x1B', f);
5922                                 break;
5923                         } else if (*i == '[') {
5924                                 state = STATE_BRACKET;
5925                                 begin = i + 1;
5926                         } else {
5927                                 fputc('\x1B', f);
5928                                 fputc(*i, f);
5929                                 state = STATE_OTHER;
5930                         }
5931
5932                         break;
5933
5934                 case STATE_BRACKET:
5935
5936                         if (i >= *ibuf + isz || /* EOT */
5937                             (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5938                                 fputc('\x1B', f);
5939                                 fputc('[', f);
5940                                 state = STATE_OTHER;
5941                                 i = begin-1;
5942                         } else if (*i == 'm')
5943                                 state = STATE_OTHER;
5944                         break;
5945                 }
5946         }
5947
5948         if (ferror(f)) {
5949                 fclose(f);
5950                 free(obuf);
5951                 return NULL;
5952         }
5953
5954         fclose(f);
5955
5956         free(*ibuf);
5957         *ibuf = obuf;
5958
5959         if (_isz)
5960                 *_isz = osz;
5961
5962         return obuf;
5963 }
5964
5965 int on_ac_power(void) {
5966         bool found_offline = false, found_online = false;
5967         _cleanup_closedir_ DIR *d = NULL;
5968
5969         d = opendir("/sys/class/power_supply");
5970         if (!d)
5971                 return errno == ENOENT ? true : -errno;
5972
5973         for (;;) {
5974                 struct dirent *de;
5975                 _cleanup_close_ int fd = -1, device = -1;
5976                 char contents[6];
5977                 ssize_t n;
5978
5979                 errno = 0;
5980                 de = readdir(d);
5981                 if (!de && errno != 0)
5982                         return -errno;
5983
5984                 if (!de)
5985                         break;
5986
5987                 if (hidden_file(de->d_name))
5988                         continue;
5989
5990                 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5991                 if (device < 0) {
5992                         if (errno == ENOENT || errno == ENOTDIR)
5993                                 continue;
5994
5995                         return -errno;
5996                 }
5997
5998                 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5999                 if (fd < 0) {
6000                         if (errno == ENOENT)
6001                                 continue;
6002
6003                         return -errno;
6004                 }
6005
6006                 n = read(fd, contents, sizeof(contents));
6007                 if (n < 0)
6008                         return -errno;
6009
6010                 if (n != 6 || memcmp(contents, "Mains\n", 6))
6011                         continue;
6012
6013                 safe_close(fd);
6014                 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
6015                 if (fd < 0) {
6016                         if (errno == ENOENT)
6017                                 continue;
6018
6019                         return -errno;
6020                 }
6021
6022                 n = read(fd, contents, sizeof(contents));
6023                 if (n < 0)
6024                         return -errno;
6025
6026                 if (n != 2 || contents[1] != '\n')
6027                         return -EIO;
6028
6029                 if (contents[0] == '1') {
6030                         found_online = true;
6031                         break;
6032                 } else if (contents[0] == '0')
6033                         found_offline = true;
6034                 else
6035                         return -EIO;
6036         }
6037
6038         return found_online || !found_offline;
6039 }
6040
6041 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
6042         char **i;
6043
6044         assert(path);
6045         assert(mode);
6046         assert(_f);
6047
6048         if (!path_strv_resolve_uniq(search, root))
6049                 return -ENOMEM;
6050
6051         STRV_FOREACH(i, search) {
6052                 _cleanup_free_ char *p = NULL;
6053                 FILE *f;
6054
6055                 if (root)
6056                         p = strjoin(root, *i, "/", path, NULL);
6057                 else
6058                         p = strjoin(*i, "/", path, NULL);
6059                 if (!p)
6060                         return -ENOMEM;
6061
6062                 f = fopen(p, mode);
6063                 if (f) {
6064                         *_f = f;
6065                         return 0;
6066                 }
6067
6068                 if (errno != ENOENT)
6069                         return -errno;
6070         }
6071
6072         return -ENOENT;
6073 }
6074
6075 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
6076         _cleanup_strv_free_ char **copy = NULL;
6077
6078         assert(path);
6079         assert(mode);
6080         assert(_f);
6081
6082         if (path_is_absolute(path)) {
6083                 FILE *f;
6084
6085                 f = fopen(path, mode);
6086                 if (f) {
6087                         *_f = f;
6088                         return 0;
6089                 }
6090
6091                 return -errno;
6092         }
6093
6094         copy = strv_copy((char**) search);
6095         if (!copy)
6096                 return -ENOMEM;
6097
6098         return search_and_fopen_internal(path, mode, root, copy, _f);
6099 }
6100
6101 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
6102         _cleanup_strv_free_ char **s = NULL;
6103
6104         if (path_is_absolute(path)) {
6105                 FILE *f;
6106
6107                 f = fopen(path, mode);
6108                 if (f) {
6109                         *_f = f;
6110                         return 0;
6111                 }
6112
6113                 return -errno;
6114         }
6115
6116         s = strv_split_nulstr(search);
6117         if (!s)
6118                 return -ENOMEM;
6119
6120         return search_and_fopen_internal(path, mode, root, s, _f);
6121 }
6122
6123 char *strextend(char **x, ...) {
6124         va_list ap;
6125         size_t f, l;
6126         char *r, *p;
6127
6128         assert(x);
6129
6130         l = f = *x ? strlen(*x) : 0;
6131
6132         va_start(ap, x);
6133         for (;;) {
6134                 const char *t;
6135                 size_t n;
6136
6137                 t = va_arg(ap, const char *);
6138                 if (!t)
6139                         break;
6140
6141                 n = strlen(t);
6142                 if (n > ((size_t) -1) - l) {
6143                         va_end(ap);
6144                         return NULL;
6145                 }
6146
6147                 l += n;
6148         }
6149         va_end(ap);
6150
6151         r = realloc(*x, l+1);
6152         if (!r)
6153                 return NULL;
6154
6155         p = r + f;
6156
6157         va_start(ap, x);
6158         for (;;) {
6159                 const char *t;
6160
6161                 t = va_arg(ap, const char *);
6162                 if (!t)
6163                         break;
6164
6165                 p = stpcpy(p, t);
6166         }
6167         va_end(ap);
6168
6169         *p = 0;
6170         *x = r;
6171
6172         return r + l;
6173 }
6174
6175 char *strrep(const char *s, unsigned n) {
6176         size_t l;
6177         char *r, *p;
6178         unsigned i;
6179
6180         assert(s);
6181
6182         l = strlen(s);
6183         p = r = malloc(l * n + 1);
6184         if (!r)
6185                 return NULL;
6186
6187         for (i = 0; i < n; i++)
6188                 p = stpcpy(p, s);
6189
6190         *p = 0;
6191         return r;
6192 }
6193
6194 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
6195         size_t a, newalloc;
6196         void *q;
6197
6198         assert(p);
6199         assert(allocated);
6200
6201         if (*allocated >= need)
6202                 return *p;
6203
6204         newalloc = MAX(need * 2, 64u / size);
6205         a = newalloc * size;
6206
6207         /* check for overflows */
6208         if (a < size * need)
6209                 return NULL;
6210
6211         q = realloc(*p, a);
6212         if (!q)
6213                 return NULL;
6214
6215         *p = q;
6216         *allocated = newalloc;
6217         return q;
6218 }
6219
6220 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
6221         size_t prev;
6222         uint8_t *q;
6223
6224         assert(p);
6225         assert(allocated);
6226
6227         prev = *allocated;
6228
6229         q = greedy_realloc(p, allocated, need, size);
6230         if (!q)
6231                 return NULL;
6232
6233         if (*allocated > prev)
6234                 memzero(q + prev * size, (*allocated - prev) * size);
6235
6236         return q;
6237 }
6238
6239 bool id128_is_valid(const char *s) {
6240         size_t i, l;
6241
6242         l = strlen(s);
6243         if (l == 32) {
6244
6245                 /* Simple formatted 128bit hex string */
6246
6247                 for (i = 0; i < l; i++) {
6248                         char c = s[i];
6249
6250                         if (!(c >= '0' && c <= '9') &&
6251                             !(c >= 'a' && c <= 'z') &&
6252                             !(c >= 'A' && c <= 'Z'))
6253                                 return false;
6254                 }
6255
6256         } else if (l == 36) {
6257
6258                 /* Formatted UUID */
6259
6260                 for (i = 0; i < l; i++) {
6261                         char c = s[i];
6262
6263                         if ((i == 8 || i == 13 || i == 18 || i == 23)) {
6264                                 if (c != '-')
6265                                         return false;
6266                         } else {
6267                                 if (!(c >= '0' && c <= '9') &&
6268                                     !(c >= 'a' && c <= 'z') &&
6269                                     !(c >= 'A' && c <= 'Z'))
6270                                         return false;
6271                         }
6272                 }
6273
6274         } else
6275                 return false;
6276
6277         return true;
6278 }
6279
6280 int split_pair(const char *s, const char *sep, char **l, char **r) {
6281         char *x, *a, *b;
6282
6283         assert(s);
6284         assert(sep);
6285         assert(l);
6286         assert(r);
6287
6288         if (isempty(sep))
6289                 return -EINVAL;
6290
6291         x = strstr(s, sep);
6292         if (!x)
6293                 return -EINVAL;
6294
6295         a = strndup(s, x - s);
6296         if (!a)
6297                 return -ENOMEM;
6298
6299         b = strdup(x + strlen(sep));
6300         if (!b) {
6301                 free(a);
6302                 return -ENOMEM;
6303         }
6304
6305         *l = a;
6306         *r = b;
6307
6308         return 0;
6309 }
6310
6311 int shall_restore_state(void) {
6312         _cleanup_free_ char *value = NULL;
6313         int r;
6314
6315         r = get_proc_cmdline_key("systemd.restore_state=", &value);
6316         if (r < 0)
6317                 return r;
6318         if (r == 0)
6319                 return true;
6320
6321         return parse_boolean(value) != 0;
6322 }
6323
6324 int proc_cmdline(char **ret) {
6325         assert(ret);
6326
6327         if (detect_container(NULL) > 0)
6328                 return get_process_cmdline(1, 0, false, ret);
6329         else
6330                 return read_one_line_file("/proc/cmdline", ret);
6331 }
6332
6333 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6334         _cleanup_free_ char *line = NULL;
6335         const char *p;
6336         int r;
6337
6338         assert(parse_item);
6339
6340         r = proc_cmdline(&line);
6341         if (r < 0)
6342                 return r;
6343
6344         p = line;
6345         for (;;) {
6346                 _cleanup_free_ char *word = NULL;
6347                 char *value = NULL;
6348
6349                 r = unquote_first_word(&p, &word, UNQUOTE_RELAX);
6350                 if (r < 0)
6351                         return r;
6352                 if (r == 0)
6353                         break;
6354
6355                 /* Filter out arguments that are intended only for the
6356                  * initrd */
6357                 if (!in_initrd() && startswith(word, "rd."))
6358                         continue;
6359
6360                 value = strchr(word, '=');
6361                 if (value)
6362                         *(value++) = 0;
6363
6364                 r = parse_item(word, value);
6365                 if (r < 0)
6366                         return r;
6367         }
6368
6369         return 0;
6370 }
6371
6372 int get_proc_cmdline_key(const char *key, char **value) {
6373         _cleanup_free_ char *line = NULL, *ret = NULL;
6374         bool found = false;
6375         const char *p;
6376         int r;
6377
6378         assert(key);
6379
6380         r = proc_cmdline(&line);
6381         if (r < 0)
6382                 return r;
6383
6384         p = line;
6385         for (;;) {
6386                 _cleanup_free_ char *word = NULL;
6387                 const char *e;
6388
6389                 r = unquote_first_word(&p, &word, UNQUOTE_RELAX);
6390                 if (r < 0)
6391                         return r;
6392                 if (r == 0)
6393                         break;
6394
6395                 /* Filter out arguments that are intended only for the
6396                  * initrd */
6397                 if (!in_initrd() && startswith(word, "rd."))
6398                         continue;
6399
6400                 if (value) {
6401                         e = startswith(word, key);
6402                         if (!e)
6403                                 continue;
6404
6405                         r = free_and_strdup(&ret, e);
6406                         if (r < 0)
6407                                 return r;
6408
6409                         found = true;
6410                 } else {
6411                         if (streq(word, key))
6412                                 found = true;
6413                 }
6414         }
6415
6416         if (value) {
6417                 *value = ret;
6418                 ret = NULL;
6419         }
6420
6421         return found;
6422
6423 }
6424
6425 int container_get_leader(const char *machine, pid_t *pid) {
6426         _cleanup_free_ char *s = NULL, *class = NULL;
6427         const char *p;
6428         pid_t leader;
6429         int r;
6430
6431         assert(machine);
6432         assert(pid);
6433
6434         p = strjoina("/run/systemd/machines/", machine);
6435         r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6436         if (r == -ENOENT)
6437                 return -EHOSTDOWN;
6438         if (r < 0)
6439                 return r;
6440         if (!s)
6441                 return -EIO;
6442
6443         if (!streq_ptr(class, "container"))
6444                 return -EIO;
6445
6446         r = parse_pid(s, &leader);
6447         if (r < 0)
6448                 return r;
6449         if (leader <= 1)
6450                 return -EIO;
6451
6452         *pid = leader;
6453         return 0;
6454 }
6455
6456 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
6457         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
6458         int rfd = -1;
6459
6460         assert(pid >= 0);
6461
6462         if (mntns_fd) {
6463                 const char *mntns;
6464
6465                 mntns = procfs_file_alloca(pid, "ns/mnt");
6466                 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6467                 if (mntnsfd < 0)
6468                         return -errno;
6469         }
6470
6471         if (pidns_fd) {
6472                 const char *pidns;
6473
6474                 pidns = procfs_file_alloca(pid, "ns/pid");
6475                 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6476                 if (pidnsfd < 0)
6477                         return -errno;
6478         }
6479
6480         if (netns_fd) {
6481                 const char *netns;
6482
6483                 netns = procfs_file_alloca(pid, "ns/net");
6484                 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6485                 if (netnsfd < 0)
6486                         return -errno;
6487         }
6488
6489         if (root_fd) {
6490                 const char *root;
6491
6492                 root = procfs_file_alloca(pid, "root");
6493                 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6494                 if (rfd < 0)
6495                         return -errno;
6496         }
6497
6498         if (pidns_fd)
6499                 *pidns_fd = pidnsfd;
6500
6501         if (mntns_fd)
6502                 *mntns_fd = mntnsfd;
6503
6504         if (netns_fd)
6505                 *netns_fd = netnsfd;
6506
6507         if (root_fd)
6508                 *root_fd = rfd;
6509
6510         pidnsfd = mntnsfd = netnsfd = -1;
6511
6512         return 0;
6513 }
6514
6515 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
6516
6517         if (pidns_fd >= 0)
6518                 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6519                         return -errno;
6520
6521         if (mntns_fd >= 0)
6522                 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6523                         return -errno;
6524
6525         if (netns_fd >= 0)
6526                 if (setns(netns_fd, CLONE_NEWNET) < 0)
6527                         return -errno;
6528
6529         if (root_fd >= 0) {
6530                 if (fchdir(root_fd) < 0)
6531                         return -errno;
6532
6533                 if (chroot(".") < 0)
6534                         return -errno;
6535         }
6536
6537         if (setresgid(0, 0, 0) < 0)
6538                 return -errno;
6539
6540         if (setgroups(0, NULL) < 0)
6541                 return -errno;
6542
6543         if (setresuid(0, 0, 0) < 0)
6544                 return -errno;
6545
6546         return 0;
6547 }
6548
6549 bool pid_is_unwaited(pid_t pid) {
6550         /* Checks whether a PID is still valid at all, including a zombie */
6551
6552         if (pid <= 0)
6553                 return false;
6554
6555         if (kill(pid, 0) >= 0)
6556                 return true;
6557
6558         return errno != ESRCH;
6559 }
6560
6561 bool pid_is_alive(pid_t pid) {
6562         int r;
6563
6564         /* Checks whether a PID is still valid and not a zombie */
6565
6566         if (pid <= 0)
6567                 return false;
6568
6569         r = get_process_state(pid);
6570         if (r == -ENOENT || r == 'Z')
6571                 return false;
6572
6573         return true;
6574 }
6575
6576 int getpeercred(int fd, struct ucred *ucred) {
6577         socklen_t n = sizeof(struct ucred);
6578         struct ucred u;
6579         int r;
6580
6581         assert(fd >= 0);
6582         assert(ucred);
6583
6584         r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6585         if (r < 0)
6586                 return -errno;
6587
6588         if (n != sizeof(struct ucred))
6589                 return -EIO;
6590
6591         /* Check if the data is actually useful and not suppressed due
6592          * to namespacing issues */
6593         if (u.pid <= 0)
6594                 return -ENODATA;
6595         if (u.uid == UID_INVALID)
6596                 return -ENODATA;
6597         if (u.gid == GID_INVALID)
6598                 return -ENODATA;
6599
6600         *ucred = u;
6601         return 0;
6602 }
6603
6604 int getpeersec(int fd, char **ret) {
6605         socklen_t n = 64;
6606         char *s;
6607         int r;
6608
6609         assert(fd >= 0);
6610         assert(ret);
6611
6612         s = new0(char, n);
6613         if (!s)
6614                 return -ENOMEM;
6615
6616         r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6617         if (r < 0) {
6618                 free(s);
6619
6620                 if (errno != ERANGE)
6621                         return -errno;
6622
6623                 s = new0(char, n);
6624                 if (!s)
6625                         return -ENOMEM;
6626
6627                 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6628                 if (r < 0) {
6629                         free(s);
6630                         return -errno;
6631                 }
6632         }
6633
6634         if (isempty(s)) {
6635                 free(s);
6636                 return -EOPNOTSUPP;
6637         }
6638
6639         *ret = s;
6640         return 0;
6641 }
6642
6643 /* This is much like like mkostemp() but is subject to umask(). */
6644 int mkostemp_safe(char *pattern, int flags) {
6645         _cleanup_umask_ mode_t u;
6646         int fd;
6647
6648         assert(pattern);
6649
6650         u = umask(077);
6651
6652         fd = mkostemp(pattern, flags);
6653         if (fd < 0)
6654                 return -errno;
6655
6656         return fd;
6657 }
6658
6659 int open_tmpfile(const char *path, int flags) {
6660         char *p;
6661         int fd;
6662
6663         assert(path);
6664
6665 #ifdef O_TMPFILE
6666         /* Try O_TMPFILE first, if it is supported */
6667         fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6668         if (fd >= 0)
6669                 return fd;
6670 #endif
6671
6672         /* Fall back to unguessable name + unlinking */
6673         p = strjoina(path, "/systemd-tmp-XXXXXX");
6674
6675         fd = mkostemp_safe(p, flags);
6676         if (fd < 0)
6677                 return fd;
6678
6679         unlink(p);
6680         return fd;
6681 }
6682
6683 int fd_warn_permissions(const char *path, int fd) {
6684         struct stat st;
6685
6686         if (fstat(fd, &st) < 0)
6687                 return -errno;
6688
6689         if (st.st_mode & 0111)
6690                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6691
6692         if (st.st_mode & 0002)
6693                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6694
6695         if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6696                 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);
6697
6698         return 0;
6699 }
6700
6701 unsigned long personality_from_string(const char *p) {
6702
6703         /* Parse a personality specifier. We introduce our own
6704          * identifiers that indicate specific ABIs, rather than just
6705          * hints regarding the register size, since we want to keep
6706          * things open for multiple locally supported ABIs for the
6707          * same register size. We try to reuse the ABI identifiers
6708          * used by libseccomp. */
6709
6710 #if defined(__x86_64__)
6711
6712         if (streq(p, "x86"))
6713                 return PER_LINUX32;
6714
6715         if (streq(p, "x86-64"))
6716                 return PER_LINUX;
6717
6718 #elif defined(__i386__)
6719
6720         if (streq(p, "x86"))
6721                 return PER_LINUX;
6722 #endif
6723
6724         /* personality(7) documents that 0xffffffffUL is used for
6725          * querying the current personality, hence let's use that here
6726          * as error indicator. */
6727         return 0xffffffffUL;
6728 }
6729
6730 const char* personality_to_string(unsigned long p) {
6731
6732 #if defined(__x86_64__)
6733
6734         if (p == PER_LINUX32)
6735                 return "x86";
6736
6737         if (p == PER_LINUX)
6738                 return "x86-64";
6739
6740 #elif defined(__i386__)
6741
6742         if (p == PER_LINUX)
6743                 return "x86";
6744 #endif
6745
6746         return NULL;
6747 }
6748
6749 uint64_t physical_memory(void) {
6750         long mem;
6751
6752         /* We return this as uint64_t in case we are running as 32bit
6753          * process on a 64bit kernel with huge amounts of memory */
6754
6755         mem = sysconf(_SC_PHYS_PAGES);
6756         assert(mem > 0);
6757
6758         return (uint64_t) mem * (uint64_t) page_size();
6759 }
6760
6761 void hexdump(FILE *f, const void *p, size_t s) {
6762         const uint8_t *b = p;
6763         unsigned n = 0;
6764
6765         assert(s == 0 || b);
6766
6767         while (s > 0) {
6768                 size_t i;
6769
6770                 fprintf(f, "%04x  ", n);
6771
6772                 for (i = 0; i < 16; i++) {
6773
6774                         if (i >= s)
6775                                 fputs("   ", f);
6776                         else
6777                                 fprintf(f, "%02x ", b[i]);
6778
6779                         if (i == 7)
6780                                 fputc(' ', f);
6781                 }
6782
6783                 fputc(' ', f);
6784
6785                 for (i = 0; i < 16; i++) {
6786
6787                         if (i >= s)
6788                                 fputc(' ', f);
6789                         else
6790                                 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
6791                 }
6792
6793                 fputc('\n', f);
6794
6795                 if (s < 16)
6796                         break;
6797
6798                 n += 16;
6799                 b += 16;
6800                 s -= 16;
6801         }
6802 }
6803
6804 int update_reboot_param_file(const char *param) {
6805         int r = 0;
6806
6807         if (param) {
6808
6809                 r = write_string_file(REBOOT_PARAM_FILE, param);
6810                 if (r < 0)
6811                         log_error("Failed to write reboot param to "
6812                                   REBOOT_PARAM_FILE": %s", strerror(-r));
6813         } else
6814                 unlink(REBOOT_PARAM_FILE);
6815
6816         return r;
6817 }
6818
6819 int umount_recursive(const char *prefix, int flags) {
6820         bool again;
6821         int n = 0, r;
6822
6823         /* Try to umount everything recursively below a
6824          * directory. Also, take care of stacked mounts, and keep
6825          * unmounting them until they are gone. */
6826
6827         do {
6828                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6829
6830                 again = false;
6831                 r = 0;
6832
6833                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6834                 if (!proc_self_mountinfo)
6835                         return -errno;
6836
6837                 for (;;) {
6838                         _cleanup_free_ char *path = NULL, *p = NULL;
6839                         int k;
6840
6841                         k = fscanf(proc_self_mountinfo,
6842                                    "%*s "       /* (1) mount id */
6843                                    "%*s "       /* (2) parent id */
6844                                    "%*s "       /* (3) major:minor */
6845                                    "%*s "       /* (4) root */
6846                                    "%ms "       /* (5) mount point */
6847                                    "%*s"        /* (6) mount options */
6848                                    "%*[^-]"     /* (7) optional fields */
6849                                    "- "         /* (8) separator */
6850                                    "%*s "       /* (9) file system type */
6851                                    "%*s"        /* (10) mount source */
6852                                    "%*s"        /* (11) mount options 2 */
6853                                    "%*[^\n]",   /* some rubbish at the end */
6854                                    &path);
6855                         if (k != 1) {
6856                                 if (k == EOF)
6857                                         break;
6858
6859                                 continue;
6860                         }
6861
6862                         r = cunescape(path, UNESCAPE_RELAX, &p);
6863                         if (r < 0)
6864                                 return r;
6865
6866                         if (!path_startswith(p, prefix))
6867                                 continue;
6868
6869                         if (umount2(p, flags) < 0) {
6870                                 r = -errno;
6871                                 continue;
6872                         }
6873
6874                         again = true;
6875                         n++;
6876
6877                         break;
6878                 }
6879
6880         } while (again);
6881
6882         return r ? r : n;
6883 }
6884
6885 static int get_mount_flags(const char *path, unsigned long *flags) {
6886         struct statvfs buf;
6887
6888         if (statvfs(path, &buf) < 0)
6889                 return -errno;
6890         *flags = buf.f_flag;
6891         return 0;
6892 }
6893
6894 int bind_remount_recursive(const char *prefix, bool ro) {
6895         _cleanup_set_free_free_ Set *done = NULL;
6896         _cleanup_free_ char *cleaned = NULL;
6897         int r;
6898
6899         /* Recursively remount a directory (and all its submounts)
6900          * read-only or read-write. If the directory is already
6901          * mounted, we reuse the mount and simply mark it
6902          * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
6903          * operation). If it isn't we first make it one. Afterwards we
6904          * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
6905          * submounts we can access, too. When mounts are stacked on
6906          * the same mount point we only care for each individual
6907          * "top-level" mount on each point, as we cannot
6908          * influence/access the underlying mounts anyway. We do not
6909          * have any effect on future submounts that might get
6910          * propagated, they migt be writable. This includes future
6911          * submounts that have been triggered via autofs. */
6912
6913         cleaned = strdup(prefix);
6914         if (!cleaned)
6915                 return -ENOMEM;
6916
6917         path_kill_slashes(cleaned);
6918
6919         done = set_new(&string_hash_ops);
6920         if (!done)
6921                 return -ENOMEM;
6922
6923         for (;;) {
6924                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6925                 _cleanup_set_free_free_ Set *todo = NULL;
6926                 bool top_autofs = false;
6927                 char *x;
6928                 unsigned long orig_flags;
6929
6930                 todo = set_new(&string_hash_ops);
6931                 if (!todo)
6932                         return -ENOMEM;
6933
6934                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6935                 if (!proc_self_mountinfo)
6936                         return -errno;
6937
6938                 for (;;) {
6939                         _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
6940                         int k;
6941
6942                         k = fscanf(proc_self_mountinfo,
6943                                    "%*s "       /* (1) mount id */
6944                                    "%*s "       /* (2) parent id */
6945                                    "%*s "       /* (3) major:minor */
6946                                    "%*s "       /* (4) root */
6947                                    "%ms "       /* (5) mount point */
6948                                    "%*s"        /* (6) mount options (superblock) */
6949                                    "%*[^-]"     /* (7) optional fields */
6950                                    "- "         /* (8) separator */
6951                                    "%ms "       /* (9) file system type */
6952                                    "%*s"        /* (10) mount source */
6953                                    "%*s"        /* (11) mount options (bind mount) */
6954                                    "%*[^\n]",   /* some rubbish at the end */
6955                                    &path,
6956                                    &type);
6957                         if (k != 2) {
6958                                 if (k == EOF)
6959                                         break;
6960
6961                                 continue;
6962                         }
6963
6964                         r = cunescape(path, UNESCAPE_RELAX, &p);
6965                         if (r < 0)
6966                                 return r;
6967
6968                         /* Let's ignore autofs mounts.  If they aren't
6969                          * triggered yet, we want to avoid triggering
6970                          * them, as we don't make any guarantees for
6971                          * future submounts anyway.  If they are
6972                          * already triggered, then we will find
6973                          * another entry for this. */
6974                         if (streq(type, "autofs")) {
6975                                 top_autofs = top_autofs || path_equal(cleaned, p);
6976                                 continue;
6977                         }
6978
6979                         if (path_startswith(p, cleaned) &&
6980                             !set_contains(done, p)) {
6981
6982                                 r = set_consume(todo, p);
6983                                 p = NULL;
6984
6985                                 if (r == -EEXIST)
6986                                         continue;
6987                                 if (r < 0)
6988                                         return r;
6989                         }
6990                 }
6991
6992                 /* If we have no submounts to process anymore and if
6993                  * the root is either already done, or an autofs, we
6994                  * are done */
6995                 if (set_isempty(todo) &&
6996                     (top_autofs || set_contains(done, cleaned)))
6997                         return 0;
6998
6999                 if (!set_contains(done, cleaned) &&
7000                     !set_contains(todo, cleaned)) {
7001                         /* The prefix directory itself is not yet a
7002                          * mount, make it one. */
7003                         if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
7004                                 return -errno;
7005
7006                         orig_flags = 0;
7007                         (void) get_mount_flags(cleaned, &orig_flags);
7008                         orig_flags &= ~MS_RDONLY;
7009
7010                         if (mount(NULL, prefix, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
7011                                 return -errno;
7012
7013                         x = strdup(cleaned);
7014                         if (!x)
7015                                 return -ENOMEM;
7016
7017                         r = set_consume(done, x);
7018                         if (r < 0)
7019                                 return r;
7020                 }
7021
7022                 while ((x = set_steal_first(todo))) {
7023
7024                         r = set_consume(done, x);
7025                         if (r == -EEXIST)
7026                                 continue;
7027                         if (r < 0)
7028                                 return r;
7029
7030                         /* Try to reuse the original flag set, but
7031                          * don't care for errors, in case of
7032                          * obstructed mounts */
7033                         orig_flags = 0;
7034                         (void) get_mount_flags(x, &orig_flags);
7035                         orig_flags &= ~MS_RDONLY;
7036
7037                         if (mount(NULL, x, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
7038
7039                                 /* Deal with mount points that are
7040                                  * obstructed by a later mount */
7041
7042                                 if (errno != ENOENT)
7043                                         return -errno;
7044                         }
7045
7046                 }
7047         }
7048 }
7049
7050 int fflush_and_check(FILE *f) {
7051         assert(f);
7052
7053         errno = 0;
7054         fflush(f);
7055
7056         if (ferror(f))
7057                 return errno ? -errno : -EIO;
7058
7059         return 0;
7060 }
7061
7062 int tempfn_xxxxxx(const char *p, char **ret) {
7063         const char *fn;
7064         char *t;
7065
7066         assert(p);
7067         assert(ret);
7068
7069         /*
7070          * Turns this:
7071          *         /foo/bar/waldo
7072          *
7073          * Into this:
7074          *         /foo/bar/.#waldoXXXXXX
7075          */
7076
7077         fn = basename(p);
7078         if (!filename_is_valid(fn))
7079                 return -EINVAL;
7080
7081         t = new(char, strlen(p) + 2 + 6 + 1);
7082         if (!t)
7083                 return -ENOMEM;
7084
7085         strcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn), "XXXXXX");
7086
7087         *ret = path_kill_slashes(t);
7088         return 0;
7089 }
7090
7091 int tempfn_random(const char *p, char **ret) {
7092         const char *fn;
7093         char *t, *x;
7094         uint64_t u;
7095         unsigned i;
7096
7097         assert(p);
7098         assert(ret);
7099
7100         /*
7101          * Turns this:
7102          *         /foo/bar/waldo
7103          *
7104          * Into this:
7105          *         /foo/bar/.#waldobaa2a261115984a9
7106          */
7107
7108         fn = basename(p);
7109         if (!filename_is_valid(fn))
7110                 return -EINVAL;
7111
7112         t = new(char, strlen(p) + 2 + 16 + 1);
7113         if (!t)
7114                 return -ENOMEM;
7115
7116         x = stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn);
7117
7118         u = random_u64();
7119         for (i = 0; i < 16; i++) {
7120                 *(x++) = hexchar(u & 0xF);
7121                 u >>= 4;
7122         }
7123
7124         *x = 0;
7125
7126         *ret = path_kill_slashes(t);
7127         return 0;
7128 }
7129
7130 int tempfn_random_child(const char *p, char **ret) {
7131         char *t, *x;
7132         uint64_t u;
7133         unsigned i;
7134
7135         assert(p);
7136         assert(ret);
7137
7138         /* Turns this:
7139          *         /foo/bar/waldo
7140          * Into this:
7141          *         /foo/bar/waldo/.#3c2b6219aa75d7d0
7142          */
7143
7144         t = new(char, strlen(p) + 3 + 16 + 1);
7145         if (!t)
7146                 return -ENOMEM;
7147
7148         x = stpcpy(stpcpy(t, p), "/.#");
7149
7150         u = random_u64();
7151         for (i = 0; i < 16; i++) {
7152                 *(x++) = hexchar(u & 0xF);
7153                 u >>= 4;
7154         }
7155
7156         *x = 0;
7157
7158         *ret = path_kill_slashes(t);
7159         return 0;
7160 }
7161
7162 /* make sure the hostname is not "localhost" */
7163 bool is_localhost(const char *hostname) {
7164         assert(hostname);
7165
7166         /* This tries to identify local host and domain names
7167          * described in RFC6761 plus the redhatism of .localdomain */
7168
7169         return streq(hostname, "localhost") ||
7170                streq(hostname, "localhost.") ||
7171                streq(hostname, "localdomain.") ||
7172                streq(hostname, "localdomain") ||
7173                endswith(hostname, ".localhost") ||
7174                endswith(hostname, ".localhost.") ||
7175                endswith(hostname, ".localdomain") ||
7176                endswith(hostname, ".localdomain.");
7177 }
7178
7179 int take_password_lock(const char *root) {
7180
7181         struct flock flock = {
7182                 .l_type = F_WRLCK,
7183                 .l_whence = SEEK_SET,
7184                 .l_start = 0,
7185                 .l_len = 0,
7186         };
7187
7188         const char *path;
7189         int fd, r;
7190
7191         /* This is roughly the same as lckpwdf(), but not as awful. We
7192          * don't want to use alarm() and signals, hence we implement
7193          * our own trivial version of this.
7194          *
7195          * Note that shadow-utils also takes per-database locks in
7196          * addition to lckpwdf(). However, we don't given that they
7197          * are redundant as they they invoke lckpwdf() first and keep
7198          * it during everything they do. The per-database locks are
7199          * awfully racy, and thus we just won't do them. */
7200
7201         if (root)
7202                 path = strjoina(root, "/etc/.pwd.lock");
7203         else
7204                 path = "/etc/.pwd.lock";
7205
7206         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
7207         if (fd < 0)
7208                 return -errno;
7209
7210         r = fcntl(fd, F_SETLKW, &flock);
7211         if (r < 0) {
7212                 safe_close(fd);
7213                 return -errno;
7214         }
7215
7216         return fd;
7217 }
7218
7219 int is_symlink(const char *path) {
7220         struct stat info;
7221
7222         if (lstat(path, &info) < 0)
7223                 return -errno;
7224
7225         return !!S_ISLNK(info.st_mode);
7226 }
7227
7228 int is_dir(const char* path, bool follow) {
7229         struct stat st;
7230         int r;
7231
7232         if (follow)
7233                 r = stat(path, &st);
7234         else
7235                 r = lstat(path, &st);
7236         if (r < 0)
7237                 return -errno;
7238
7239         return !!S_ISDIR(st.st_mode);
7240 }
7241
7242 int unquote_first_word(const char **p, char **ret, UnquoteFlags flags) {
7243         _cleanup_free_ char *s = NULL;
7244         size_t allocated = 0, sz = 0;
7245         int r;
7246
7247         enum {
7248                 START,
7249                 VALUE,
7250                 VALUE_ESCAPE,
7251                 SINGLE_QUOTE,
7252                 SINGLE_QUOTE_ESCAPE,
7253                 DOUBLE_QUOTE,
7254                 DOUBLE_QUOTE_ESCAPE,
7255                 SPACE,
7256         } state = START;
7257
7258         assert(p);
7259         assert(*p);
7260         assert(ret);
7261
7262         /* Parses the first word of a string, and returns it in
7263          * *ret. Removes all quotes in the process. When parsing fails
7264          * (because of an uneven number of quotes or similar), leaves
7265          * the pointer *p at the first invalid character. */
7266
7267         for (;;) {
7268                 char c = **p;
7269
7270                 switch (state) {
7271
7272                 case START:
7273                         if (c == 0)
7274                                 goto finish;
7275                         else if (strchr(WHITESPACE, c))
7276                                 break;
7277
7278                         state = VALUE;
7279                         /* fallthrough */
7280
7281                 case VALUE:
7282                         if (c == 0)
7283                                 goto finish;
7284                         else if (c == '\'')
7285                                 state = SINGLE_QUOTE;
7286                         else if (c == '\\')
7287                                 state = VALUE_ESCAPE;
7288                         else if (c == '\"')
7289                                 state = DOUBLE_QUOTE;
7290                         else if (strchr(WHITESPACE, c))
7291                                 state = SPACE;
7292                         else {
7293                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7294                                         return -ENOMEM;
7295
7296                                 s[sz++] = c;
7297                         }
7298
7299                         break;
7300
7301                 case VALUE_ESCAPE:
7302                         if (c == 0) {
7303                                 if (flags & UNQUOTE_RELAX)
7304                                         goto finish;
7305                                 return -EINVAL;
7306                         }
7307
7308                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7309                                 return -ENOMEM;
7310
7311                         if (flags & UNQUOTE_CUNESCAPE) {
7312                                 uint32_t u;
7313
7314                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
7315                                 if (r < 0)
7316                                         return -EINVAL;
7317
7318                                 (*p) += r - 1;
7319
7320                                 if (c != 0)
7321                                         s[sz++] = c; /* normal explicit char */
7322                                 else
7323                                         sz += utf8_encode_unichar(s, u); /* unicode chars we'll encode as utf8 */
7324                         } else
7325                                 s[sz++] = c;
7326
7327                         state = VALUE;
7328                         break;
7329
7330                 case SINGLE_QUOTE:
7331                         if (c == 0) {
7332                                 if (flags & UNQUOTE_RELAX)
7333                                         goto finish;
7334                                 return -EINVAL;
7335                         } else if (c == '\'')
7336                                 state = VALUE;
7337                         else if (c == '\\')
7338                                 state = SINGLE_QUOTE_ESCAPE;
7339                         else {
7340                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7341                                         return -ENOMEM;
7342
7343                                 s[sz++] = c;
7344                         }
7345
7346                         break;
7347
7348                 case SINGLE_QUOTE_ESCAPE:
7349                         if (c == 0) {
7350                                 if (flags & UNQUOTE_RELAX)
7351                                         goto finish;
7352                                 return -EINVAL;
7353                         }
7354
7355                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7356                                 return -ENOMEM;
7357
7358                         if (flags & UNQUOTE_CUNESCAPE) {
7359                                 uint32_t u;
7360
7361                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
7362                                 if (r < 0)
7363                                         return -EINVAL;
7364
7365                                 (*p) += r - 1;
7366
7367                                 if (c != 0)
7368                                         s[sz++] = c;
7369                                 else
7370                                         sz += utf8_encode_unichar(s, u);
7371                         } else
7372                                 s[sz++] = c;
7373
7374                         state = SINGLE_QUOTE;
7375                         break;
7376
7377                 case DOUBLE_QUOTE:
7378                         if (c == 0)
7379                                 return -EINVAL;
7380                         else if (c == '\"')
7381                                 state = VALUE;
7382                         else if (c == '\\')
7383                                 state = DOUBLE_QUOTE_ESCAPE;
7384                         else {
7385                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7386                                         return -ENOMEM;
7387
7388                                 s[sz++] = c;
7389                         }
7390
7391                         break;
7392
7393                 case DOUBLE_QUOTE_ESCAPE:
7394                         if (c == 0) {
7395                                 if (flags & UNQUOTE_RELAX)
7396                                         goto finish;
7397                                 return -EINVAL;
7398                         }
7399
7400                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7401                                 return -ENOMEM;
7402
7403                         if (flags & UNQUOTE_CUNESCAPE) {
7404                                 uint32_t u;
7405
7406                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
7407                                 if (r < 0)
7408                                         return -EINVAL;
7409
7410                                 (*p) += r - 1;
7411
7412                                 if (c != 0)
7413                                         s[sz++] = c;
7414                                 else
7415                                         sz += utf8_encode_unichar(s, u);
7416                         } else
7417                                 s[sz++] = c;
7418
7419                         state = DOUBLE_QUOTE;
7420                         break;
7421
7422                 case SPACE:
7423                         if (c == 0)
7424                                 goto finish;
7425                         if (!strchr(WHITESPACE, c))
7426                                 goto finish;
7427
7428                         break;
7429                 }
7430
7431                 (*p) ++;
7432         }
7433
7434 finish:
7435         if (!s) {
7436                 *ret = NULL;
7437                 return 0;
7438         }
7439
7440         s[sz] = 0;
7441         *ret = s;
7442         s = NULL;
7443
7444         return 1;
7445 }
7446
7447 int unquote_many_words(const char **p, UnquoteFlags flags, ...) {
7448         va_list ap;
7449         char **l;
7450         int n = 0, i, c, r;
7451
7452         /* Parses a number of words from a string, stripping any
7453          * quotes if necessary. */
7454
7455         assert(p);
7456
7457         /* Count how many words are expected */
7458         va_start(ap, flags);
7459         for (;;) {
7460                 if (!va_arg(ap, char **))
7461                         break;
7462                 n++;
7463         }
7464         va_end(ap);
7465
7466         if (n <= 0)
7467                 return 0;
7468
7469         /* Read all words into a temporary array */
7470         l = newa0(char*, n);
7471         for (c = 0; c < n; c++) {
7472
7473                 r = unquote_first_word(p, &l[c], flags);
7474                 if (r < 0) {
7475                         int j;
7476
7477                         for (j = 0; j < c; j++)
7478                                 free(l[j]);
7479
7480                         return r;
7481                 }
7482
7483                 if (r == 0)
7484                         break;
7485         }
7486
7487         /* If we managed to parse all words, return them in the passed
7488          * in parameters */
7489         va_start(ap, flags);
7490         for (i = 0; i < n; i++) {
7491                 char **v;
7492
7493                 v = va_arg(ap, char **);
7494                 assert(v);
7495
7496                 *v = l[i];
7497         }
7498         va_end(ap);
7499
7500         return c;
7501 }
7502
7503 int free_and_strdup(char **p, const char *s) {
7504         char *t;
7505
7506         assert(p);
7507
7508         /* Replaces a string pointer with an strdup()ed new string,
7509          * possibly freeing the old one. */
7510
7511         if (s) {
7512                 t = strdup(s);
7513                 if (!t)
7514                         return -ENOMEM;
7515         } else
7516                 t = NULL;
7517
7518         free(*p);
7519         *p = t;
7520
7521         return 0;
7522 }
7523
7524 int sethostname_idempotent(const char *s) {
7525         int r;
7526         char buf[HOST_NAME_MAX + 1] = {};
7527
7528         assert(s);
7529
7530         r = gethostname(buf, sizeof(buf));
7531         if (r < 0)
7532                 return -errno;
7533
7534         if (streq(buf, s))
7535                 return 0;
7536
7537         r = sethostname(s, strlen(s));
7538         if (r < 0)
7539                 return -errno;
7540
7541         return 1;
7542 }
7543
7544 int ptsname_malloc(int fd, char **ret) {
7545         size_t l = 100;
7546
7547         assert(fd >= 0);
7548         assert(ret);
7549
7550         for (;;) {
7551                 char *c;
7552
7553                 c = new(char, l);
7554                 if (!c)
7555                         return -ENOMEM;
7556
7557                 if (ptsname_r(fd, c, l) == 0) {
7558                         *ret = c;
7559                         return 0;
7560                 }
7561                 if (errno != ERANGE) {
7562                         free(c);
7563                         return -errno;
7564                 }
7565
7566                 free(c);
7567                 l *= 2;
7568         }
7569 }
7570
7571 int openpt_in_namespace(pid_t pid, int flags) {
7572         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, rootfd = -1;
7573         _cleanup_close_pair_ int pair[2] = { -1, -1 };
7574         union {
7575                 struct cmsghdr cmsghdr;
7576                 uint8_t buf[CMSG_SPACE(sizeof(int))];
7577         } control = {};
7578         struct msghdr mh = {
7579                 .msg_control = &control,
7580                 .msg_controllen = sizeof(control),
7581         };
7582         struct cmsghdr *cmsg;
7583         siginfo_t si;
7584         pid_t child;
7585         int r;
7586
7587         assert(pid > 0);
7588
7589         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &rootfd);
7590         if (r < 0)
7591                 return r;
7592
7593         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
7594                 return -errno;
7595
7596         child = fork();
7597         if (child < 0)
7598                 return -errno;
7599
7600         if (child == 0) {
7601                 int master;
7602
7603                 pair[0] = safe_close(pair[0]);
7604
7605                 r = namespace_enter(pidnsfd, mntnsfd, -1, rootfd);
7606                 if (r < 0)
7607                         _exit(EXIT_FAILURE);
7608
7609                 master = posix_openpt(flags);
7610                 if (master < 0)
7611                         _exit(EXIT_FAILURE);
7612
7613                 cmsg = CMSG_FIRSTHDR(&mh);
7614                 cmsg->cmsg_level = SOL_SOCKET;
7615                 cmsg->cmsg_type = SCM_RIGHTS;
7616                 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
7617                 memcpy(CMSG_DATA(cmsg), &master, sizeof(int));
7618
7619                 mh.msg_controllen = cmsg->cmsg_len;
7620
7621                 if (sendmsg(pair[1], &mh, MSG_NOSIGNAL) < 0)
7622                         _exit(EXIT_FAILURE);
7623
7624                 _exit(EXIT_SUCCESS);
7625         }
7626
7627         pair[1] = safe_close(pair[1]);
7628
7629         r = wait_for_terminate(child, &si);
7630         if (r < 0)
7631                 return r;
7632         if (si.si_code != CLD_EXITED || si.si_status != EXIT_SUCCESS)
7633                 return -EIO;
7634
7635         if (recvmsg(pair[0], &mh, MSG_NOSIGNAL|MSG_CMSG_CLOEXEC) < 0)
7636                 return -errno;
7637
7638         for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg))
7639                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
7640                         int *fds;
7641                         unsigned n_fds;
7642
7643                         fds = (int*) CMSG_DATA(cmsg);
7644                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
7645
7646                         if (n_fds != 1) {
7647                                 close_many(fds, n_fds);
7648                                 return -EIO;
7649                         }
7650
7651                         return fds[0];
7652                 }
7653
7654         return -EIO;
7655 }
7656
7657 ssize_t fgetxattrat_fake(int dirfd, const char *filename, const char *attribute, void *value, size_t size, int flags) {
7658         _cleanup_close_ int fd = -1;
7659         ssize_t l;
7660
7661         /* The kernel doesn't have a fgetxattrat() command, hence let's emulate one */
7662
7663         fd = openat(dirfd, filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOATIME|(flags & AT_SYMLINK_NOFOLLOW ? O_NOFOLLOW : 0));
7664         if (fd < 0)
7665                 return -errno;
7666
7667         l = fgetxattr(fd, attribute, value, size);
7668         if (l < 0)
7669                 return -errno;
7670
7671         return l;
7672 }
7673
7674 static int parse_crtime(le64_t le, usec_t *usec) {
7675         uint64_t u;
7676
7677         assert(usec);
7678
7679         u = le64toh(le);
7680         if (u == 0 || u == (uint64_t) -1)
7681                 return -EIO;
7682
7683         *usec = (usec_t) u;
7684         return 0;
7685 }
7686
7687 int fd_getcrtime(int fd, usec_t *usec) {
7688         le64_t le;
7689         ssize_t n;
7690
7691         assert(fd >= 0);
7692         assert(usec);
7693
7694         /* Until Linux gets a real concept of birthtime/creation time,
7695          * let's fake one with xattrs */
7696
7697         n = fgetxattr(fd, "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_getcrtime_at(int dirfd, const char *name, usec_t *usec, int flags) {
7707         le64_t le;
7708         ssize_t n;
7709
7710         n = fgetxattrat_fake(dirfd, name, "user.crtime_usec", &le, sizeof(le), flags);
7711         if (n < 0)
7712                 return -errno;
7713         if (n != sizeof(le))
7714                 return -EIO;
7715
7716         return parse_crtime(le, usec);
7717 }
7718
7719 int path_getcrtime(const char *p, usec_t *usec) {
7720         le64_t le;
7721         ssize_t n;
7722
7723         assert(p);
7724         assert(usec);
7725
7726         n = getxattr(p, "user.crtime_usec", &le, sizeof(le));
7727         if (n < 0)
7728                 return -errno;
7729         if (n != sizeof(le))
7730                 return -EIO;
7731
7732         return parse_crtime(le, usec);
7733 }
7734
7735 int fd_setcrtime(int fd, usec_t usec) {
7736         le64_t le;
7737
7738         assert(fd >= 0);
7739
7740         if (usec <= 0)
7741                 usec = now(CLOCK_REALTIME);
7742
7743         le = htole64((uint64_t) usec);
7744         if (fsetxattr(fd, "user.crtime_usec", &le, sizeof(le), 0) < 0)
7745                 return -errno;
7746
7747         return 0;
7748 }
7749
7750 int chattr_fd(int fd, unsigned value, unsigned mask) {
7751         unsigned old_attr, new_attr;
7752
7753         assert(fd >= 0);
7754
7755         if (mask == 0)
7756                 return 0;
7757
7758         if (ioctl(fd, FS_IOC_GETFLAGS, &old_attr) < 0)
7759                 return -errno;
7760
7761         new_attr = (old_attr & ~mask) | (value & mask);
7762         if (new_attr == old_attr)
7763                 return 0;
7764
7765         if (ioctl(fd, FS_IOC_SETFLAGS, &new_attr) < 0)
7766                 return -errno;
7767
7768         return 1;
7769 }
7770
7771 int chattr_path(const char *p, unsigned value, unsigned mask) {
7772         _cleanup_close_ int fd = -1;
7773
7774         assert(p);
7775
7776         if (mask == 0)
7777                 return 0;
7778
7779         fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
7780         if (fd < 0)
7781                 return -errno;
7782
7783         return chattr_fd(fd, value, mask);
7784 }
7785
7786 int read_attr_fd(int fd, unsigned *ret) {
7787         assert(fd >= 0);
7788
7789         if (ioctl(fd, FS_IOC_GETFLAGS, ret) < 0)
7790                 return -errno;
7791
7792         return 0;
7793 }
7794
7795 int read_attr_path(const char *p, unsigned *ret) {
7796         _cleanup_close_ int fd = -1;
7797
7798         assert(p);
7799         assert(ret);
7800
7801         fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
7802         if (fd < 0)
7803                 return -errno;
7804
7805         return read_attr_fd(fd, ret);
7806 }
7807
7808 int make_lock_file(const char *p, int operation, LockFile *ret) {
7809         _cleanup_close_ int fd = -1;
7810         _cleanup_free_ char *t = NULL;
7811         int r;
7812
7813         /*
7814          * We use UNPOSIX locks if they are available. They have nice
7815          * semantics, and are mostly compatible with NFS. However,
7816          * they are only available on new kernels. When we detect we
7817          * are running on an older kernel, then we fall back to good
7818          * old BSD locks. They also have nice semantics, but are
7819          * slightly problematic on NFS, where they are upgraded to
7820          * POSIX locks, even though locally they are orthogonal to
7821          * POSIX locks.
7822          */
7823
7824         t = strdup(p);
7825         if (!t)
7826                 return -ENOMEM;
7827
7828         for (;;) {
7829                 struct flock fl = {
7830                         .l_type = (operation & ~LOCK_NB) == LOCK_EX ? F_WRLCK : F_RDLCK,
7831                         .l_whence = SEEK_SET,
7832                 };
7833                 struct stat st;
7834
7835                 fd = open(p, O_CREAT|O_RDWR|O_NOFOLLOW|O_CLOEXEC|O_NOCTTY, 0600);
7836                 if (fd < 0)
7837                         return -errno;
7838
7839                 r = fcntl(fd, (operation & LOCK_NB) ? F_OFD_SETLK : F_OFD_SETLKW, &fl);
7840                 if (r < 0) {
7841
7842                         /* If the kernel is too old, use good old BSD locks */
7843                         if (errno == EINVAL)
7844                                 r = flock(fd, operation);
7845
7846                         if (r < 0)
7847                                 return errno == EAGAIN ? -EBUSY : -errno;
7848                 }
7849
7850                 /* If we acquired the lock, let's check if the file
7851                  * still exists in the file system. If not, then the
7852                  * previous exclusive owner removed it and then closed
7853                  * it. In such a case our acquired lock is worthless,
7854                  * hence try again. */
7855
7856                 r = fstat(fd, &st);
7857                 if (r < 0)
7858                         return -errno;
7859                 if (st.st_nlink > 0)
7860                         break;
7861
7862                 fd = safe_close(fd);
7863         }
7864
7865         ret->path = t;
7866         ret->fd = fd;
7867         ret->operation = operation;
7868
7869         fd = -1;
7870         t = NULL;
7871
7872         return r;
7873 }
7874
7875 int make_lock_file_for(const char *p, int operation, LockFile *ret) {
7876         const char *fn;
7877         char *t;
7878
7879         assert(p);
7880         assert(ret);
7881
7882         fn = basename(p);
7883         if (!filename_is_valid(fn))
7884                 return -EINVAL;
7885
7886         t = newa(char, strlen(p) + 2 + 4 + 1);
7887         stpcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn), ".lck");
7888
7889         return make_lock_file(t, operation, ret);
7890 }
7891
7892 void release_lock_file(LockFile *f) {
7893         int r;
7894
7895         if (!f)
7896                 return;
7897
7898         if (f->path) {
7899
7900                 /* If we are the exclusive owner we can safely delete
7901                  * the lock file itself. If we are not the exclusive
7902                  * owner, we can try becoming it. */
7903
7904                 if (f->fd >= 0 &&
7905                     (f->operation & ~LOCK_NB) == LOCK_SH) {
7906                         static const struct flock fl = {
7907                                 .l_type = F_WRLCK,
7908                                 .l_whence = SEEK_SET,
7909                         };
7910
7911                         r = fcntl(f->fd, F_OFD_SETLK, &fl);
7912                         if (r < 0 && errno == EINVAL)
7913                                 r = flock(f->fd, LOCK_EX|LOCK_NB);
7914
7915                         if (r >= 0)
7916                                 f->operation = LOCK_EX|LOCK_NB;
7917                 }
7918
7919                 if ((f->operation & ~LOCK_NB) == LOCK_EX)
7920                         unlink_noerrno(f->path);
7921
7922                 free(f->path);
7923                 f->path = NULL;
7924         }
7925
7926         f->fd = safe_close(f->fd);
7927         f->operation = 0;
7928 }
7929
7930 static size_t nul_length(const uint8_t *p, size_t sz) {
7931         size_t n = 0;
7932
7933         while (sz > 0) {
7934                 if (*p != 0)
7935                         break;
7936
7937                 n++;
7938                 p++;
7939                 sz--;
7940         }
7941
7942         return n;
7943 }
7944
7945 ssize_t sparse_write(int fd, const void *p, size_t sz, size_t run_length) {
7946         const uint8_t *q, *w, *e;
7947         ssize_t l;
7948
7949         q = w = p;
7950         e = q + sz;
7951         while (q < e) {
7952                 size_t n;
7953
7954                 n = nul_length(q, e - q);
7955
7956                 /* If there are more than the specified run length of
7957                  * NUL bytes, or if this is the beginning or the end
7958                  * of the buffer, then seek instead of write */
7959                 if ((n > run_length) ||
7960                     (n > 0 && q == p) ||
7961                     (n > 0 && q + n >= e)) {
7962                         if (q > w) {
7963                                 l = write(fd, w, q - w);
7964                                 if (l < 0)
7965                                         return -errno;
7966                                 if (l != q -w)
7967                                         return -EIO;
7968                         }
7969
7970                         if (lseek(fd, n, SEEK_CUR) == (off_t) -1)
7971                                 return -errno;
7972
7973                         q += n;
7974                         w = q;
7975                 } else if (n > 0)
7976                         q += n;
7977                 else
7978                         q ++;
7979         }
7980
7981         if (q > w) {
7982                 l = write(fd, w, q - w);
7983                 if (l < 0)
7984                         return -errno;
7985                 if (l != q - w)
7986                         return -EIO;
7987         }
7988
7989         return q - (const uint8_t*) p;
7990 }
7991
7992 void sigkill_wait(pid_t *pid) {
7993         if (!pid)
7994                 return;
7995         if (*pid <= 1)
7996                 return;
7997
7998         if (kill(*pid, SIGKILL) > 0)
7999                 (void) wait_for_terminate(*pid, NULL);
8000 }
8001
8002 int syslog_parse_priority(const char **p, int *priority, bool with_facility) {
8003         int a = 0, b = 0, c = 0;
8004         int k;
8005
8006         assert(p);
8007         assert(*p);
8008         assert(priority);
8009
8010         if ((*p)[0] != '<')
8011                 return 0;
8012
8013         if (!strchr(*p, '>'))
8014                 return 0;
8015
8016         if ((*p)[2] == '>') {
8017                 c = undecchar((*p)[1]);
8018                 k = 3;
8019         } else if ((*p)[3] == '>') {
8020                 b = undecchar((*p)[1]);
8021                 c = undecchar((*p)[2]);
8022                 k = 4;
8023         } else if ((*p)[4] == '>') {
8024                 a = undecchar((*p)[1]);
8025                 b = undecchar((*p)[2]);
8026                 c = undecchar((*p)[3]);
8027                 k = 5;
8028         } else
8029                 return 0;
8030
8031         if (a < 0 || b < 0 || c < 0 ||
8032             (!with_facility && (a || b || c > 7)))
8033                 return 0;
8034
8035         if (with_facility)
8036                 *priority = a*100 + b*10 + c;
8037         else
8038                 *priority = (*priority & LOG_FACMASK) | c;
8039
8040         *p += k;
8041         return 1;
8042 }
8043
8044 ssize_t string_table_lookup(const char * const *table, size_t len, const char *key) {
8045         size_t i;
8046
8047         if (!key)
8048                 return -1;
8049
8050         for (i = 0; i < len; ++i)
8051                 if (streq_ptr(table[i], key))
8052                         return (ssize_t)i;
8053
8054         return -1;
8055 }
8056
8057 void cmsg_close_all(struct msghdr *mh) {
8058         struct cmsghdr *cmsg;
8059
8060         assert(mh);
8061
8062         for (cmsg = CMSG_FIRSTHDR(mh); cmsg; cmsg = CMSG_NXTHDR(mh, cmsg))
8063                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS)
8064                         close_many((int*) CMSG_DATA(cmsg), (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int));
8065 }
8066
8067 int rename_noreplace(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
8068         struct stat buf;
8069         int ret;
8070
8071         ret = renameat2(olddirfd, oldpath, newdirfd, newpath, RENAME_NOREPLACE);
8072         if (ret >= 0)
8073                 return 0;
8074
8075         /* Even though renameat2() exists since Linux 3.15, btrfs added
8076          * support for it later. If it is not implemented, fallback to another
8077          * method. */
8078         if (errno != EINVAL)
8079                 return -errno;
8080
8081         /* The link()/unlink() fallback does not work on directories. But
8082          * renameat() without RENAME_NOREPLACE gives the same semantics on
8083          * directories, except when newpath is an *empty* directory. This is
8084          * good enough. */
8085         ret = fstatat(olddirfd, oldpath, &buf, AT_SYMLINK_NOFOLLOW);
8086         if (ret >= 0 && S_ISDIR(buf.st_mode)) {
8087                 ret = renameat(olddirfd, oldpath, newdirfd, newpath);
8088                 return ret >= 0 ? 0 : -errno;
8089         }
8090
8091         /* If it is not a directory, use the link()/unlink() fallback. */
8092         ret = linkat(olddirfd, oldpath, newdirfd, newpath, 0);
8093         if (ret < 0)
8094                 return -errno;
8095
8096         ret = unlinkat(olddirfd, oldpath, 0);
8097         if (ret < 0) {
8098                 /* backup errno before the following unlinkat() alters it */
8099                 ret = errno;
8100                 (void) unlinkat(newdirfd, newpath, 0);
8101                 errno = ret;
8102                 return -errno;
8103         }
8104
8105         return 0;
8106 }
8107
8108 char *shell_maybe_quote(const char *s) {
8109         const char *p;
8110         char *r, *t;
8111
8112         assert(s);
8113
8114         /* Encloses a string in double quotes if necessary to make it
8115          * OK as shell string. */
8116
8117         for (p = s; *p; p++)
8118                 if (*p <= ' ' ||
8119                     *p >= 127 ||
8120                     strchr(SHELL_NEED_QUOTES, *p))
8121                         break;
8122
8123         if (!*p)
8124                 return strdup(s);
8125
8126         r = new(char, 1+strlen(s)*2+1+1);
8127         if (!r)
8128                 return NULL;
8129
8130         t = r;
8131         *(t++) = '"';
8132         t = mempcpy(t, s, p - s);
8133
8134         for (; *p; p++) {
8135
8136                 if (strchr(SHELL_NEED_ESCAPE, *p))
8137                         *(t++) = '\\';
8138
8139                 *(t++) = *p;
8140         }
8141
8142         *(t++)= '"';
8143         *t = 0;
8144
8145         return r;
8146 }