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