src/shared/util.c

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