src/shared/util.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <errno.h>
  25 #include <stdlib.h>
  26 #include <signal.h>
  27 #include <libintl.h>
  28 #include <stdio.h>
  29 #include <syslog.h>
  30 #include <sched.h>
  31 #include <sys/resource.h>
  32 #include <linux/sched.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <dirent.h>
  37 #include <sys/ioctl.h>
  38 #include <stdarg.h>
  39 #include <poll.h>
  40 #include <ctype.h>
  41 #include <sys/prctl.h>
  42 #include <sys/utsname.h>
  43 #include <pwd.h>
  44 #include <netinet/ip.h>
  45 #include <sys/wait.h>
  46 #include <sys/time.h>
  47 #include <glob.h>
  48 #include <grp.h>
  49 #include <sys/mman.h>
  50 #include <sys/vfs.h>
  51 #include <sys/mount.h>
  52 #include <linux/magic.h>
  53 #include <limits.h>
  54 #include <langinfo.h>
  55 #include <locale.h>
  56 #include <sys/personality.h>
  57 #include <sys/xattr.h>
  58 #include <sys/statvfs.h>
  59 #include <sys/file.h>
  60 #include <linux/fs.h>
  61
  62 /* When we include libgen.h because we need dirname() we immediately
  63  * undefine basename() since libgen.h defines it as a macro to the XDG
  64  * version which is really broken. */
  65 #include <libgen.h>
  66 #undef basename
  67
  68 #ifdef HAVE_SYS_AUXV_H
  69 #include <sys/auxv.h>
  70 #endif
  71
  72 #include "config.h"
  73 #include "macro.h"
  74 #include "util.h"
  75 #include "ioprio.h"
  76 #include "missing.h"
  77 #include "log.h"
  78 #include "strv.h"
  79 #include "mkdir.h"
  80 #include "path-util.h"
  81 #include "exit-status.h"
  82 #include "hashmap.h"
  83 #include "env-util.h"
  84 #include "fileio.h"
  85 #include "device-nodes.h"
  86 #include "utf8.h"
  87 #include "gunicode.h"
  88 #include "virt.h"
  89 #include "def.h"
  90 #include "sparse-endian.h"
  91 #include "formats-util.h"
  92 #include "process-util.h"
  93 #include "random-util.h"
  94 #include "terminal-util.h"
  95 #include "hostname-util.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 size_t page_size(void) {
 104         static thread_local size_t pgsz = 0;
 105         long r;
 106
 107         if (_likely_(pgsz > 0))
 108                 return pgsz;
 109
 110         r = sysconf(_SC_PAGESIZE);
 111         assert(r > 0);
 112
 113         pgsz = (size_t) r;
 114         return pgsz;
 115 }
 116
 117 bool streq_ptr(const char *a, const char *b) {
 118
 119         /* Like streq(), but tries to make sense of NULL pointers */
 120
 121         if (a && b)
 122                 return streq(a, b);
 123
 124         if (!a && !b)
 125                 return true;
 126
 127         return false;
 128 }
 129
 130 char* endswith(const char *s, const char *postfix) {
 131         size_t sl, pl;
 132
 133         assert(s);
 134         assert(postfix);
 135
 136         sl = strlen(s);
 137         pl = strlen(postfix);
 138
 139         if (pl == 0)
 140                 return (char*) s + sl;
 141
 142         if (sl < pl)
 143                 return NULL;
 144
 145         if (memcmp(s + sl - pl, postfix, pl) != 0)
 146                 return NULL;
 147
 148         return (char*) s + sl - pl;
 149 }
 150
 151 char* first_word(const char *s, const char *word) {
 152         size_t sl, wl;
 153         const char *p;
 154
 155         assert(s);
 156         assert(word);
 157
 158         /* Checks if the string starts with the specified word, either
 159          * followed by NUL or by whitespace. Returns a pointer to the
 160          * NUL or the first character after the whitespace. */
 161
 162         sl = strlen(s);
 163         wl = strlen(word);
 164
 165         if (sl < wl)
 166                 return NULL;
 167
 168         if (wl == 0)
 169                 return (char*) s;
 170
 171         if (memcmp(s, word, wl) != 0)
 172                 return NULL;
 173
 174         p = s + wl;
 175         if (*p == 0)
 176                 return (char*) p;
 177
 178         if (!strchr(WHITESPACE, *p))
 179                 return NULL;
 180
 181         p += strspn(p, WHITESPACE);
 182         return (char*) p;
 183 }
 184
 185 size_t cescape_char(char c, char *buf) {
 186         char * buf_old = buf;
 187
 188         switch (c) {
 189
 190                 case '\a':
 191                         *(buf++) = '\\';
 192                         *(buf++) = 'a';
 193                         break;
 194                 case '\b':
 195                         *(buf++) = '\\';
 196                         *(buf++) = 'b';
 197                         break;
 198                 case '\f':
 199                         *(buf++) = '\\';
 200                         *(buf++) = 'f';
 201                         break;
 202                 case '\n':
 203                         *(buf++) = '\\';
 204                         *(buf++) = 'n';
 205                         break;
 206                 case '\r':
 207                         *(buf++) = '\\';
 208                         *(buf++) = 'r';
 209                         break;
 210                 case '\t':
 211                         *(buf++) = '\\';
 212                         *(buf++) = 't';
 213                         break;
 214                 case '\v':
 215                         *(buf++) = '\\';
 216                         *(buf++) = 'v';
 217                         break;
 218                 case '\\':
 219                         *(buf++) = '\\';
 220                         *(buf++) = '\\';
 221                         break;
 222                 case '"':
 223                         *(buf++) = '\\';
 224                         *(buf++) = '"';
 225                         break;
 226                 case '\'':
 227                         *(buf++) = '\\';
 228                         *(buf++) = '\'';
 229                         break;
 230
 231                 default:
 232                         /* For special chars we prefer octal over
 233                          * hexadecimal encoding, simply because glib's
 234                          * g_strescape() does the same */
 235                         if ((c < ' ') || (c >= 127)) {
 236                                 *(buf++) = '\\';
 237                                 *(buf++) = octchar((unsigned char) c >> 6);
 238                                 *(buf++) = octchar((unsigned char) c >> 3);
 239                                 *(buf++) = octchar((unsigned char) c);
 240                         } else
 241                                 *(buf++) = c;
 242                         break;
 243         }
 244
 245         return buf - buf_old;
 246 }
 247
 248 int close_nointr(int fd) {
 249         assert(fd >= 0);
 250
 251         if (close(fd) >= 0)
 252                 return 0;
 253
 254         /*
 255          * Just ignore EINTR; a retry loop is the wrong thing to do on
 256          * Linux.
 257          *
 258          * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
 259          * https://bugzilla.gnome.org/show_bug.cgi?id=682819
 260          * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
 261          * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
 262          */
 263         if (errno == EINTR)
 264                 return 0;
 265
 266         return -errno;
 267 }
 268
 269 int safe_close(int fd) {
 270
 271         /*
 272          * Like close_nointr() but cannot fail. Guarantees errno is
 273          * unchanged. Is a NOP with negative fds passed, and returns
 274          * -1, so that it can be used in this syntax:
 275          *
 276          * fd = safe_close(fd);
 277          */
 278
 279         if (fd >= 0) {
 280                 PROTECT_ERRNO;
 281
 282                 /* The kernel might return pretty much any error code
 283                  * via close(), but the fd will be closed anyway. The
 284                  * only condition we want to check for here is whether
 285                  * the fd was invalid at all... */
 286
 287                 assert_se(close_nointr(fd) != -EBADF);
 288         }
 289
 290         return -1;
 291 }
 292
 293 void close_many(const int fds[], unsigned n_fd) {
 294         unsigned i;
 295
 296         assert(fds || n_fd <= 0);
 297
 298         for (i = 0; i < n_fd; i++)
 299                 safe_close(fds[i]);
 300 }
 301
 302 int unlink_noerrno(const char *path) {
 303         PROTECT_ERRNO;
 304         int r;
 305
 306         r = unlink(path);
 307         if (r < 0)
 308                 return -errno;
 309
 310         return 0;
 311 }
 312
 313 int parse_boolean(const char *v) {
 314         assert(v);
 315
 316         if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
 317                 return 1;
 318         else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
 319                 return 0;
 320
 321         return -EINVAL;
 322 }
 323
 324 int parse_pid(const char *s, pid_t* ret_pid) {
 325         unsigned long ul = 0;
 326         pid_t pid;
 327         int r;
 328
 329         assert(s);
 330         assert(ret_pid);
 331
 332         r = safe_atolu(s, &ul);
 333         if (r < 0)
 334                 return r;
 335
 336         pid = (pid_t) ul;
 337
 338         if ((unsigned long) pid != ul)
 339                 return -ERANGE;
 340
 341         if (pid <= 0)
 342                 return -ERANGE;
 343
 344         *ret_pid = pid;
 345         return 0;
 346 }
 347
 348 int parse_uid(const char *s, uid_t* ret_uid) {
 349         unsigned long ul = 0;
 350         uid_t uid;
 351         int r;
 352
 353         assert(s);
 354
 355         r = safe_atolu(s, &ul);
 356         if (r < 0)
 357                 return r;
 358
 359         uid = (uid_t) ul;
 360
 361         if ((unsigned long) uid != ul)
 362                 return -ERANGE;
 363
 364         /* Some libc APIs use UID_INVALID as special placeholder */
 365         if (uid == (uid_t) 0xFFFFFFFF)
 366                 return -ENXIO;
 367
 368         /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
 369         if (uid == (uid_t) 0xFFFF)
 370                 return -ENXIO;
 371
 372         if (ret_uid)
 373                 *ret_uid = uid;
 374
 375         return 0;
 376 }
 377
 378 int safe_atou(const char *s, unsigned *ret_u) {
 379         char *x = NULL;
 380         unsigned long l;
 381
 382         assert(s);
 383         assert(ret_u);
 384
 385         errno = 0;
 386         l = strtoul(s, &x, 0);
 387
 388         if (!x || x == s || *x || errno)
 389                 return errno > 0 ? -errno : -EINVAL;
 390
 391         if ((unsigned long) (unsigned) l != l)
 392                 return -ERANGE;
 393
 394         *ret_u = (unsigned) l;
 395         return 0;
 396 }
 397
 398 int safe_atoi(const char *s, int *ret_i) {
 399         char *x = NULL;
 400         long l;
 401
 402         assert(s);
 403         assert(ret_i);
 404
 405         errno = 0;
 406         l = strtol(s, &x, 0);
 407
 408         if (!x || x == s || *x || errno)
 409                 return errno > 0 ? -errno : -EINVAL;
 410
 411         if ((long) (int) l != l)
 412                 return -ERANGE;
 413
 414         *ret_i = (int) l;
 415         return 0;
 416 }
 417
 418 int safe_atou8(const char *s, uint8_t *ret) {
 419         char *x = NULL;
 420         unsigned long l;
 421
 422         assert(s);
 423         assert(ret);
 424
 425         errno = 0;
 426         l = strtoul(s, &x, 0);
 427
 428         if (!x || x == s || *x || errno)
 429                 return errno > 0 ? -errno : -EINVAL;
 430
 431         if ((unsigned long) (uint8_t) l != l)
 432                 return -ERANGE;
 433
 434         *ret = (uint8_t) l;
 435         return 0;
 436 }
 437
 438 int safe_atou16(const char *s, uint16_t *ret) {
 439         char *x = NULL;
 440         unsigned long l;
 441
 442         assert(s);
 443         assert(ret);
 444
 445         errno = 0;
 446         l = strtoul(s, &x, 0);
 447
 448         if (!x || x == s || *x || errno)
 449                 return errno > 0 ? -errno : -EINVAL;
 450
 451         if ((unsigned long) (uint16_t) l != l)
 452                 return -ERANGE;
 453
 454         *ret = (uint16_t) l;
 455         return 0;
 456 }
 457
 458 int safe_atoi16(const char *s, int16_t *ret) {
 459         char *x = NULL;
 460         long l;
 461
 462         assert(s);
 463         assert(ret);
 464
 465         errno = 0;
 466         l = strtol(s, &x, 0);
 467
 468         if (!x || x == s || *x || errno)
 469                 return errno > 0 ? -errno : -EINVAL;
 470
 471         if ((long) (int16_t) l != l)
 472                 return -ERANGE;
 473
 474         *ret = (int16_t) l;
 475         return 0;
 476 }
 477
 478 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 479         char *x = NULL;
 480         unsigned long long l;
 481
 482         assert(s);
 483         assert(ret_llu);
 484
 485         errno = 0;
 486         l = strtoull(s, &x, 0);
 487
 488         if (!x || x == s || *x || errno)
 489                 return errno ? -errno : -EINVAL;
 490
 491         *ret_llu = l;
 492         return 0;
 493 }
 494
 495 int safe_atolli(const char *s, long long int *ret_lli) {
 496         char *x = NULL;
 497         long long l;
 498
 499         assert(s);
 500         assert(ret_lli);
 501
 502         errno = 0;
 503         l = strtoll(s, &x, 0);
 504
 505         if (!x || x == s || *x || errno)
 506                 return errno ? -errno : -EINVAL;
 507
 508         *ret_lli = l;
 509         return 0;
 510 }
 511
 512 int safe_atod(const char *s, double *ret_d) {
 513         char *x = NULL;
 514         double d = 0;
 515         locale_t loc;
 516
 517         assert(s);
 518         assert(ret_d);
 519
 520         loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
 521         if (loc == (locale_t) 0)
 522                 return -errno;
 523
 524         errno = 0;
 525         d = strtod_l(s, &x, loc);
 526
 527         if (!x || x == s || *x || errno) {
 528                 freelocale(loc);
 529                 return errno ? -errno : -EINVAL;
 530         }
 531
 532         freelocale(loc);
 533         *ret_d = (double) d;
 534         return 0;
 535 }
 536
 537 static size_t strcspn_escaped(const char *s, const char *reject) {
 538         bool escaped = false;
 539         int n;
 540
 541         for (n=0; s[n]; n++) {
 542                 if (escaped)
 543                         escaped = false;
 544                 else if (s[n] == '\\')
 545                         escaped = true;
 546                 else if (strchr(reject, s[n]))
 547                         break;
 548         }
 549
 550         /* if s ends in \, return index of previous char */
 551         return n - escaped;
 552 }
 553
 554 /* Split a string into words. */
 555 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
 556         const char *current;
 557
 558         current = *state;
 559
 560         if (!*current) {
 561                 assert(**state == '\0');
 562                 return NULL;
 563         }
 564
 565         current += strspn(current, separator);
 566         if (!*current) {
 567                 *state = current;
 568                 return NULL;
 569         }
 570
 571         if (quoted && strchr("\'\"", *current)) {
 572                 char quotechars[2] = {*current, '\0'};
 573
 574                 *l = strcspn_escaped(current + 1, quotechars);
 575                 if (current[*l + 1] == '\0' ||
 576                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
 577                         /* right quote missing or garbage at the end */
 578                         *state = current;
 579                         return NULL;
 580                 }
 581                 assert(current[*l + 1] == quotechars[0]);
 582                 *state = current++ + *l + 2;
 583         } else if (quoted) {
 584                 *l = strcspn_escaped(current, separator);
 585                 if (current[*l] && !strchr(separator, current[*l])) {
 586                         /* unfinished escape */
 587                         *state = current;
 588                         return NULL;
 589                 }
 590                 *state = current + *l;
 591         } else {
 592                 *l = strcspn(current, separator);
 593                 *state = current + *l;
 594         }
 595
 596         return current;
 597 }
 598
 599 int fchmod_umask(int fd, mode_t m) {
 600         mode_t u;
 601         int r;
 602
 603         u = umask(0777);
 604         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 605         umask(u);
 606
 607         return r;
 608 }
 609
 610 char *truncate_nl(char *s) {
 611         assert(s);
 612
 613         s[strcspn(s, NEWLINE)] = 0;
 614         return s;
 615 }
 616
 617 char *strnappend(const char *s, const char *suffix, size_t b) {
 618         size_t a;
 619         char *r;
 620
 621         if (!s && !suffix)
 622                 return strdup("");
 623
 624         if (!s)
 625                 return strndup(suffix, b);
 626
 627         if (!suffix)
 628                 return strdup(s);
 629
 630         assert(s);
 631         assert(suffix);
 632
 633         a = strlen(s);
 634         if (b > ((size_t) -1) - a)
 635                 return NULL;
 636
 637         r = new(char, a+b+1);
 638         if (!r)
 639                 return NULL;
 640
 641         memcpy(r, s, a);
 642         memcpy(r+a, suffix, b);
 643         r[a+b] = 0;
 644
 645         return r;
 646 }
 647
 648 char *strappend(const char *s, const char *suffix) {
 649         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
 650 }
 651
 652 int readlinkat_malloc(int fd, const char *p, char **ret) {
 653         size_t l = 100;
 654         int r;
 655
 656         assert(p);
 657         assert(ret);
 658
 659         for (;;) {
 660                 char *c;
 661                 ssize_t n;
 662
 663                 c = new(char, l);
 664                 if (!c)
 665                         return -ENOMEM;
 666
 667                 n = readlinkat(fd, p, c, l-1);
 668                 if (n < 0) {
 669                         r = -errno;
 670                         free(c);
 671                         return r;
 672                 }
 673
 674                 if ((size_t) n < l-1) {
 675                         c[n] = 0;
 676                         *ret = c;
 677                         return 0;
 678                 }
 679
 680                 free(c);
 681                 l *= 2;
 682         }
 683 }
 684
 685 int readlink_malloc(const char *p, char **ret) {
 686         return readlinkat_malloc(AT_FDCWD, p, ret);
 687 }
 688
 689 int readlink_value(const char *p, char **ret) {
 690         _cleanup_free_ char *link = NULL;
 691         char *value;
 692         int r;
 693
 694         r = readlink_malloc(p, &link);
 695         if (r < 0)
 696                 return r;
 697
 698         value = basename(link);
 699         if (!value)
 700                 return -ENOENT;
 701
 702         value = strdup(value);
 703         if (!value)
 704                 return -ENOMEM;
 705
 706         *ret = value;
 707
 708         return 0;
 709 }
 710
 711 int readlink_and_make_absolute(const char *p, char **r) {
 712         _cleanup_free_ char *target = NULL;
 713         char *k;
 714         int j;
 715
 716         assert(p);
 717         assert(r);
 718
 719         j = readlink_malloc(p, &target);
 720         if (j < 0)
 721                 return j;
 722
 723         k = file_in_same_dir(p, target);
 724         if (!k)
 725                 return -ENOMEM;
 726
 727         *r = k;
 728         return 0;
 729 }
 730
 731 int readlink_and_canonicalize(const char *p, char **r) {
 732         char *t, *s;
 733         int j;
 734
 735         assert(p);
 736         assert(r);
 737
 738         j = readlink_and_make_absolute(p, &t);
 739         if (j < 0)
 740                 return j;
 741
 742         s = canonicalize_file_name(t);
 743         if (s) {
 744                 free(t);
 745                 *r = s;
 746         } else
 747                 *r = t;
 748
 749         path_kill_slashes(*r);
 750
 751         return 0;
 752 }
 753
 754 int reset_all_signal_handlers(void) {
 755         int sig, r = 0;
 756
 757         for (sig = 1; sig < _NSIG; sig++) {
 758                 struct sigaction sa = {
 759                         .sa_handler = SIG_DFL,
 760                         .sa_flags = SA_RESTART,
 761                 };
 762
 763                 /* These two cannot be caught... */
 764                 if (sig == SIGKILL || sig == SIGSTOP)
 765                         continue;
 766
 767                 /* On Linux the first two RT signals are reserved by
 768                  * glibc, and sigaction() will return EINVAL for them. */
 769                 if ((sigaction(sig, &sa, NULL) < 0))
 770                         if (errno != EINVAL && r == 0)
 771                                 r = -errno;
 772         }
 773
 774         return r;
 775 }
 776
 777 int reset_signal_mask(void) {
 778         sigset_t ss;
 779
 780         if (sigemptyset(&ss) < 0)
 781                 return -errno;
 782
 783         if (sigprocmask(SIG_SETMASK, &ss, NULL) < 0)
 784                 return -errno;
 785
 786         return 0;
 787 }
 788
 789 char *strstrip(char *s) {
 790         char *e;
 791
 792         /* Drops trailing whitespace. Modifies the string in
 793          * place. Returns pointer to first non-space character */
 794
 795         s += strspn(s, WHITESPACE);
 796
 797         for (e = strchr(s, 0); e > s; e --)
 798                 if (!strchr(WHITESPACE, e[-1]))
 799                         break;
 800
 801         *e = 0;
 802
 803         return s;
 804 }
 805
 806 char *delete_chars(char *s, const char *bad) {
 807         char *f, *t;
 808
 809         /* Drops all whitespace, regardless where in the string */
 810
 811         for (f = s, t = s; *f; f++) {
 812                 if (strchr(bad, *f))
 813                         continue;
 814
 815                 *(t++) = *f;
 816         }
 817
 818         *t = 0;
 819
 820         return s;
 821 }
 822
 823 char *file_in_same_dir(const char *path, const char *filename) {
 824         char *e, *ret;
 825         size_t k;
 826
 827         assert(path);
 828         assert(filename);
 829
 830         /* This removes the last component of path and appends
 831          * filename, unless the latter is absolute anyway or the
 832          * former isn't */
 833
 834         if (path_is_absolute(filename))
 835                 return strdup(filename);
 836
 837         e = strrchr(path, '/');
 838         if (!e)
 839                 return strdup(filename);
 840
 841         k = strlen(filename);
 842         ret = new(char, (e + 1 - path) + k + 1);
 843         if (!ret)
 844                 return NULL;
 845
 846         memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);
 847         return ret;
 848 }
 849
 850 int rmdir_parents(const char *path, const char *stop) {
 851         size_t l;
 852         int r = 0;
 853
 854         assert(path);
 855         assert(stop);
 856
 857         l = strlen(path);
 858
 859         /* Skip trailing slashes */
 860         while (l > 0 && path[l-1] == '/')
 861                 l--;
 862
 863         while (l > 0) {
 864                 char *t;
 865
 866                 /* Skip last component */
 867                 while (l > 0 && path[l-1] != '/')
 868                         l--;
 869
 870                 /* Skip trailing slashes */
 871                 while (l > 0 && path[l-1] == '/')
 872                         l--;
 873
 874                 if (l <= 0)
 875                         break;
 876
 877                 if (!(t = strndup(path, l)))
 878                         return -ENOMEM;
 879
 880                 if (path_startswith(stop, t)) {
 881                         free(t);
 882                         return 0;
 883                 }
 884
 885                 r = rmdir(t);
 886                 free(t);
 887
 888                 if (r < 0)
 889                         if (errno != ENOENT)
 890                                 return -errno;
 891         }
 892
 893         return 0;
 894 }
 895
 896 char hexchar(int x) {
 897         static const char table[16] = "0123456789abcdef";
 898
 899         return table[x & 15];
 900 }
 901
 902 int unhexchar(char c) {
 903
 904         if (c >= '0' && c <= '9')
 905                 return c - '0';
 906
 907         if (c >= 'a' && c <= 'f')
 908                 return c - 'a' + 10;
 909
 910         if (c >= 'A' && c <= 'F')
 911                 return c - 'A' + 10;
 912
 913         return -EINVAL;
 914 }
 915
 916 char *hexmem(const void *p, size_t l) {
 917         char *r, *z;
 918         const uint8_t *x;
 919
 920         z = r = malloc(l * 2 + 1);
 921         if (!r)
 922                 return NULL;
 923
 924         for (x = p; x < (const uint8_t*) p + l; x++) {
 925                 *(z++) = hexchar(*x >> 4);
 926                 *(z++) = hexchar(*x & 15);
 927         }
 928
 929         *z = 0;
 930         return r;
 931 }
 932
 933 void *unhexmem(const char *p, size_t l) {
 934         uint8_t *r, *z;
 935         const char *x;
 936
 937         assert(p);
 938
 939         z = r = malloc((l + 1) / 2 + 1);
 940         if (!r)
 941                 return NULL;
 942
 943         for (x = p; x < p + l; x += 2) {
 944                 int a, b;
 945
 946                 a = unhexchar(x[0]);
 947                 if (x+1 < p + l)
 948                         b = unhexchar(x[1]);
 949                 else
 950                         b = 0;
 951
 952                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
 953         }
 954
 955         *z = 0;
 956         return r;
 957 }
 958
 959 char octchar(int x) {
 960         return '0' + (x & 7);
 961 }
 962
 963 int unoctchar(char c) {
 964
 965         if (c >= '0' && c <= '7')
 966                 return c - '0';
 967
 968         return -EINVAL;
 969 }
 970
 971 char decchar(int x) {
 972         return '0' + (x % 10);
 973 }
 974
 975 int undecchar(char c) {
 976
 977         if (c >= '0' && c <= '9')
 978                 return c - '0';
 979
 980         return -EINVAL;
 981 }
 982
 983 char *cescape(const char *s) {
 984         char *r, *t;
 985         const char *f;
 986
 987         assert(s);
 988
 989         /* Does C style string escaping. May be reversed with
 990          * cunescape(). */
 991
 992         r = new(char, strlen(s)*4 + 1);
 993         if (!r)
 994                 return NULL;
 995
 996         for (f = s, t = r; *f; f++)
 997                 t += cescape_char(*f, t);
 998
 999         *t = 0;
1000
1001         return r;
1002 }
1003
1004 static int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode) {
1005         int r = 1;
1006
1007         assert(p);
1008         assert(*p);
1009         assert(ret);
1010
1011         /* Unescapes C style. Returns the unescaped character in ret,
1012          * unless we encountered a \u sequence in which case the full
1013          * unicode character is returned in ret_unicode, instead. */
1014
1015         if (length != (size_t) -1 && length < 1)
1016                 return -EINVAL;
1017
1018         switch (p[0]) {
1019
1020         case 'a':
1021                 *ret = '\a';
1022                 break;
1023         case 'b':
1024                 *ret = '\b';
1025                 break;
1026         case 'f':
1027                 *ret = '\f';
1028                 break;
1029         case 'n':
1030                 *ret = '\n';
1031                 break;
1032         case 'r':
1033                 *ret = '\r';
1034                 break;
1035         case 't':
1036                 *ret = '\t';
1037                 break;
1038         case 'v':
1039                 *ret = '\v';
1040                 break;
1041         case '\\':
1042                 *ret = '\\';
1043                 break;
1044         case '"':
1045                 *ret = '"';
1046                 break;
1047         case '\'':
1048                 *ret = '\'';
1049                 break;
1050
1051         case 's':
1052                 /* This is an extension of the XDG syntax files */
1053                 *ret = ' ';
1054                 break;
1055
1056         case 'x': {
1057                 /* hexadecimal encoding */
1058                 int a, b;
1059
1060                 if (length != (size_t) -1 && length < 3)
1061                         return -EINVAL;
1062
1063                 a = unhexchar(p[1]);
1064                 if (a < 0)
1065                         return -EINVAL;
1066
1067                 b = unhexchar(p[2]);
1068                 if (b < 0)
1069                         return -EINVAL;
1070
1071                 /* Don't allow NUL bytes */
1072                 if (a == 0 && b == 0)
1073                         return -EINVAL;
1074
1075                 *ret = (char) ((a << 4U) | b);
1076                 r = 3;
1077                 break;
1078         }
1079
1080         case 'u': {
1081                 /* C++11 style 16bit unicode */
1082
1083                 int a[4];
1084                 unsigned i;
1085                 uint32_t c;
1086
1087                 if (length != (size_t) -1 && length < 5)
1088                         return -EINVAL;
1089
1090                 for (i = 0; i < 4; i++) {
1091                         a[i] = unhexchar(p[1 + i]);
1092                         if (a[i] < 0)
1093                                 return a[i];
1094                 }
1095
1096                 c = ((uint32_t) a[0] << 12U) | ((uint32_t) a[1] << 8U) | ((uint32_t) a[2] << 4U) | (uint32_t) a[3];
1097
1098                 /* Don't allow 0 chars */
1099                 if (c == 0)
1100                         return -EINVAL;
1101
1102                 if (c < 128)
1103                         *ret = c;
1104                 else {
1105                         if (!ret_unicode)
1106                                 return -EINVAL;
1107
1108                         *ret = 0;
1109                         *ret_unicode = c;
1110                 }
1111
1112                 r = 5;
1113                 break;
1114         }
1115
1116         case 'U': {
1117                 /* C++11 style 32bit unicode */
1118
1119                 int a[8];
1120                 unsigned i;
1121                 uint32_t c;
1122
1123                 if (length != (size_t) -1 && length < 9)
1124                         return -EINVAL;
1125
1126                 for (i = 0; i < 8; i++) {
1127                         a[i] = unhexchar(p[1 + i]);
1128                         if (a[i] < 0)
1129                                 return a[i];
1130                 }
1131
1132                 c = ((uint32_t) a[0] << 28U) | ((uint32_t) a[1] << 24U) | ((uint32_t) a[2] << 20U) | ((uint32_t) a[3] << 16U) |
1133                     ((uint32_t) a[4] << 12U) | ((uint32_t) a[5] <<  8U) | ((uint32_t) a[6] <<  4U) |  (uint32_t) a[7];
1134
1135                 /* Don't allow 0 chars */
1136                 if (c == 0)
1137                         return -EINVAL;
1138
1139                 /* Don't allow invalid code points */
1140                 if (!unichar_is_valid(c))
1141                         return -EINVAL;
1142
1143                 if (c < 128)
1144                         *ret = c;
1145                 else {
1146                         if (!ret_unicode)
1147                                 return -EINVAL;
1148
1149                         *ret = 0;
1150                         *ret_unicode = c;
1151                 }
1152
1153                 r = 9;
1154                 break;
1155         }
1156
1157         case '0':
1158         case '1':
1159         case '2':
1160         case '3':
1161         case '4':
1162         case '5':
1163         case '6':
1164         case '7': {
1165                 /* octal encoding */
1166                 int a, b, c;
1167                 uint32_t m;
1168
1169                 if (length != (size_t) -1 && length < 4)
1170                         return -EINVAL;
1171
1172                 a = unoctchar(p[0]);
1173                 if (a < 0)
1174                         return -EINVAL;
1175
1176                 b = unoctchar(p[1]);
1177                 if (b < 0)
1178                         return -EINVAL;
1179
1180                 c = unoctchar(p[2]);
1181                 if (c < 0)
1182                         return -EINVAL;
1183
1184                 /* don't allow NUL bytes */
1185                 if (a == 0 && b == 0 && c == 0)
1186                         return -EINVAL;
1187
1188                 /* Don't allow bytes above 255 */
1189                 m = ((uint32_t) a << 6U) | ((uint32_t) b << 3U) | (uint32_t) c;
1190                 if (m > 255)
1191                         return -EINVAL;
1192
1193                 *ret = m;
1194                 r = 3;
1195                 break;
1196         }
1197
1198         default:
1199                 return -EINVAL;
1200         }
1201
1202         return r;
1203 }
1204
1205 int cunescape_length_with_prefix(const char *s, size_t length, const char *prefix, UnescapeFlags flags, char **ret) {
1206         char *r, *t;
1207         const char *f;
1208         size_t pl;
1209
1210         assert(s);
1211         assert(ret);
1212
1213         /* Undoes C style string escaping, and optionally prefixes it. */
1214
1215         pl = prefix ? strlen(prefix) : 0;
1216
1217         r = new(char, pl+length+1);
1218         if (!r)
1219                 return -ENOMEM;
1220
1221         if (prefix)
1222                 memcpy(r, prefix, pl);
1223
1224         for (f = s, t = r + pl; f < s + length; f++) {
1225                 size_t remaining;
1226                 uint32_t u;
1227                 char c;
1228                 int k;
1229
1230                 remaining = s + length - f;
1231                 assert(remaining > 0);
1232
1233                 if (*f != '\\') {
1234                         /* A literal literal, copy verbatim */
1235                         *(t++) = *f;
1236                         continue;
1237                 }
1238
1239                 if (remaining == 1) {
1240                         if (flags & UNESCAPE_RELAX) {
1241                                 /* A trailing backslash, copy verbatim */
1242                                 *(t++) = *f;
1243                                 continue;
1244                         }
1245
1246                         free(r);
1247                         return -EINVAL;
1248                 }
1249
1250                 k = cunescape_one(f + 1, remaining - 1, &c, &u);
1251                 if (k < 0) {
1252                         if (flags & UNESCAPE_RELAX) {
1253                                 /* Invalid escape code, let's take it literal then */
1254                                 *(t++) = '\\';
1255                                 continue;
1256                         }
1257
1258                         free(r);
1259                         return k;
1260                 }
1261
1262                 if (c != 0)
1263                         /* Non-Unicode? Let's encode this directly */
1264                         *(t++) = c;
1265                 else
1266                         /* Unicode? Then let's encode this in UTF-8 */
1267                         t += utf8_encode_unichar(t, u);
1268
1269                 f += k;
1270         }
1271
1272         *t = 0;
1273
1274         *ret = r;
1275         return t - r;
1276 }
1277
1278 int cunescape_length(const char *s, size_t length, UnescapeFlags flags, char **ret) {
1279         return cunescape_length_with_prefix(s, length, NULL, flags, ret);
1280 }
1281
1282 int cunescape(const char *s, UnescapeFlags flags, char **ret) {
1283         return cunescape_length(s, strlen(s), flags, ret);
1284 }
1285
1286 char *xescape(const char *s, const char *bad) {
1287         char *r, *t;
1288         const char *f;
1289
1290         /* Escapes all chars in bad, in addition to \ and all special
1291          * chars, in \xFF style escaping. May be reversed with
1292          * cunescape(). */
1293
1294         r = new(char, strlen(s) * 4 + 1);
1295         if (!r)
1296                 return NULL;
1297
1298         for (f = s, t = r; *f; f++) {
1299
1300                 if ((*f < ' ') || (*f >= 127) ||
1301                     (*f == '\\') || strchr(bad, *f)) {
1302                         *(t++) = '\\';
1303                         *(t++) = 'x';
1304                         *(t++) = hexchar(*f >> 4);
1305                         *(t++) = hexchar(*f);
1306                 } else
1307                         *(t++) = *f;
1308         }
1309
1310         *t = 0;
1311
1312         return r;
1313 }
1314
1315 char *ascii_strlower(char *t) {
1316         char *p;
1317
1318         assert(t);
1319
1320         for (p = t; *p; p++)
1321                 if (*p >= 'A' && *p <= 'Z')
1322                         *p = *p - 'A' + 'a';
1323
1324         return t;
1325 }
1326
1327 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1328         assert(filename);
1329
1330         return
1331                 filename[0] == '.' ||
1332                 streq(filename, "lost+found") ||
1333                 streq(filename, "aquota.user") ||
1334                 streq(filename, "aquota.group") ||
1335                 endswith(filename, ".rpmnew") ||
1336                 endswith(filename, ".rpmsave") ||
1337                 endswith(filename, ".rpmorig") ||
1338                 endswith(filename, ".dpkg-old") ||
1339                 endswith(filename, ".dpkg-new") ||
1340                 endswith(filename, ".dpkg-tmp") ||
1341                 endswith(filename, ".dpkg-dist") ||
1342                 endswith(filename, ".dpkg-bak") ||
1343                 endswith(filename, ".dpkg-backup") ||
1344                 endswith(filename, ".dpkg-remove") ||
1345                 endswith(filename, ".swp");
1346 }
1347
1348 bool hidden_file(const char *filename) {
1349         assert(filename);
1350
1351         if (endswith(filename, "~"))
1352                 return true;
1353
1354         return hidden_file_allow_backup(filename);
1355 }
1356
1357 int fd_nonblock(int fd, bool nonblock) {
1358         int flags, nflags;
1359
1360         assert(fd >= 0);
1361
1362         flags = fcntl(fd, F_GETFL, 0);
1363         if (flags < 0)
1364                 return -errno;
1365
1366         if (nonblock)
1367                 nflags = flags | O_NONBLOCK;
1368         else
1369                 nflags = flags & ~O_NONBLOCK;
1370
1371         if (nflags == flags)
1372                 return 0;
1373
1374         if (fcntl(fd, F_SETFL, nflags) < 0)
1375                 return -errno;
1376
1377         return 0;
1378 }
1379
1380 int fd_cloexec(int fd, bool cloexec) {
1381         int flags, nflags;
1382
1383         assert(fd >= 0);
1384
1385         flags = fcntl(fd, F_GETFD, 0);
1386         if (flags < 0)
1387                 return -errno;
1388
1389         if (cloexec)
1390                 nflags = flags | FD_CLOEXEC;
1391         else
1392                 nflags = flags & ~FD_CLOEXEC;
1393
1394         if (nflags == flags)
1395                 return 0;
1396
1397         if (fcntl(fd, F_SETFD, nflags) < 0)
1398                 return -errno;
1399
1400         return 0;
1401 }
1402
1403 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1404         unsigned i;
1405
1406         assert(n_fdset == 0 || fdset);
1407
1408         for (i = 0; i < n_fdset; i++)
1409                 if (fdset[i] == fd)
1410                         return true;
1411
1412         return false;
1413 }
1414
1415 int close_all_fds(const int except[], unsigned n_except) {
1416         _cleanup_closedir_ DIR *d = NULL;
1417         struct dirent *de;
1418         int r = 0;
1419
1420         assert(n_except == 0 || except);
1421
1422         d = opendir("/proc/self/fd");
1423         if (!d) {
1424                 int fd;
1425                 struct rlimit rl;
1426
1427                 /* When /proc isn't available (for example in chroots)
1428                  * the fallback is brute forcing through the fd
1429                  * table */
1430
1431                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1432                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1433
1434                         if (fd_in_set(fd, except, n_except))
1435                                 continue;
1436
1437                         if (close_nointr(fd) < 0)
1438                                 if (errno != EBADF && r == 0)
1439                                         r = -errno;
1440                 }
1441
1442                 return r;
1443         }
1444
1445         while ((de = readdir(d))) {
1446                 int fd = -1;
1447
1448                 if (hidden_file(de->d_name))
1449                         continue;
1450
1451                 if (safe_atoi(de->d_name, &fd) < 0)
1452                         /* Let's better ignore this, just in case */
1453                         continue;
1454
1455                 if (fd < 3)
1456                         continue;
1457
1458                 if (fd == dirfd(d))
1459                         continue;
1460
1461                 if (fd_in_set(fd, except, n_except))
1462                         continue;
1463
1464                 if (close_nointr(fd) < 0) {
1465                         /* Valgrind has its own FD and doesn't want to have it closed */
1466                         if (errno != EBADF && r == 0)
1467                                 r = -errno;
1468                 }
1469         }
1470
1471         return r;
1472 }
1473
1474 bool chars_intersect(const char *a, const char *b) {
1475         const char *p;
1476
1477         /* Returns true if any of the chars in a are in b. */
1478         for (p = a; *p; p++)
1479                 if (strchr(b, *p))
1480                         return true;
1481
1482         return false;
1483 }
1484
1485 bool fstype_is_network(const char *fstype) {
1486         static const char table[] =
1487                 "afs\0"
1488                 "cifs\0"
1489                 "smbfs\0"
1490                 "sshfs\0"
1491                 "ncpfs\0"
1492                 "ncp\0"
1493                 "nfs\0"
1494                 "nfs4\0"
1495                 "gfs\0"
1496                 "gfs2\0"
1497                 "glusterfs\0";
1498
1499         const char *x;
1500
1501         x = startswith(fstype, "fuse.");
1502         if (x)
1503                 fstype = x;
1504
1505         return nulstr_contains(table, fstype);
1506 }
1507
1508 int flush_fd(int fd) {
1509         struct pollfd pollfd = {
1510                 .fd = fd,
1511                 .events = POLLIN,
1512         };
1513
1514         for (;;) {
1515                 char buf[LINE_MAX];
1516                 ssize_t l;
1517                 int r;
1518
1519                 r = poll(&pollfd, 1, 0);
1520                 if (r < 0) {
1521                         if (errno == EINTR)
1522                                 continue;
1523
1524                         return -errno;
1525
1526                 } else if (r == 0)
1527                         return 0;
1528
1529                 l = read(fd, buf, sizeof(buf));
1530                 if (l < 0) {
1531
1532                         if (errno == EINTR)
1533                                 continue;
1534
1535                         if (errno == EAGAIN)
1536                                 return 0;
1537
1538                         return -errno;
1539                 } else if (l == 0)
1540                         return 0;
1541         }
1542 }
1543
1544 int sigaction_many(const struct sigaction *sa, ...) {
1545         va_list ap;
1546         int r = 0, sig;
1547
1548         va_start(ap, sa);
1549         while ((sig = va_arg(ap, int)) > 0)
1550                 if (sigaction(sig, sa, NULL) < 0)
1551                         r = -errno;
1552         va_end(ap);
1553
1554         return r;
1555 }
1556
1557 int ignore_signals(int sig, ...) {
1558         struct sigaction sa = {
1559                 .sa_handler = SIG_IGN,
1560                 .sa_flags = SA_RESTART,
1561         };
1562         va_list ap;
1563         int r = 0;
1564
1565         if (sigaction(sig, &sa, NULL) < 0)
1566                 r = -errno;
1567
1568         va_start(ap, sig);
1569         while ((sig = va_arg(ap, int)) > 0)
1570                 if (sigaction(sig, &sa, NULL) < 0)
1571                         r = -errno;
1572         va_end(ap);
1573
1574         return r;
1575 }
1576
1577 int default_signals(int sig, ...) {
1578         struct sigaction sa = {
1579                 .sa_handler = SIG_DFL,
1580                 .sa_flags = SA_RESTART,
1581         };
1582         va_list ap;
1583         int r = 0;
1584
1585         if (sigaction(sig, &sa, NULL) < 0)
1586                 r = -errno;
1587
1588         va_start(ap, sig);
1589         while ((sig = va_arg(ap, int)) > 0)
1590                 if (sigaction(sig, &sa, NULL) < 0)
1591                         r = -errno;
1592         va_end(ap);
1593
1594         return r;
1595 }
1596
1597 void safe_close_pair(int p[]) {
1598         assert(p);
1599
1600         if (p[0] == p[1]) {
1601                 /* Special case pairs which use the same fd in both
1602                  * directions... */
1603                 p[0] = p[1] = safe_close(p[0]);
1604                 return;
1605         }
1606
1607         p[0] = safe_close(p[0]);
1608         p[1] = safe_close(p[1]);
1609 }
1610
1611 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
1612         uint8_t *p = buf;
1613         ssize_t n = 0;
1614
1615         assert(fd >= 0);
1616         assert(buf);
1617
1618         while (nbytes > 0) {
1619                 ssize_t k;
1620
1621                 k = read(fd, p, nbytes);
1622                 if (k < 0) {
1623                         if (errno == EINTR)
1624                                 continue;
1625
1626                         if (errno == EAGAIN && do_poll) {
1627
1628                                 /* We knowingly ignore any return value here,
1629                                  * and expect that any error/EOF is reported
1630                                  * via read() */
1631
1632                                 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
1633                                 continue;
1634                         }
1635
1636                         return n > 0 ? n : -errno;
1637                 }
1638
1639                 if (k == 0)
1640                         return n;
1641
1642                 p += k;
1643                 nbytes -= k;
1644                 n += k;
1645         }
1646
1647         return n;
1648 }
1649
1650 int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll) {
1651         ssize_t n;
1652
1653         n = loop_read(fd, buf, nbytes, do_poll);
1654         if (n < 0)
1655                 return n;
1656         if ((size_t) n != nbytes)
1657                 return -EIO;
1658         return 0;
1659 }
1660
1661 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
1662         const uint8_t *p = buf;
1663
1664         assert(fd >= 0);
1665         assert(buf);
1666
1667         errno = 0;
1668
1669         do {
1670                 ssize_t k;
1671
1672                 k = write(fd, p, nbytes);
1673                 if (k < 0) {
1674                         if (errno == EINTR)
1675                                 continue;
1676
1677                         if (errno == EAGAIN && do_poll) {
1678                                 /* We knowingly ignore any return value here,
1679                                  * and expect that any error/EOF is reported
1680                                  * via write() */
1681
1682                                 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
1683                                 continue;
1684                         }
1685
1686                         return -errno;
1687                 }
1688
1689                 if (nbytes > 0 && k == 0) /* Can't really happen */
1690                         return -EIO;
1691
1692                 p += k;
1693                 nbytes -= k;
1694         } while (nbytes > 0);
1695
1696         return 0;
1697 }
1698
1699 int parse_size(const char *t, off_t base, off_t *size) {
1700
1701         /* Soo, sometimes we want to parse IEC binary suffixes, and
1702          * sometimes SI decimal suffixes. This function can parse
1703          * both. Which one is the right way depends on the
1704          * context. Wikipedia suggests that SI is customary for
1705          * hardware metrics and network speeds, while IEC is
1706          * customary for most data sizes used by software and volatile
1707          * (RAM) memory. Hence be careful which one you pick!
1708          *
1709          * In either case we use just K, M, G as suffix, and not Ki,
1710          * Mi, Gi or so (as IEC would suggest). That's because that's
1711          * frickin' ugly. But this means you really need to make sure
1712          * to document which base you are parsing when you use this
1713          * call. */
1714
1715         struct table {
1716                 const char *suffix;
1717                 unsigned long long factor;
1718         };
1719
1720         static const struct table iec[] = {
1721                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
1722                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
1723                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
1724                 { "G", 1024ULL*1024ULL*1024ULL },
1725                 { "M", 1024ULL*1024ULL },
1726                 { "K", 1024ULL },
1727                 { "B", 1 },
1728                 { "", 1 },
1729         };
1730
1731         static const struct table si[] = {
1732                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
1733                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
1734                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
1735                 { "G", 1000ULL*1000ULL*1000ULL },
1736                 { "M", 1000ULL*1000ULL },
1737                 { "K", 1000ULL },
1738                 { "B", 1 },
1739                 { "", 1 },
1740         };
1741
1742         const struct table *table;
1743         const char *p;
1744         unsigned long long r = 0;
1745         unsigned n_entries, start_pos = 0;
1746
1747         assert(t);
1748         assert(base == 1000 || base == 1024);
1749         assert(size);
1750
1751         if (base == 1000) {
1752                 table = si;
1753                 n_entries = ELEMENTSOF(si);
1754         } else {
1755                 table = iec;
1756                 n_entries = ELEMENTSOF(iec);
1757         }
1758
1759         p = t;
1760         do {
1761                 long long l;
1762                 unsigned long long l2;
1763                 double frac = 0;
1764                 char *e;
1765                 unsigned i;
1766
1767                 errno = 0;
1768                 l = strtoll(p, &e, 10);
1769
1770                 if (errno > 0)
1771                         return -errno;
1772
1773                 if (l < 0)
1774                         return -ERANGE;
1775
1776                 if (e == p)
1777                         return -EINVAL;
1778
1779                 if (*e == '.') {
1780                         e++;
1781                         if (*e >= '0' && *e <= '9') {
1782                                 char *e2;
1783
1784                                 /* strotoull itself would accept space/+/- */
1785                                 l2 = strtoull(e, &e2, 10);
1786
1787                                 if (errno == ERANGE)
1788                                         return -errno;
1789
1790                                 /* Ignore failure. E.g. 10.M is valid */
1791                                 frac = l2;
1792                                 for (; e < e2; e++)
1793                                         frac /= 10;
1794                         }
1795                 }
1796
1797                 e += strspn(e, WHITESPACE);
1798
1799                 for (i = start_pos; i < n_entries; i++)
1800                         if (startswith(e, table[i].suffix)) {
1801                                 unsigned long long tmp;
1802                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
1803                                         return -ERANGE;
1804                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
1805                                 if (tmp > ULLONG_MAX - r)
1806                                         return -ERANGE;
1807
1808                                 r += tmp;
1809                                 if ((unsigned long long) (off_t) r != r)
1810                                         return -ERANGE;
1811
1812                                 p = e + strlen(table[i].suffix);
1813
1814                                 start_pos = i + 1;
1815                                 break;
1816                         }
1817
1818                 if (i >= n_entries)
1819                         return -EINVAL;
1820
1821         } while (*p);
1822
1823         *size = r;
1824
1825         return 0;
1826 }
1827
1828 bool is_device_path(const char *path) {
1829
1830         /* Returns true on paths that refer to a device, either in
1831          * sysfs or in /dev */
1832
1833         return
1834                 path_startswith(path, "/dev/") ||
1835                 path_startswith(path, "/sys/");
1836 }
1837
1838 int dir_is_empty(const char *path) {
1839         _cleanup_closedir_ DIR *d;
1840
1841         d = opendir(path);
1842         if (!d)
1843                 return -errno;
1844
1845         for (;;) {
1846                 struct dirent *de;
1847
1848                 errno = 0;
1849                 de = readdir(d);
1850                 if (!de && errno != 0)
1851                         return -errno;
1852
1853                 if (!de)
1854                         return 1;
1855
1856                 if (!hidden_file(de->d_name))
1857                         return 0;
1858         }
1859 }
1860
1861 char* dirname_malloc(const char *path) {
1862         char *d, *dir, *dir2;
1863
1864         d = strdup(path);
1865         if (!d)
1866                 return NULL;
1867         dir = dirname(d);
1868         assert(dir);
1869
1870         if (dir != d) {
1871                 dir2 = strdup(dir);
1872                 free(d);
1873                 return dir2;
1874         }
1875
1876         return dir;
1877 }
1878
1879 void rename_process(const char name[8]) {
1880         assert(name);
1881
1882         /* This is a like a poor man's setproctitle(). It changes the
1883          * comm field, argv[0], and also the glibc's internally used
1884          * name of the process. For the first one a limit of 16 chars
1885          * applies, to the second one usually one of 10 (i.e. length
1886          * of "/sbin/init"), to the third one one of 7 (i.e. length of
1887          * "systemd"). If you pass a longer string it will be
1888          * truncated */
1889
1890         prctl(PR_SET_NAME, name);
1891
1892         if (program_invocation_name)
1893                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
1894
1895         if (saved_argc > 0) {
1896                 int i;
1897
1898                 if (saved_argv[0])
1899                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
1900
1901                 for (i = 1; i < saved_argc; i++) {
1902                         if (!saved_argv[i])
1903                                 break;
1904
1905                         memzero(saved_argv[i], strlen(saved_argv[i]));
1906                 }
1907         }
1908 }
1909
1910 void sigset_add_many(sigset_t *ss, ...) {
1911         va_list ap;
1912         int sig;
1913
1914         assert(ss);
1915
1916         va_start(ap, ss);
1917         while ((sig = va_arg(ap, int)) > 0)
1918                 assert_se(sigaddset(ss, sig) == 0);
1919         va_end(ap);
1920 }
1921
1922 int sigprocmask_many(int how, ...) {
1923         va_list ap;
1924         sigset_t ss;
1925         int sig;
1926
1927         assert_se(sigemptyset(&ss) == 0);
1928
1929         va_start(ap, how);
1930         while ((sig = va_arg(ap, int)) > 0)
1931                 assert_se(sigaddset(&ss, sig) == 0);
1932         va_end(ap);
1933
1934         if (sigprocmask(how, &ss, NULL) < 0)
1935                 return -errno;
1936
1937         return 0;
1938 }
1939 char *lookup_uid(uid_t uid) {
1940         long bufsize;
1941         char *name;
1942         _cleanup_free_ char *buf = NULL;
1943         struct passwd pwbuf, *pw = NULL;
1944
1945         /* Shortcut things to avoid NSS lookups */
1946         if (uid == 0)
1947                 return strdup("root");
1948
1949         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
1950         if (bufsize <= 0)
1951                 bufsize = 4096;
1952
1953         buf = malloc(bufsize);
1954         if (!buf)
1955                 return NULL;
1956
1957         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
1958                 return strdup(pw->pw_name);
1959
1960         if (asprintf(&name, UID_FMT, uid) < 0)
1961                 return NULL;
1962
1963         return name;
1964 }
1965
1966 char* getlogname_malloc(void) {
1967         uid_t uid;
1968         struct stat st;
1969
1970         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
1971                 uid = st.st_uid;
1972         else
1973                 uid = getuid();
1974
1975         return lookup_uid(uid);
1976 }
1977
1978 char *getusername_malloc(void) {
1979         const char *e;
1980
1981         e = getenv("USER");
1982         if (e)
1983                 return strdup(e);
1984
1985         return lookup_uid(getuid());
1986 }
1987
1988 bool is_temporary_fs(const struct statfs *s) {
1989         assert(s);
1990
1991         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
1992                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
1993 }
1994
1995 int fd_is_temporary_fs(int fd) {
1996         struct statfs s;
1997
1998         if (fstatfs(fd, &s) < 0)
1999                 return -errno;
2000
2001         return is_temporary_fs(&s);
2002 }
2003
2004 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2005         assert(path);
2006
2007         /* Under the assumption that we are running privileged we
2008          * first change the access mode and only then hand out
2009          * ownership to avoid a window where access is too open. */
2010
2011         if (mode != MODE_INVALID)
2012                 if (chmod(path, mode) < 0)
2013                         return -errno;
2014
2015         if (uid != UID_INVALID || gid != GID_INVALID)
2016                 if (chown(path, uid, gid) < 0)
2017                         return -errno;
2018
2019         return 0;
2020 }
2021
2022 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2023         assert(fd >= 0);
2024
2025         /* Under the assumption that we are running privileged we
2026          * first change the access mode and only then hand out
2027          * ownership to avoid a window where access is too open. */
2028
2029         if (mode != MODE_INVALID)
2030                 if (fchmod(fd, mode) < 0)
2031                         return -errno;
2032
2033         if (uid != UID_INVALID || gid != GID_INVALID)
2034                 if (fchown(fd, uid, gid) < 0)
2035                         return -errno;
2036
2037         return 0;
2038 }
2039
2040 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2041         cpu_set_t *r;
2042         unsigned n = 1024;
2043
2044         /* Allocates the cpuset in the right size */
2045
2046         for (;;) {
2047                 if (!(r = CPU_ALLOC(n)))
2048                         return NULL;
2049
2050                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2051                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2052
2053                         if (ncpus)
2054                                 *ncpus = n;
2055
2056                         return r;
2057                 }
2058
2059                 CPU_FREE(r);
2060
2061                 if (errno != EINVAL)
2062                         return NULL;
2063
2064                 n *= 2;
2065         }
2066 }
2067
2068 int files_same(const char *filea, const char *fileb) {
2069         struct stat a, b;
2070
2071         if (stat(filea, &a) < 0)
2072                 return -errno;
2073
2074         if (stat(fileb, &b) < 0)
2075                 return -errno;
2076
2077         return a.st_dev == b.st_dev &&
2078                a.st_ino == b.st_ino;
2079 }
2080
2081 int running_in_chroot(void) {
2082         int ret;
2083
2084         ret = files_same("/proc/1/root", "/");
2085         if (ret < 0)
2086                 return ret;
2087
2088         return ret == 0;
2089 }
2090
2091 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
2092         size_t x;
2093         char *r;
2094
2095         assert(s);
2096         assert(percent <= 100);
2097         assert(new_length >= 3);
2098
2099         if (old_length <= 3 || old_length <= new_length)
2100                 return strndup(s, old_length);
2101
2102         r = new0(char, new_length+1);
2103         if (!r)
2104                 return NULL;
2105
2106         x = (new_length * percent) / 100;
2107
2108         if (x > new_length - 3)
2109                 x = new_length - 3;
2110
2111         memcpy(r, s, x);
2112         r[x] = '.';
2113         r[x+1] = '.';
2114         r[x+2] = '.';
2115         memcpy(r + x + 3,
2116                s + old_length - (new_length - x - 3),
2117                new_length - x - 3);
2118
2119         return r;
2120 }
2121
2122 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
2123         size_t x;
2124         char *e;
2125         const char *i, *j;
2126         unsigned k, len, len2;
2127
2128         assert(s);
2129         assert(percent <= 100);
2130         assert(new_length >= 3);
2131
2132         /* if no multibyte characters use ascii_ellipsize_mem for speed */
2133         if (ascii_is_valid(s))
2134                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
2135
2136         if (old_length <= 3 || old_length <= new_length)
2137                 return strndup(s, old_length);
2138
2139         x = (new_length * percent) / 100;
2140
2141         if (x > new_length - 3)
2142                 x = new_length - 3;
2143
2144         k = 0;
2145         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
2146                 int c;
2147
2148                 c = utf8_encoded_to_unichar(i);
2149                 if (c < 0)
2150                         return NULL;
2151                 k += unichar_iswide(c) ? 2 : 1;
2152         }
2153
2154         if (k > x) /* last character was wide and went over quota */
2155                 x ++;
2156
2157         for (j = s + old_length; k < new_length && j > i; ) {
2158                 int c;
2159
2160                 j = utf8_prev_char(j);
2161                 c = utf8_encoded_to_unichar(j);
2162                 if (c < 0)
2163                         return NULL;
2164                 k += unichar_iswide(c) ? 2 : 1;
2165         }
2166         assert(i <= j);
2167
2168         /* we don't actually need to ellipsize */
2169         if (i == j)
2170                 return memdup(s, old_length + 1);
2171
2172         /* make space for ellipsis */
2173         j = utf8_next_char(j);
2174
2175         len = i - s;
2176         len2 = s + old_length - j;
2177         e = new(char, len + 3 + len2 + 1);
2178         if (!e)
2179                 return NULL;
2180
2181         /*
2182         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
2183                old_length, new_length, x, len, len2, k);
2184         */
2185
2186         memcpy(e, s, len);
2187         e[len]   = 0xe2; /* tri-dot ellipsis: … */
2188         e[len + 1] = 0x80;
2189         e[len + 2] = 0xa6;
2190
2191         memcpy(e + len + 3, j, len2 + 1);
2192
2193         return e;
2194 }
2195
2196 char *ellipsize(const char *s, size_t length, unsigned percent) {
2197         return ellipsize_mem(s, strlen(s), length, percent);
2198 }
2199
2200 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
2201         _cleanup_close_ int fd;
2202         int r;
2203
2204         assert(path);
2205
2206         if (parents)
2207                 mkdir_parents(path, 0755);
2208
2209         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
2210         if (fd < 0)
2211                 return -errno;
2212
2213         if (mode > 0) {
2214                 r = fchmod(fd, mode);
2215                 if (r < 0)
2216                         return -errno;
2217         }
2218
2219         if (uid != UID_INVALID || gid != GID_INVALID) {
2220                 r = fchown(fd, uid, gid);
2221                 if (r < 0)
2222                         return -errno;
2223         }
2224
2225         if (stamp != USEC_INFINITY) {
2226                 struct timespec ts[2];
2227
2228                 timespec_store(&ts[0], stamp);
2229                 ts[1] = ts[0];
2230                 r = futimens(fd, ts);
2231         } else
2232                 r = futimens(fd, NULL);
2233         if (r < 0)
2234                 return -errno;
2235
2236         return 0;
2237 }
2238
2239 int touch(const char *path) {
2240         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
2241 }
2242
2243 static char *unquote(const char *s, const char* quotes) {
2244         size_t l;
2245         assert(s);
2246
2247         /* This is rather stupid, simply removes the heading and
2248          * trailing quotes if there is one. Doesn't care about
2249          * escaping or anything.
2250          *
2251          * DON'T USE THIS FOR NEW CODE ANYMORE!*/
2252
2253         l = strlen(s);
2254         if (l < 2)
2255                 return strdup(s);
2256
2257         if (strchr(quotes, s[0]) && s[l-1] == s[0])
2258                 return strndup(s+1, l-2);
2259
2260         return strdup(s);
2261 }
2262
2263 noreturn void freeze(void) {
2264
2265         /* Make sure nobody waits for us on a socket anymore */
2266         close_all_fds(NULL, 0);
2267
2268         sync();
2269
2270         for (;;)
2271                 pause();
2272 }
2273
2274 bool null_or_empty(struct stat *st) {
2275         assert(st);
2276
2277         if (S_ISREG(st->st_mode) && st->st_size <= 0)
2278                 return true;
2279
2280         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
2281                 return true;
2282
2283         return false;
2284 }
2285
2286 int null_or_empty_path(const char *fn) {
2287         struct stat st;
2288
2289         assert(fn);
2290
2291         if (stat(fn, &st) < 0)
2292                 return -errno;
2293
2294         return null_or_empty(&st);
2295 }
2296
2297 int null_or_empty_fd(int fd) {
2298         struct stat st;
2299
2300         assert(fd >= 0);
2301
2302         if (fstat(fd, &st) < 0)
2303                 return -errno;
2304
2305         return null_or_empty(&st);
2306 }
2307
2308 DIR *xopendirat(int fd, const char *name, int flags) {
2309         int nfd;
2310         DIR *d;
2311
2312         assert(!(flags & O_CREAT));
2313
2314         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
2315         if (nfd < 0)
2316                 return NULL;
2317
2318         d = fdopendir(nfd);
2319         if (!d) {
2320                 safe_close(nfd);
2321                 return NULL;
2322         }
2323
2324         return d;
2325 }
2326
2327 int signal_from_string_try_harder(const char *s) {
2328         int signo;
2329         assert(s);
2330
2331         signo = signal_from_string(s);
2332         if (signo <= 0)
2333                 if (startswith(s, "SIG"))
2334                         return signal_from_string(s+3);
2335
2336         return signo;
2337 }
2338
2339 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
2340         _cleanup_free_ char *t = NULL, *u = NULL;
2341         size_t enc_len;
2342
2343         u = unquote(tagvalue, QUOTES);
2344         if (!u)
2345                 return NULL;
2346
2347         enc_len = strlen(u) * 4 + 1;
2348         t = new(char, enc_len);
2349         if (!t)
2350                 return NULL;
2351
2352         if (encode_devnode_name(u, t, enc_len) < 0)
2353                 return NULL;
2354
2355         return strjoin("/dev/disk/by-", by, "/", t, NULL);
2356 }
2357
2358 char *fstab_node_to_udev_node(const char *p) {
2359         assert(p);
2360
2361         if (startswith(p, "LABEL="))
2362                 return tag_to_udev_node(p+6, "label");
2363
2364         if (startswith(p, "UUID="))
2365                 return tag_to_udev_node(p+5, "uuid");
2366
2367         if (startswith(p, "PARTUUID="))
2368                 return tag_to_udev_node(p+9, "partuuid");
2369
2370         if (startswith(p, "PARTLABEL="))
2371                 return tag_to_udev_node(p+10, "partlabel");
2372
2373         return strdup(p);
2374 }
2375
2376 bool dirent_is_file(const struct dirent *de) {
2377         assert(de);
2378
2379         if (hidden_file(de->d_name))
2380                 return false;
2381
2382         if (de->d_type != DT_REG &&
2383             de->d_type != DT_LNK &&
2384             de->d_type != DT_UNKNOWN)
2385                 return false;
2386
2387         return true;
2388 }
2389
2390 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
2391         assert(de);
2392
2393         if (de->d_type != DT_REG &&
2394             de->d_type != DT_LNK &&
2395             de->d_type != DT_UNKNOWN)
2396                 return false;
2397
2398         if (hidden_file_allow_backup(de->d_name))
2399                 return false;
2400
2401         return endswith(de->d_name, suffix);
2402 }
2403
2404 static int do_execute(char **directories, usec_t timeout, char *argv[]) {
2405         _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
2406         _cleanup_set_free_free_ Set *seen = NULL;
2407         char **directory;
2408
2409         /* We fork this all off from a child process so that we can
2410          * somewhat cleanly make use of SIGALRM to set a time limit */
2411
2412         reset_all_signal_handlers();
2413         reset_signal_mask();
2414
2415         assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
2416
2417         pids = hashmap_new(NULL);
2418         if (!pids)
2419                 return log_oom();
2420
2421         seen = set_new(&string_hash_ops);
2422         if (!seen)
2423                 return log_oom();
2424
2425         STRV_FOREACH(directory, directories) {
2426                 _cleanup_closedir_ DIR *d;
2427                 struct dirent *de;
2428
2429                 d = opendir(*directory);
2430                 if (!d) {
2431                         if (errno == ENOENT)
2432                                 continue;
2433
2434                         return log_error_errno(errno, "Failed to open directory %s: %m", *directory);
2435                 }
2436
2437                 FOREACH_DIRENT(de, d, break) {
2438                         _cleanup_free_ char *path = NULL;
2439                         pid_t pid;
2440                         int r;
2441
2442                         if (!dirent_is_file(de))
2443                                 continue;
2444
2445                         if (set_contains(seen, de->d_name)) {
2446                                 log_debug("%1$s/%2$s skipped (%2$s was already seen).", *directory, de->d_name);
2447                                 continue;
2448                         }
2449
2450                         r = set_put_strdup(seen, de->d_name);
2451                         if (r < 0)
2452                                 return log_oom();
2453
2454                         path = strjoin(*directory, "/", de->d_name, NULL);
2455                         if (!path)
2456                                 return log_oom();
2457
2458                         if (null_or_empty_path(path)) {
2459                                 log_debug("%s is empty (a mask).", path);
2460                                 continue;
2461                         }
2462
2463                         pid = fork();
2464                         if (pid < 0) {
2465                                 log_error_errno(errno, "Failed to fork: %m");
2466                                 continue;
2467                         } else if (pid == 0) {
2468                                 char *_argv[2];
2469
2470                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
2471
2472                                 if (!argv) {
2473                                         _argv[0] = path;
2474                                         _argv[1] = NULL;
2475                                         argv = _argv;
2476                                 } else
2477                                         argv[0] = path;
2478
2479                                 execv(path, argv);
2480                                 return log_error_errno(errno, "Failed to execute %s: %m", path);
2481                         }
2482
2483                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
2484
2485                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
2486                         if (r < 0)
2487                                 return log_oom();
2488                         path = NULL;
2489                 }
2490         }
2491
2492         /* Abort execution of this process after the timout. We simply
2493          * rely on SIGALRM as default action terminating the process,
2494          * and turn on alarm(). */
2495
2496         if (timeout != USEC_INFINITY)
2497                 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
2498
2499         while (!hashmap_isempty(pids)) {
2500                 _cleanup_free_ char *path = NULL;
2501                 pid_t pid;
2502
2503                 pid = PTR_TO_UINT(hashmap_first_key(pids));
2504                 assert(pid > 0);
2505
2506                 path = hashmap_remove(pids, UINT_TO_PTR(pid));
2507                 assert(path);
2508
2509                 wait_for_terminate_and_warn(path, pid, true);
2510         }
2511
2512         return 0;
2513 }
2514
2515 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]) {
2516         pid_t executor_pid;
2517         int r;
2518         char *name;
2519         char **dirs = (char**) directories;
2520
2521         assert(!strv_isempty(dirs));
2522
2523         name = basename(dirs[0]);
2524         assert(!isempty(name));
2525
2526         /* Executes all binaries in the directories in parallel and waits
2527          * for them to finish. Optionally a timeout is applied. If a file
2528          * with the same name exists in more than one directory, the
2529          * earliest one wins. */
2530
2531         executor_pid = fork();
2532         if (executor_pid < 0) {
2533                 log_error_errno(errno, "Failed to fork: %m");
2534                 return;
2535
2536         } else if (executor_pid == 0) {
2537                 r = do_execute(dirs, timeout, argv);
2538                 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
2539         }
2540
2541         wait_for_terminate_and_warn(name, executor_pid, true);
2542 }
2543
2544 bool nulstr_contains(const char*nulstr, const char *needle) {
2545         const char *i;
2546
2547         if (!nulstr)
2548                 return false;
2549
2550         NULSTR_FOREACH(i, nulstr)
2551                 if (streq(i, needle))
2552                         return true;
2553
2554         return false;
2555 }
2556
2557 bool plymouth_running(void) {
2558         return access("/run/plymouth/pid", F_OK) >= 0;
2559 }
2560
2561 char* strshorten(char *s, size_t l) {
2562         assert(s);
2563
2564         if (l < strlen(s))
2565                 s[l] = 0;
2566
2567         return s;
2568 }
2569
2570 bool machine_name_is_valid(const char *s) {
2571
2572         if (!hostname_is_valid(s))
2573                 return false;
2574
2575         /* Machine names should be useful hostnames, but also be
2576          * useful in unit names, hence we enforce a stricter length
2577          * limitation. */
2578
2579         if (strlen(s) > 64)
2580                 return false;
2581
2582         return true;
2583 }
2584
2585 int pipe_eof(int fd) {
2586         struct pollfd pollfd = {
2587                 .fd = fd,
2588                 .events = POLLIN|POLLHUP,
2589         };
2590
2591         int r;
2592
2593         r = poll(&pollfd, 1, 0);
2594         if (r < 0)
2595                 return -errno;
2596
2597         if (r == 0)
2598                 return 0;
2599
2600         return pollfd.revents & POLLHUP;
2601 }
2602
2603 int fd_wait_for_event(int fd, int event, usec_t t) {
2604
2605         struct pollfd pollfd = {
2606                 .fd = fd,
2607                 .events = event,
2608         };
2609
2610         struct timespec ts;
2611         int r;
2612
2613         r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
2614         if (r < 0)
2615                 return -errno;
2616
2617         if (r == 0)
2618                 return 0;
2619
2620         return pollfd.revents;
2621 }
2622
2623 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
2624         FILE *f;
2625         char *t;
2626         int r, fd;
2627
2628         assert(path);
2629         assert(_f);
2630         assert(_temp_path);
2631
2632         r = tempfn_xxxxxx(path, &t);
2633         if (r < 0)
2634                 return r;
2635
2636         fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
2637         if (fd < 0) {
2638                 free(t);
2639                 return -errno;
2640         }
2641
2642         f = fdopen(fd, "we");
2643         if (!f) {
2644                 unlink(t);
2645                 free(t);
2646                 return -errno;
2647         }
2648
2649         *_f = f;
2650         *_temp_path = t;
2651
2652         return 0;
2653 }
2654
2655 int symlink_atomic(const char *from, const char *to) {
2656         _cleanup_free_ char *t = NULL;
2657         int r;
2658
2659         assert(from);
2660         assert(to);
2661
2662         r = tempfn_random(to, &t);
2663         if (r < 0)
2664                 return r;
2665
2666         if (symlink(from, t) < 0)
2667                 return -errno;
2668
2669         if (rename(t, to) < 0) {
2670                 unlink_noerrno(t);
2671                 return -errno;
2672         }
2673
2674         return 0;
2675 }
2676
2677 int symlink_idempotent(const char *from, const char *to) {
2678         _cleanup_free_ char *p = NULL;
2679         int r;
2680
2681         assert(from);
2682         assert(to);
2683
2684         if (symlink(from, to) < 0) {
2685                 if (errno != EEXIST)
2686                         return -errno;
2687
2688                 r = readlink_malloc(to, &p);
2689                 if (r < 0)
2690                         return r;
2691
2692                 if (!streq(p, from))
2693                         return -EINVAL;
2694         }
2695
2696         return 0;
2697 }
2698
2699 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
2700         _cleanup_free_ char *t = NULL;
2701         int r;
2702
2703         assert(path);
2704
2705         r = tempfn_random(path, &t);
2706         if (r < 0)
2707                 return r;
2708
2709         if (mknod(t, mode, dev) < 0)
2710                 return -errno;
2711
2712         if (rename(t, path) < 0) {
2713                 unlink_noerrno(t);
2714                 return -errno;
2715         }
2716
2717         return 0;
2718 }
2719
2720 int mkfifo_atomic(const char *path, mode_t mode) {
2721         _cleanup_free_ char *t = NULL;
2722         int r;
2723
2724         assert(path);
2725
2726         r = tempfn_random(path, &t);
2727         if (r < 0)
2728                 return r;
2729
2730         if (mkfifo(t, mode) < 0)
2731                 return -errno;
2732
2733         if (rename(t, path) < 0) {
2734                 unlink_noerrno(t);
2735                 return -errno;
2736         }
2737
2738         return 0;
2739 }
2740
2741 bool display_is_local(const char *display) {
2742         assert(display);
2743
2744         return
2745                 display[0] == ':' &&
2746                 display[1] >= '0' &&
2747                 display[1] <= '9';
2748 }
2749
2750 int socket_from_display(const char *display, char **path) {
2751         size_t k;
2752         char *f, *c;
2753
2754         assert(display);
2755         assert(path);
2756
2757         if (!display_is_local(display))
2758                 return -EINVAL;
2759
2760         k = strspn(display+1, "0123456789");
2761
2762         f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
2763         if (!f)
2764                 return -ENOMEM;
2765
2766         c = stpcpy(f, "/tmp/.X11-unix/X");
2767         memcpy(c, display+1, k);
2768         c[k] = 0;
2769
2770         *path = f;
2771
2772         return 0;
2773 }
2774
2775 int get_user_creds(
2776                 const char **username,
2777                 uid_t *uid, gid_t *gid,
2778                 const char **home,
2779                 const char **shell) {
2780
2781         struct passwd *p;
2782         uid_t u;
2783
2784         assert(username);
2785         assert(*username);
2786
2787         /* We enforce some special rules for uid=0: in order to avoid
2788          * NSS lookups for root we hardcode its data. */
2789
2790         if (streq(*username, "root") || streq(*username, "0")) {
2791                 *username = "root";
2792
2793                 if (uid)
2794                         *uid = 0;
2795
2796                 if (gid)
2797                         *gid = 0;
2798
2799                 if (home)
2800                         *home = "/root";
2801
2802                 if (shell)
2803                         *shell = "/bin/sh";
2804
2805                 return 0;
2806         }
2807
2808         if (parse_uid(*username, &u) >= 0) {
2809                 errno = 0;
2810                 p = getpwuid(u);
2811
2812                 /* If there are multiple users with the same id, make
2813                  * sure to leave $USER to the configured value instead
2814                  * of the first occurrence in the database. However if
2815                  * the uid was configured by a numeric uid, then let's
2816                  * pick the real username from /etc/passwd. */
2817                 if (p)
2818                         *username = p->pw_name;
2819         } else {
2820                 errno = 0;
2821                 p = getpwnam(*username);
2822         }
2823
2824         if (!p)
2825                 return errno > 0 ? -errno : -ESRCH;
2826
2827         if (uid)
2828                 *uid = p->pw_uid;
2829
2830         if (gid)
2831                 *gid = p->pw_gid;
2832
2833         if (home)
2834                 *home = p->pw_dir;
2835
2836         if (shell)
2837                 *shell = p->pw_shell;
2838
2839         return 0;
2840 }
2841
2842 char* uid_to_name(uid_t uid) {
2843         struct passwd *p;
2844         char *r;
2845
2846         if (uid == 0)
2847                 return strdup("root");
2848
2849         p = getpwuid(uid);
2850         if (p)
2851                 return strdup(p->pw_name);
2852
2853         if (asprintf(&r, UID_FMT, uid) < 0)
2854                 return NULL;
2855
2856         return r;
2857 }
2858
2859 char* gid_to_name(gid_t gid) {
2860         struct group *p;
2861         char *r;
2862
2863         if (gid == 0)
2864                 return strdup("root");
2865
2866         p = getgrgid(gid);
2867         if (p)
2868                 return strdup(p->gr_name);
2869
2870         if (asprintf(&r, GID_FMT, gid) < 0)
2871                 return NULL;
2872
2873         return r;
2874 }
2875
2876 int get_group_creds(const char **groupname, gid_t *gid) {
2877         struct group *g;
2878         gid_t id;
2879
2880         assert(groupname);
2881
2882         /* We enforce some special rules for gid=0: in order to avoid
2883          * NSS lookups for root we hardcode its data. */
2884
2885         if (streq(*groupname, "root") || streq(*groupname, "0")) {
2886                 *groupname = "root";
2887
2888                 if (gid)
2889                         *gid = 0;
2890
2891                 return 0;
2892         }
2893
2894         if (parse_gid(*groupname, &id) >= 0) {
2895                 errno = 0;
2896                 g = getgrgid(id);
2897
2898                 if (g)
2899                         *groupname = g->gr_name;
2900         } else {
2901                 errno = 0;
2902                 g = getgrnam(*groupname);
2903         }
2904
2905         if (!g)
2906                 return errno > 0 ? -errno : -ESRCH;
2907
2908         if (gid)
2909                 *gid = g->gr_gid;
2910
2911         return 0;
2912 }
2913
2914 int in_gid(gid_t gid) {
2915         gid_t *gids;
2916         int ngroups_max, r, i;
2917
2918         if (getgid() == gid)
2919                 return 1;
2920
2921         if (getegid() == gid)
2922                 return 1;
2923
2924         ngroups_max = sysconf(_SC_NGROUPS_MAX);
2925         assert(ngroups_max > 0);
2926
2927         gids = alloca(sizeof(gid_t) * ngroups_max);
2928
2929         r = getgroups(ngroups_max, gids);
2930         if (r < 0)
2931                 return -errno;
2932
2933         for (i = 0; i < r; i++)
2934                 if (gids[i] == gid)
2935                         return 1;
2936
2937         return 0;
2938 }
2939
2940 int in_group(const char *name) {
2941         int r;
2942         gid_t gid;
2943
2944         r = get_group_creds(&name, &gid);
2945         if (r < 0)
2946                 return r;
2947
2948         return in_gid(gid);
2949 }
2950
2951 int glob_exists(const char *path) {
2952         _cleanup_globfree_ glob_t g = {};
2953         int k;
2954
2955         assert(path);
2956
2957         errno = 0;
2958         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
2959
2960         if (k == GLOB_NOMATCH)
2961                 return 0;
2962         else if (k == GLOB_NOSPACE)
2963                 return -ENOMEM;
2964         else if (k == 0)
2965                 return !strv_isempty(g.gl_pathv);
2966         else
2967                 return errno ? -errno : -EIO;
2968 }
2969
2970 int glob_extend(char ***strv, const char *path) {
2971         _cleanup_globfree_ glob_t g = {};
2972         int k;
2973         char **p;
2974
2975         errno = 0;
2976         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
2977
2978         if (k == GLOB_NOMATCH)
2979                 return -ENOENT;
2980         else if (k == GLOB_NOSPACE)
2981                 return -ENOMEM;
2982         else if (k != 0 || strv_isempty(g.gl_pathv))
2983                 return errno ? -errno : -EIO;
2984
2985         STRV_FOREACH(p, g.gl_pathv) {
2986                 k = strv_extend(strv, *p);
2987                 if (k < 0)
2988                         break;
2989         }
2990
2991         return k;
2992 }
2993
2994 int dirent_ensure_type(DIR *d, struct dirent *de) {
2995         struct stat st;
2996
2997         assert(d);
2998         assert(de);
2999
3000         if (de->d_type != DT_UNKNOWN)
3001                 return 0;
3002
3003         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
3004                 return -errno;
3005
3006         de->d_type =
3007                 S_ISREG(st.st_mode)  ? DT_REG  :
3008                 S_ISDIR(st.st_mode)  ? DT_DIR  :
3009                 S_ISLNK(st.st_mode)  ? DT_LNK  :
3010                 S_ISFIFO(st.st_mode) ? DT_FIFO :
3011                 S_ISSOCK(st.st_mode) ? DT_SOCK :
3012                 S_ISCHR(st.st_mode)  ? DT_CHR  :
3013                 S_ISBLK(st.st_mode)  ? DT_BLK  :
3014                                        DT_UNKNOWN;
3015
3016         return 0;
3017 }
3018
3019 int get_files_in_directory(const char *path, char ***list) {
3020         _cleanup_closedir_ DIR *d = NULL;
3021         size_t bufsize = 0, n = 0;
3022         _cleanup_strv_free_ char **l = NULL;
3023
3024         assert(path);
3025
3026         /* Returns all files in a directory in *list, and the number
3027          * of files as return value. If list is NULL returns only the
3028          * number. */
3029
3030         d = opendir(path);
3031         if (!d)
3032                 return -errno;
3033
3034         for (;;) {
3035                 struct dirent *de;
3036
3037                 errno = 0;
3038                 de = readdir(d);
3039                 if (!de && errno != 0)
3040                         return -errno;
3041                 if (!de)
3042                         break;
3043
3044                 dirent_ensure_type(d, de);
3045
3046                 if (!dirent_is_file(de))
3047                         continue;
3048
3049                 if (list) {
3050                         /* one extra slot is needed for the terminating NULL */
3051                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
3052                                 return -ENOMEM;
3053
3054                         l[n] = strdup(de->d_name);
3055                         if (!l[n])
3056                                 return -ENOMEM;
3057
3058                         l[++n] = NULL;
3059                 } else
3060                         n++;
3061         }
3062
3063         if (list) {
3064                 *list = l;
3065                 l = NULL; /* avoid freeing */
3066         }
3067
3068         return n;
3069 }
3070
3071 char *strjoin(const char *x, ...) {
3072         va_list ap;
3073         size_t l;
3074         char *r, *p;
3075
3076         va_start(ap, x);
3077
3078         if (x) {
3079                 l = strlen(x);
3080
3081                 for (;;) {
3082                         const char *t;
3083                         size_t n;
3084
3085                         t = va_arg(ap, const char *);
3086                         if (!t)
3087                                 break;
3088
3089                         n = strlen(t);
3090                         if (n > ((size_t) -1) - l) {
3091                                 va_end(ap);
3092                                 return NULL;
3093                         }
3094
3095                         l += n;
3096                 }
3097         } else
3098                 l = 0;
3099
3100         va_end(ap);
3101
3102         r = new(char, l+1);
3103         if (!r)
3104                 return NULL;
3105
3106         if (x) {
3107                 p = stpcpy(r, x);
3108
3109                 va_start(ap, x);
3110
3111                 for (;;) {
3112                         const char *t;
3113
3114                         t = va_arg(ap, const char *);
3115                         if (!t)
3116                                 break;
3117
3118                         p = stpcpy(p, t);
3119                 }
3120
3121                 va_end(ap);
3122         } else
3123                 r[0] = 0;
3124
3125         return r;
3126 }
3127
3128 bool is_main_thread(void) {
3129         static thread_local int cached = 0;
3130
3131         if (_unlikely_(cached == 0))
3132                 cached = getpid() == gettid() ? 1 : -1;
3133
3134         return cached > 0;
3135 }
3136
3137 int block_get_whole_disk(dev_t d, dev_t *ret) {
3138         char *p, *s;
3139         int r;
3140         unsigned n, m;
3141
3142         assert(ret);
3143
3144         /* If it has a queue this is good enough for us */
3145         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
3146                 return -ENOMEM;
3147
3148         r = access(p, F_OK);
3149         free(p);
3150
3151         if (r >= 0) {
3152                 *ret = d;
3153                 return 0;
3154         }
3155
3156         /* If it is a partition find the originating device */
3157         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
3158                 return -ENOMEM;
3159
3160         r = access(p, F_OK);
3161         free(p);
3162
3163         if (r < 0)
3164                 return -ENOENT;
3165
3166         /* Get parent dev_t */
3167         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
3168                 return -ENOMEM;
3169
3170         r = read_one_line_file(p, &s);
3171         free(p);
3172
3173         if (r < 0)
3174                 return r;
3175
3176         r = sscanf(s, "%u:%u", &m, &n);
3177         free(s);
3178
3179         if (r != 2)
3180                 return -EINVAL;
3181
3182         /* Only return this if it is really good enough for us. */
3183         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
3184                 return -ENOMEM;
3185
3186         r = access(p, F_OK);
3187         free(p);
3188
3189         if (r >= 0) {
3190                 *ret = makedev(m, n);
3191                 return 0;
3192         }
3193
3194         return -ENOENT;
3195 }
3196
3197 static const char *const ioprio_class_table[] = {
3198         [IOPRIO_CLASS_NONE] = "none",
3199         [IOPRIO_CLASS_RT] = "realtime",
3200         [IOPRIO_CLASS_BE] = "best-effort",
3201         [IOPRIO_CLASS_IDLE] = "idle"
3202 };
3203
3204 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
3205
3206 static const char *const sigchld_code_table[] = {
3207         [CLD_EXITED] = "exited",
3208         [CLD_KILLED] = "killed",
3209         [CLD_DUMPED] = "dumped",
3210         [CLD_TRAPPED] = "trapped",
3211         [CLD_STOPPED] = "stopped",
3212         [CLD_CONTINUED] = "continued",
3213 };
3214
3215 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
3216
3217 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
3218         [LOG_FAC(LOG_KERN)] = "kern",
3219         [LOG_FAC(LOG_USER)] = "user",
3220         [LOG_FAC(LOG_MAIL)] = "mail",
3221         [LOG_FAC(LOG_DAEMON)] = "daemon",
3222         [LOG_FAC(LOG_AUTH)] = "auth",
3223         [LOG_FAC(LOG_SYSLOG)] = "syslog",
3224         [LOG_FAC(LOG_LPR)] = "lpr",
3225         [LOG_FAC(LOG_NEWS)] = "news",
3226         [LOG_FAC(LOG_UUCP)] = "uucp",
3227         [LOG_FAC(LOG_CRON)] = "cron",
3228         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
3229         [LOG_FAC(LOG_FTP)] = "ftp",
3230         [LOG_FAC(LOG_LOCAL0)] = "local0",
3231         [LOG_FAC(LOG_LOCAL1)] = "local1",
3232         [LOG_FAC(LOG_LOCAL2)] = "local2",
3233         [LOG_FAC(LOG_LOCAL3)] = "local3",
3234         [LOG_FAC(LOG_LOCAL4)] = "local4",
3235         [LOG_FAC(LOG_LOCAL5)] = "local5",
3236         [LOG_FAC(LOG_LOCAL6)] = "local6",
3237         [LOG_FAC(LOG_LOCAL7)] = "local7"
3238 };
3239
3240 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
3241
3242 static const char *const log_level_table[] = {
3243         [LOG_EMERG] = "emerg",
3244         [LOG_ALERT] = "alert",
3245         [LOG_CRIT] = "crit",
3246         [LOG_ERR] = "err",
3247         [LOG_WARNING] = "warning",
3248         [LOG_NOTICE] = "notice",
3249         [LOG_INFO] = "info",
3250         [LOG_DEBUG] = "debug"
3251 };
3252
3253 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
3254
3255 static const char* const sched_policy_table[] = {
3256         [SCHED_OTHER] = "other",
3257         [SCHED_BATCH] = "batch",
3258         [SCHED_IDLE] = "idle",
3259         [SCHED_FIFO] = "fifo",
3260         [SCHED_RR] = "rr"
3261 };
3262
3263 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
3264
3265 static const char* const rlimit_table[_RLIMIT_MAX] = {
3266         [RLIMIT_CPU] = "LimitCPU",
3267         [RLIMIT_FSIZE] = "LimitFSIZE",
3268         [RLIMIT_DATA] = "LimitDATA",
3269         [RLIMIT_STACK] = "LimitSTACK",
3270         [RLIMIT_CORE] = "LimitCORE",
3271         [RLIMIT_RSS] = "LimitRSS",
3272         [RLIMIT_NOFILE] = "LimitNOFILE",
3273         [RLIMIT_AS] = "LimitAS",
3274         [RLIMIT_NPROC] = "LimitNPROC",
3275         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
3276         [RLIMIT_LOCKS] = "LimitLOCKS",
3277         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
3278         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
3279         [RLIMIT_NICE] = "LimitNICE",
3280         [RLIMIT_RTPRIO] = "LimitRTPRIO",
3281         [RLIMIT_RTTIME] = "LimitRTTIME"
3282 };
3283
3284 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
3285
3286 static const char* const ip_tos_table[] = {
3287         [IPTOS_LOWDELAY] = "low-delay",
3288         [IPTOS_THROUGHPUT] = "throughput",
3289         [IPTOS_RELIABILITY] = "reliability",
3290         [IPTOS_LOWCOST] = "low-cost",
3291 };
3292
3293 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
3294
3295 static const char *const __signal_table[] = {
3296         [SIGHUP] = "HUP",
3297         [SIGINT] = "INT",
3298         [SIGQUIT] = "QUIT",
3299         [SIGILL] = "ILL",
3300         [SIGTRAP] = "TRAP",
3301         [SIGABRT] = "ABRT",
3302         [SIGBUS] = "BUS",
3303         [SIGFPE] = "FPE",
3304         [SIGKILL] = "KILL",
3305         [SIGUSR1] = "USR1",
3306         [SIGSEGV] = "SEGV",
3307         [SIGUSR2] = "USR2",
3308         [SIGPIPE] = "PIPE",
3309         [SIGALRM] = "ALRM",
3310         [SIGTERM] = "TERM",
3311 #ifdef SIGSTKFLT
3312         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
3313 #endif
3314         [SIGCHLD] = "CHLD",
3315         [SIGCONT] = "CONT",
3316         [SIGSTOP] = "STOP",
3317         [SIGTSTP] = "TSTP",
3318         [SIGTTIN] = "TTIN",
3319         [SIGTTOU] = "TTOU",
3320         [SIGURG] = "URG",
3321         [SIGXCPU] = "XCPU",
3322         [SIGXFSZ] = "XFSZ",
3323         [SIGVTALRM] = "VTALRM",
3324         [SIGPROF] = "PROF",
3325         [SIGWINCH] = "WINCH",
3326         [SIGIO] = "IO",
3327         [SIGPWR] = "PWR",
3328         [SIGSYS] = "SYS"
3329 };
3330
3331 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
3332
3333 const char *signal_to_string(int signo) {
3334         static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
3335         const char *name;
3336
3337         name = __signal_to_string(signo);
3338         if (name)
3339                 return name;
3340
3341         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
3342                 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
3343         else
3344                 snprintf(buf, sizeof(buf), "%d", signo);
3345
3346         return buf;
3347 }
3348
3349 int signal_from_string(const char *s) {
3350         int signo;
3351         int offset = 0;
3352         unsigned u;
3353
3354         signo = __signal_from_string(s);
3355         if (signo > 0)
3356                 return signo;
3357
3358         if (startswith(s, "RTMIN+")) {
3359                 s += 6;
3360                 offset = SIGRTMIN;
3361         }
3362         if (safe_atou(s, &u) >= 0) {
3363                 signo = (int) u + offset;
3364                 if (signo > 0 && signo < _NSIG)
3365                         return signo;
3366         }
3367         return -EINVAL;
3368 }
3369
3370 bool kexec_loaded(void) {
3371        bool loaded = false;
3372        char *s;
3373
3374        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
3375                if (s[0] == '1')
3376                        loaded = true;
3377                free(s);
3378        }
3379        return loaded;
3380 }
3381
3382 int prot_from_flags(int flags) {
3383
3384         switch (flags & O_ACCMODE) {
3385
3386         case O_RDONLY:
3387                 return PROT_READ;
3388
3389         case O_WRONLY:
3390                 return PROT_WRITE;
3391
3392         case O_RDWR:
3393                 return PROT_READ|PROT_WRITE;
3394
3395         default:
3396                 return -EINVAL;
3397         }
3398 }
3399
3400 char *format_bytes(char *buf, size_t l, off_t t) {
3401         unsigned i;
3402
3403         static const struct {
3404                 const char *suffix;
3405                 off_t factor;
3406         } table[] = {
3407                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3408                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3409                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
3410                 { "G", 1024ULL*1024ULL*1024ULL },
3411                 { "M", 1024ULL*1024ULL },
3412                 { "K", 1024ULL },
3413         };
3414
3415         if (t == (off_t) -1)
3416                 return NULL;
3417
3418         for (i = 0; i < ELEMENTSOF(table); i++) {
3419
3420                 if (t >= table[i].factor) {
3421                         snprintf(buf, l,
3422                                  "%llu.%llu%s",
3423                                  (unsigned long long) (t / table[i].factor),
3424                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
3425                                  table[i].suffix);
3426
3427                         goto finish;
3428                 }
3429         }
3430
3431         snprintf(buf, l, "%lluB", (unsigned long long) t);
3432
3433 finish:
3434         buf[l-1] = 0;
3435         return buf;
3436
3437 }
3438
3439 void* memdup(const void *p, size_t l) {
3440         void *r;
3441
3442         assert(p);
3443
3444         r = malloc(l);
3445         if (!r)
3446                 return NULL;
3447
3448         memcpy(r, p, l);
3449         return r;
3450 }
3451
3452 int fd_inc_sndbuf(int fd, size_t n) {
3453         int r, value;
3454         socklen_t l = sizeof(value);
3455
3456         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
3457         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
3458                 return 0;
3459
3460         /* If we have the privileges we will ignore the kernel limit. */
3461
3462         value = (int) n;
3463         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
3464                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
3465                         return -errno;
3466
3467         return 1;
3468 }
3469
3470 int fd_inc_rcvbuf(int fd, size_t n) {
3471         int r, value;
3472         socklen_t l = sizeof(value);
3473
3474         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
3475         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
3476                 return 0;
3477
3478         /* If we have the privileges we will ignore the kernel limit. */
3479
3480         value = (int) n;
3481         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
3482                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
3483                         return -errno;
3484         return 1;
3485 }
3486
3487 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
3488         bool stdout_is_tty, stderr_is_tty;
3489         pid_t parent_pid, agent_pid;
3490         sigset_t ss, saved_ss;
3491         unsigned n, i;
3492         va_list ap;
3493         char **l;
3494
3495         assert(pid);
3496         assert(path);
3497
3498         /* Spawns a temporary TTY agent, making sure it goes away when
3499          * we go away */
3500
3501         parent_pid = getpid();
3502
3503         /* First we temporarily block all signals, so that the new
3504          * child has them blocked initially. This way, we can be sure
3505          * that SIGTERMs are not lost we might send to the agent. */
3506         assert_se(sigfillset(&ss) >= 0);
3507         assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
3508
3509         agent_pid = fork();
3510         if (agent_pid < 0) {
3511                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
3512                 return -errno;
3513         }
3514
3515         if (agent_pid != 0) {
3516                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
3517                 *pid = agent_pid;
3518                 return 0;
3519         }
3520
3521         /* In the child:
3522          *
3523          * Make sure the agent goes away when the parent dies */
3524         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
3525                 _exit(EXIT_FAILURE);
3526
3527         /* Make sure we actually can kill the agent, if we need to, in
3528          * case somebody invoked us from a shell script that trapped
3529          * SIGTERM or so... */
3530         reset_all_signal_handlers();
3531         reset_signal_mask();
3532
3533         /* Check whether our parent died before we were able
3534          * to set the death signal and unblock the signals */
3535         if (getppid() != parent_pid)
3536                 _exit(EXIT_SUCCESS);
3537
3538         /* Don't leak fds to the agent */
3539         close_all_fds(except, n_except);
3540
3541         stdout_is_tty = isatty(STDOUT_FILENO);
3542         stderr_is_tty = isatty(STDERR_FILENO);
3543
3544         if (!stdout_is_tty || !stderr_is_tty) {
3545                 int fd;
3546
3547                 /* Detach from stdout/stderr. and reopen
3548                  * /dev/tty for them. This is important to
3549                  * ensure that when systemctl is started via
3550                  * popen() or a similar call that expects to
3551                  * read EOF we actually do generate EOF and
3552                  * not delay this indefinitely by because we
3553                  * keep an unused copy of stdin around. */
3554                 fd = open("/dev/tty", O_WRONLY);
3555                 if (fd < 0) {
3556                         log_error_errno(errno, "Failed to open /dev/tty: %m");
3557                         _exit(EXIT_FAILURE);
3558                 }
3559
3560                 if (!stdout_is_tty)
3561                         dup2(fd, STDOUT_FILENO);
3562
3563                 if (!stderr_is_tty)
3564                         dup2(fd, STDERR_FILENO);
3565
3566                 if (fd > 2)
3567                         close(fd);
3568         }
3569
3570         /* Count arguments */
3571         va_start(ap, path);
3572         for (n = 0; va_arg(ap, char*); n++)
3573                 ;
3574         va_end(ap);
3575
3576         /* Allocate strv */
3577         l = alloca(sizeof(char *) * (n + 1));
3578
3579         /* Fill in arguments */
3580         va_start(ap, path);
3581         for (i = 0; i <= n; i++)
3582                 l[i] = va_arg(ap, char*);
3583         va_end(ap);
3584
3585         execv(path, l);
3586         _exit(EXIT_FAILURE);
3587 }
3588
3589 int setrlimit_closest(int resource, const struct rlimit *rlim) {
3590         struct rlimit highest, fixed;
3591
3592         assert(rlim);
3593
3594         if (setrlimit(resource, rlim) >= 0)
3595                 return 0;
3596
3597         if (errno != EPERM)
3598                 return -errno;
3599
3600         /* So we failed to set the desired setrlimit, then let's try
3601          * to get as close as we can */
3602         assert_se(getrlimit(resource, &highest) == 0);
3603
3604         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
3605         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
3606
3607         if (setrlimit(resource, &fixed) < 0)
3608                 return -errno;
3609
3610         return 0;
3611 }
3612
3613 bool http_etag_is_valid(const char *etag) {
3614         if (isempty(etag))
3615                 return false;
3616
3617         if (!endswith(etag, "\""))
3618                 return false;
3619
3620         if (!startswith(etag, "\"") && !startswith(etag, "W/\""))
3621                 return false;
3622
3623         return true;
3624 }
3625
3626 bool http_url_is_valid(const char *url) {
3627         const char *p;
3628
3629         if (isempty(url))
3630                 return false;
3631
3632         p = startswith(url, "http://");
3633         if (!p)
3634                 p = startswith(url, "https://");
3635         if (!p)
3636                 return false;
3637
3638         if (isempty(p))
3639                 return false;
3640
3641         return ascii_is_valid(p);
3642 }
3643
3644 bool documentation_url_is_valid(const char *url) {
3645         const char *p;
3646
3647         if (isempty(url))
3648                 return false;
3649
3650         if (http_url_is_valid(url))
3651                 return true;
3652
3653         p = startswith(url, "file:/");
3654         if (!p)
3655                 p = startswith(url, "info:");
3656         if (!p)
3657                 p = startswith(url, "man:");
3658
3659         if (isempty(p))
3660                 return false;
3661
3662         return ascii_is_valid(p);
3663 }
3664
3665 bool in_initrd(void) {
3666         static int saved = -1;
3667         struct statfs s;
3668
3669         if (saved >= 0)
3670                 return saved;
3671
3672         /* We make two checks here:
3673          *
3674          * 1. the flag file /etc/initrd-release must exist
3675          * 2. the root file system must be a memory file system
3676          *
3677          * The second check is extra paranoia, since misdetecting an
3678          * initrd can have bad bad consequences due the initrd
3679          * emptying when transititioning to the main systemd.
3680          */
3681
3682         saved = access("/etc/initrd-release", F_OK) >= 0 &&
3683                 statfs("/", &s) >= 0 &&
3684                 is_temporary_fs(&s);
3685
3686         return saved;
3687 }
3688
3689 int get_home_dir(char **_h) {
3690         struct passwd *p;
3691         const char *e;
3692         char *h;
3693         uid_t u;
3694
3695         assert(_h);
3696
3697         /* Take the user specified one */
3698         e = secure_getenv("HOME");
3699         if (e && path_is_absolute(e)) {
3700                 h = strdup(e);
3701                 if (!h)
3702                         return -ENOMEM;
3703
3704                 *_h = h;
3705                 return 0;
3706         }
3707
3708         /* Hardcode home directory for root to avoid NSS */
3709         u = getuid();
3710         if (u == 0) {
3711                 h = strdup("/root");
3712                 if (!h)
3713                         return -ENOMEM;
3714
3715                 *_h = h;
3716                 return 0;
3717         }
3718
3719         /* Check the database... */
3720         errno = 0;
3721         p = getpwuid(u);
3722         if (!p)
3723                 return errno > 0 ? -errno : -ESRCH;
3724
3725         if (!path_is_absolute(p->pw_dir))
3726                 return -EINVAL;
3727
3728         h = strdup(p->pw_dir);
3729         if (!h)
3730                 return -ENOMEM;
3731
3732         *_h = h;
3733         return 0;
3734 }
3735
3736 int get_shell(char **_s) {
3737         struct passwd *p;
3738         const char *e;
3739         char *s;
3740         uid_t u;
3741
3742         assert(_s);
3743
3744         /* Take the user specified one */
3745         e = getenv("SHELL");
3746         if (e) {
3747                 s = strdup(e);
3748                 if (!s)
3749                         return -ENOMEM;
3750
3751                 *_s = s;
3752                 return 0;
3753         }
3754
3755         /* Hardcode home directory for root to avoid NSS */
3756         u = getuid();
3757         if (u == 0) {
3758                 s = strdup("/bin/sh");
3759                 if (!s)
3760                         return -ENOMEM;
3761
3762                 *_s = s;
3763                 return 0;
3764         }
3765
3766         /* Check the database... */
3767         errno = 0;
3768         p = getpwuid(u);
3769         if (!p)
3770                 return errno > 0 ? -errno : -ESRCH;
3771
3772         if (!path_is_absolute(p->pw_shell))
3773                 return -EINVAL;
3774
3775         s = strdup(p->pw_shell);
3776         if (!s)
3777                 return -ENOMEM;
3778
3779         *_s = s;
3780         return 0;
3781 }
3782
3783 bool filename_is_valid(const char *p) {
3784
3785         if (isempty(p))
3786                 return false;
3787
3788         if (strchr(p, '/'))
3789                 return false;
3790
3791         if (streq(p, "."))
3792                 return false;
3793
3794         if (streq(p, ".."))
3795                 return false;
3796
3797         if (strlen(p) > FILENAME_MAX)
3798                 return false;
3799
3800         return true;
3801 }
3802
3803 bool string_is_safe(const char *p) {
3804         const char *t;
3805
3806         if (!p)
3807                 return false;
3808
3809         for (t = p; *t; t++) {
3810                 if (*t > 0 && *t < ' ')
3811                         return false;
3812
3813                 if (strchr("\\\"\'\0x7f", *t))
3814                         return false;
3815         }
3816
3817         return true;
3818 }
3819
3820 /**
3821  * Check if a string contains control characters. If 'ok' is non-NULL
3822  * it may be a string containing additional CCs to be considered OK.
3823  */
3824 bool string_has_cc(const char *p, const char *ok) {
3825         const char *t;
3826
3827         assert(p);
3828
3829         for (t = p; *t; t++) {
3830                 if (ok && strchr(ok, *t))
3831                         continue;
3832
3833                 if (*t > 0 && *t < ' ')
3834                         return true;
3835
3836                 if (*t == 127)
3837                         return true;
3838         }
3839
3840         return false;
3841 }
3842
3843 bool path_is_safe(const char *p) {
3844
3845         if (isempty(p))
3846                 return false;
3847
3848         if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
3849                 return false;
3850
3851         if (strlen(p)+1 > PATH_MAX)
3852                 return false;
3853
3854         /* The following two checks are not really dangerous, but hey, they still are confusing */
3855         if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
3856                 return false;
3857
3858         if (strstr(p, "//"))
3859                 return false;
3860
3861         return true;
3862 }
3863
3864 /* hey glibc, APIs with callbacks without a user pointer are so useless */
3865 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
3866                  int (*compar) (const void *, const void *, void *), void *arg) {
3867         size_t l, u, idx;
3868         const void *p;
3869         int comparison;
3870
3871         l = 0;
3872         u = nmemb;
3873         while (l < u) {
3874                 idx = (l + u) / 2;
3875                 p = (void *)(((const char *) base) + (idx * size));
3876                 comparison = compar(key, p, arg);
3877                 if (comparison < 0)
3878                         u = idx;
3879                 else if (comparison > 0)
3880                         l = idx + 1;
3881                 else
3882                         return (void *)p;
3883         }
3884         return NULL;
3885 }
3886
3887 void init_gettext(void) {
3888         setlocale(LC_ALL, "");
3889         textdomain(GETTEXT_PACKAGE);
3890 }
3891
3892 bool is_locale_utf8(void) {
3893         const char *set;
3894         static int cached_answer = -1;
3895
3896         if (cached_answer >= 0)
3897                 goto out;
3898
3899         if (!setlocale(LC_ALL, "")) {
3900                 cached_answer = true;
3901                 goto out;
3902         }
3903
3904         set = nl_langinfo(CODESET);
3905         if (!set) {
3906                 cached_answer = true;
3907                 goto out;
3908         }
3909
3910         if (streq(set, "UTF-8")) {
3911                 cached_answer = true;
3912                 goto out;
3913         }
3914
3915         /* For LC_CTYPE=="C" return true, because CTYPE is effectly
3916          * unset and everything can do to UTF-8 nowadays. */
3917         set = setlocale(LC_CTYPE, NULL);
3918         if (!set) {
3919                 cached_answer = true;
3920                 goto out;
3921         }
3922
3923         /* Check result, but ignore the result if C was set
3924          * explicitly. */
3925         cached_answer =
3926                 streq(set, "C") &&
3927                 !getenv("LC_ALL") &&
3928                 !getenv("LC_CTYPE") &&
3929                 !getenv("LANG");
3930
3931 out:
3932         return (bool) cached_answer;
3933 }
3934
3935 const char *draw_special_char(DrawSpecialChar ch) {
3936         static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
3937
3938                 /* UTF-8 */ {
3939                         [DRAW_TREE_VERTICAL]      = "\342\224\202 ",            /* │  */
3940                         [DRAW_TREE_BRANCH]        = "\342\224\234\342\224\200", /* ├─ */
3941                         [DRAW_TREE_RIGHT]         = "\342\224\224\342\224\200", /* └─ */
3942                         [DRAW_TREE_SPACE]         = "  ",                       /*    */
3943                         [DRAW_TRIANGULAR_BULLET]  = "\342\200\243",             /* ‣ */
3944                         [DRAW_BLACK_CIRCLE]       = "\342\227\217",             /* ● */
3945                         [DRAW_ARROW]              = "\342\206\222",             /* → */
3946                         [DRAW_DASH]               = "\342\200\223",             /* – */
3947                 },
3948
3949                 /* ASCII fallback */ {
3950                         [DRAW_TREE_VERTICAL]      = "| ",
3951                         [DRAW_TREE_BRANCH]        = "|-",
3952                         [DRAW_TREE_RIGHT]         = "`-",
3953                         [DRAW_TREE_SPACE]         = "  ",
3954                         [DRAW_TRIANGULAR_BULLET]  = ">",
3955                         [DRAW_BLACK_CIRCLE]       = "*",
3956                         [DRAW_ARROW]              = "->",
3957                         [DRAW_DASH]               = "-",
3958                 }
3959         };
3960
3961         return draw_table[!is_locale_utf8()][ch];
3962 }
3963
3964 char *strreplace(const char *text, const char *old_string, const char *new_string) {
3965         const char *f;
3966         char *t, *r;
3967         size_t l, old_len, new_len;
3968
3969         assert(text);
3970         assert(old_string);
3971         assert(new_string);
3972
3973         old_len = strlen(old_string);
3974         new_len = strlen(new_string);
3975
3976         l = strlen(text);
3977         r = new(char, l+1);
3978         if (!r)
3979                 return NULL;
3980
3981         f = text;
3982         t = r;
3983         while (*f) {
3984                 char *a;
3985                 size_t d, nl;
3986
3987                 if (!startswith(f, old_string)) {
3988                         *(t++) = *(f++);
3989                         continue;
3990                 }
3991
3992                 d = t - r;
3993                 nl = l - old_len + new_len;
3994                 a = realloc(r, nl + 1);
3995                 if (!a)
3996                         goto oom;
3997
3998                 l = nl;
3999                 r = a;
4000                 t = r + d;
4001
4002                 t = stpcpy(t, new_string);
4003                 f += old_len;
4004         }
4005
4006         *t = 0;
4007         return r;
4008
4009 oom:
4010         free(r);
4011         return NULL;
4012 }
4013
4014 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
4015         const char *i, *begin = NULL;
4016         enum {
4017                 STATE_OTHER,
4018                 STATE_ESCAPE,
4019                 STATE_BRACKET
4020         } state = STATE_OTHER;
4021         char *obuf = NULL;
4022         size_t osz = 0, isz;
4023         FILE *f;
4024
4025         assert(ibuf);
4026         assert(*ibuf);
4027
4028         /* Strips ANSI color and replaces TABs by 8 spaces */
4029
4030         isz = _isz ? *_isz : strlen(*ibuf);
4031
4032         f = open_memstream(&obuf, &osz);
4033         if (!f)
4034                 return NULL;
4035
4036         for (i = *ibuf; i < *ibuf + isz + 1; i++) {
4037
4038                 switch (state) {
4039
4040                 case STATE_OTHER:
4041                         if (i >= *ibuf + isz) /* EOT */
4042                                 break;
4043                         else if (*i == '\x1B')
4044                                 state = STATE_ESCAPE;
4045                         else if (*i == '\t')
4046                                 fputs("        ", f);
4047                         else
4048                                 fputc(*i, f);
4049                         break;
4050
4051                 case STATE_ESCAPE:
4052                         if (i >= *ibuf + isz) { /* EOT */
4053                                 fputc('\x1B', f);
4054                                 break;
4055                         } else if (*i == '[') {
4056                                 state = STATE_BRACKET;
4057                                 begin = i + 1;
4058                         } else {
4059                                 fputc('\x1B', f);
4060                                 fputc(*i, f);
4061                                 state = STATE_OTHER;
4062                         }
4063
4064                         break;
4065
4066                 case STATE_BRACKET:
4067
4068                         if (i >= *ibuf + isz || /* EOT */
4069                             (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
4070                                 fputc('\x1B', f);
4071                                 fputc('[', f);
4072                                 state = STATE_OTHER;
4073                                 i = begin-1;
4074                         } else if (*i == 'm')
4075                                 state = STATE_OTHER;
4076                         break;
4077                 }
4078         }
4079
4080         if (ferror(f)) {
4081                 fclose(f);
4082                 free(obuf);
4083                 return NULL;
4084         }
4085
4086         fclose(f);
4087
4088         free(*ibuf);
4089         *ibuf = obuf;
4090
4091         if (_isz)
4092                 *_isz = osz;
4093
4094         return obuf;
4095 }
4096
4097 int on_ac_power(void) {
4098         bool found_offline = false, found_online = false;
4099         _cleanup_closedir_ DIR *d = NULL;
4100
4101         d = opendir("/sys/class/power_supply");
4102         if (!d)
4103                 return errno == ENOENT ? true : -errno;
4104
4105         for (;;) {
4106                 struct dirent *de;
4107                 _cleanup_close_ int fd = -1, device = -1;
4108                 char contents[6];
4109                 ssize_t n;
4110
4111                 errno = 0;
4112                 de = readdir(d);
4113                 if (!de && errno != 0)
4114                         return -errno;
4115
4116                 if (!de)
4117                         break;
4118
4119                 if (hidden_file(de->d_name))
4120                         continue;
4121
4122                 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
4123                 if (device < 0) {
4124                         if (errno == ENOENT || errno == ENOTDIR)
4125                                 continue;
4126
4127                         return -errno;
4128                 }
4129
4130                 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
4131                 if (fd < 0) {
4132                         if (errno == ENOENT)
4133                                 continue;
4134
4135                         return -errno;
4136                 }
4137
4138                 n = read(fd, contents, sizeof(contents));
4139                 if (n < 0)
4140                         return -errno;
4141
4142                 if (n != 6 || memcmp(contents, "Mains\n", 6))
4143                         continue;
4144
4145                 safe_close(fd);
4146                 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
4147                 if (fd < 0) {
4148                         if (errno == ENOENT)
4149                                 continue;
4150
4151                         return -errno;
4152                 }
4153
4154                 n = read(fd, contents, sizeof(contents));
4155                 if (n < 0)
4156                         return -errno;
4157
4158                 if (n != 2 || contents[1] != '\n')
4159                         return -EIO;
4160
4161                 if (contents[0] == '1') {
4162                         found_online = true;
4163                         break;
4164                 } else if (contents[0] == '0')
4165                         found_offline = true;
4166                 else
4167                         return -EIO;
4168         }
4169
4170         return found_online || !found_offline;
4171 }
4172
4173 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
4174         char **i;
4175
4176         assert(path);
4177         assert(mode);
4178         assert(_f);
4179
4180         if (!path_strv_resolve_uniq(search, root))
4181                 return -ENOMEM;
4182
4183         STRV_FOREACH(i, search) {
4184                 _cleanup_free_ char *p = NULL;
4185                 FILE *f;
4186
4187                 if (root)
4188                         p = strjoin(root, *i, "/", path, NULL);
4189                 else
4190                         p = strjoin(*i, "/", path, NULL);
4191                 if (!p)
4192                         return -ENOMEM;
4193
4194                 f = fopen(p, mode);
4195                 if (f) {
4196                         *_f = f;
4197                         return 0;
4198                 }
4199
4200                 if (errno != ENOENT)
4201                         return -errno;
4202         }
4203
4204         return -ENOENT;
4205 }
4206
4207 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
4208         _cleanup_strv_free_ char **copy = NULL;
4209
4210         assert(path);
4211         assert(mode);
4212         assert(_f);
4213
4214         if (path_is_absolute(path)) {
4215                 FILE *f;
4216
4217                 f = fopen(path, mode);
4218                 if (f) {
4219                         *_f = f;
4220                         return 0;
4221                 }
4222
4223                 return -errno;
4224         }
4225
4226         copy = strv_copy((char**) search);
4227         if (!copy)
4228                 return -ENOMEM;
4229
4230         return search_and_fopen_internal(path, mode, root, copy, _f);
4231 }
4232
4233 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
4234         _cleanup_strv_free_ char **s = NULL;
4235
4236         if (path_is_absolute(path)) {
4237                 FILE *f;
4238
4239                 f = fopen(path, mode);
4240                 if (f) {
4241                         *_f = f;
4242                         return 0;
4243                 }
4244
4245                 return -errno;
4246         }
4247
4248         s = strv_split_nulstr(search);
4249         if (!s)
4250                 return -ENOMEM;
4251
4252         return search_and_fopen_internal(path, mode, root, s, _f);
4253 }
4254
4255 char *strextend(char **x, ...) {
4256         va_list ap;
4257         size_t f, l;
4258         char *r, *p;
4259
4260         assert(x);
4261
4262         l = f = *x ? strlen(*x) : 0;
4263
4264         va_start(ap, x);
4265         for (;;) {
4266                 const char *t;
4267                 size_t n;
4268
4269                 t = va_arg(ap, const char *);
4270                 if (!t)
4271                         break;
4272
4273                 n = strlen(t);
4274                 if (n > ((size_t) -1) - l) {
4275                         va_end(ap);
4276                         return NULL;
4277                 }
4278
4279                 l += n;
4280         }
4281         va_end(ap);
4282
4283         r = realloc(*x, l+1);
4284         if (!r)
4285                 return NULL;
4286
4287         p = r + f;
4288
4289         va_start(ap, x);
4290         for (;;) {
4291                 const char *t;
4292
4293                 t = va_arg(ap, const char *);
4294                 if (!t)
4295                         break;
4296
4297                 p = stpcpy(p, t);
4298         }
4299         va_end(ap);
4300
4301         *p = 0;
4302         *x = r;
4303
4304         return r + l;
4305 }
4306
4307 char *strrep(const char *s, unsigned n) {
4308         size_t l;
4309         char *r, *p;
4310         unsigned i;
4311
4312         assert(s);
4313
4314         l = strlen(s);
4315         p = r = malloc(l * n + 1);
4316         if (!r)
4317                 return NULL;
4318
4319         for (i = 0; i < n; i++)
4320                 p = stpcpy(p, s);
4321
4322         *p = 0;
4323         return r;
4324 }
4325
4326 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
4327         size_t a, newalloc;
4328         void *q;
4329
4330         assert(p);
4331         assert(allocated);
4332
4333         if (*allocated >= need)
4334                 return *p;
4335
4336         newalloc = MAX(need * 2, 64u / size);
4337         a = newalloc * size;
4338
4339         /* check for overflows */
4340         if (a < size * need)
4341                 return NULL;
4342
4343         q = realloc(*p, a);
4344         if (!q)
4345                 return NULL;
4346
4347         *p = q;
4348         *allocated = newalloc;
4349         return q;
4350 }
4351
4352 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
4353         size_t prev;
4354         uint8_t *q;
4355
4356         assert(p);
4357         assert(allocated);
4358
4359         prev = *allocated;
4360
4361         q = greedy_realloc(p, allocated, need, size);
4362         if (!q)
4363                 return NULL;
4364
4365         if (*allocated > prev)
4366                 memzero(q + prev * size, (*allocated - prev) * size);
4367
4368         return q;
4369 }
4370
4371 bool id128_is_valid(const char *s) {
4372         size_t i, l;
4373
4374         l = strlen(s);
4375         if (l == 32) {
4376
4377                 /* Simple formatted 128bit hex string */
4378
4379                 for (i = 0; i < l; i++) {
4380                         char c = s[i];
4381
4382                         if (!(c >= '0' && c <= '9') &&
4383                             !(c >= 'a' && c <= 'z') &&
4384                             !(c >= 'A' && c <= 'Z'))
4385                                 return false;
4386                 }
4387
4388         } else if (l == 36) {
4389
4390                 /* Formatted UUID */
4391
4392                 for (i = 0; i < l; i++) {
4393                         char c = s[i];
4394
4395                         if ((i == 8 || i == 13 || i == 18 || i == 23)) {
4396                                 if (c != '-')
4397                                         return false;
4398                         } else {
4399                                 if (!(c >= '0' && c <= '9') &&
4400                                     !(c >= 'a' && c <= 'z') &&
4401                                     !(c >= 'A' && c <= 'Z'))
4402                                         return false;
4403                         }
4404                 }
4405
4406         } else
4407                 return false;
4408
4409         return true;
4410 }
4411
4412 int split_pair(const char *s, const char *sep, char **l, char **r) {
4413         char *x, *a, *b;
4414
4415         assert(s);
4416         assert(sep);
4417         assert(l);
4418         assert(r);
4419
4420         if (isempty(sep))
4421                 return -EINVAL;
4422
4423         x = strstr(s, sep);
4424         if (!x)
4425                 return -EINVAL;
4426
4427         a = strndup(s, x - s);
4428         if (!a)
4429                 return -ENOMEM;
4430
4431         b = strdup(x + strlen(sep));
4432         if (!b) {
4433                 free(a);
4434                 return -ENOMEM;
4435         }
4436
4437         *l = a;
4438         *r = b;
4439
4440         return 0;
4441 }
4442
4443 int shall_restore_state(void) {
4444         _cleanup_free_ char *value = NULL;
4445         int r;
4446
4447         r = get_proc_cmdline_key("systemd.restore_state=", &value);
4448         if (r < 0)
4449                 return r;
4450         if (r == 0)
4451                 return true;
4452
4453         return parse_boolean(value) != 0;
4454 }
4455
4456 int proc_cmdline(char **ret) {
4457         assert(ret);
4458
4459         if (detect_container(NULL) > 0)
4460                 return get_process_cmdline(1, 0, false, ret);
4461         else
4462                 return read_one_line_file("/proc/cmdline", ret);
4463 }
4464
4465 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
4466         _cleanup_free_ char *line = NULL;
4467         const char *p;
4468         int r;
4469
4470         assert(parse_item);
4471
4472         r = proc_cmdline(&line);
4473         if (r < 0)
4474                 return r;
4475
4476         p = line;
4477         for (;;) {
4478                 _cleanup_free_ char *word = NULL;
4479                 char *value = NULL;
4480
4481                 r = unquote_first_word(&p, &word, UNQUOTE_RELAX);
4482                 if (r < 0)
4483                         return r;
4484                 if (r == 0)
4485                         break;
4486
4487                 /* Filter out arguments that are intended only for the
4488                  * initrd */
4489                 if (!in_initrd() && startswith(word, "rd."))
4490                         continue;
4491
4492                 value = strchr(word, '=');
4493                 if (value)
4494                         *(value++) = 0;
4495
4496                 r = parse_item(word, value);
4497                 if (r < 0)
4498                         return r;
4499         }
4500
4501         return 0;
4502 }
4503
4504 int get_proc_cmdline_key(const char *key, char **value) {
4505         _cleanup_free_ char *line = NULL, *ret = NULL;
4506         bool found = false;
4507         const char *p;
4508         int r;
4509
4510         assert(key);
4511
4512         r = proc_cmdline(&line);
4513         if (r < 0)
4514                 return r;
4515
4516         p = line;
4517         for (;;) {
4518                 _cleanup_free_ char *word = NULL;
4519                 const char *e;
4520
4521                 r = unquote_first_word(&p, &word, UNQUOTE_RELAX);
4522                 if (r < 0)
4523                         return r;
4524                 if (r == 0)
4525                         break;
4526
4527                 /* Filter out arguments that are intended only for the
4528                  * initrd */
4529                 if (!in_initrd() && startswith(word, "rd."))
4530                         continue;
4531
4532                 if (value) {
4533                         e = startswith(word, key);
4534                         if (!e)
4535                                 continue;
4536
4537                         r = free_and_strdup(&ret, e);
4538                         if (r < 0)
4539                                 return r;
4540
4541                         found = true;
4542                 } else {
4543                         if (streq(word, key))
4544                                 found = true;
4545                 }
4546         }
4547
4548         if (value) {
4549                 *value = ret;
4550                 ret = NULL;
4551         }
4552
4553         return found;
4554
4555 }
4556
4557 int container_get_leader(const char *machine, pid_t *pid) {
4558         _cleanup_free_ char *s = NULL, *class = NULL;
4559         const char *p;
4560         pid_t leader;
4561         int r;
4562
4563         assert(machine);
4564         assert(pid);
4565
4566         p = strjoina("/run/systemd/machines/", machine);
4567         r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
4568         if (r == -ENOENT)
4569                 return -EHOSTDOWN;
4570         if (r < 0)
4571                 return r;
4572         if (!s)
4573                 return -EIO;
4574
4575         if (!streq_ptr(class, "container"))
4576                 return -EIO;
4577
4578         r = parse_pid(s, &leader);
4579         if (r < 0)
4580                 return r;
4581         if (leader <= 1)
4582                 return -EIO;
4583
4584         *pid = leader;
4585         return 0;
4586 }
4587
4588 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
4589         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
4590         int rfd = -1;
4591
4592         assert(pid >= 0);
4593
4594         if (mntns_fd) {
4595                 const char *mntns;
4596
4597                 mntns = procfs_file_alloca(pid, "ns/mnt");
4598                 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
4599                 if (mntnsfd < 0)
4600                         return -errno;
4601         }
4602
4603         if (pidns_fd) {
4604                 const char *pidns;
4605
4606                 pidns = procfs_file_alloca(pid, "ns/pid");
4607                 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
4608                 if (pidnsfd < 0)
4609                         return -errno;
4610         }
4611
4612         if (netns_fd) {
4613                 const char *netns;
4614
4615                 netns = procfs_file_alloca(pid, "ns/net");
4616                 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
4617                 if (netnsfd < 0)
4618                         return -errno;
4619         }
4620
4621         if (root_fd) {
4622                 const char *root;
4623
4624                 root = procfs_file_alloca(pid, "root");
4625                 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
4626                 if (rfd < 0)
4627                         return -errno;
4628         }
4629
4630         if (pidns_fd)
4631                 *pidns_fd = pidnsfd;
4632
4633         if (mntns_fd)
4634                 *mntns_fd = mntnsfd;
4635
4636         if (netns_fd)
4637                 *netns_fd = netnsfd;
4638
4639         if (root_fd)
4640                 *root_fd = rfd;
4641
4642         pidnsfd = mntnsfd = netnsfd = -1;
4643
4644         return 0;
4645 }
4646
4647 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
4648
4649         if (pidns_fd >= 0)
4650                 if (setns(pidns_fd, CLONE_NEWPID) < 0)
4651                         return -errno;
4652
4653         if (mntns_fd >= 0)
4654                 if (setns(mntns_fd, CLONE_NEWNS) < 0)
4655                         return -errno;
4656
4657         if (netns_fd >= 0)
4658                 if (setns(netns_fd, CLONE_NEWNET) < 0)
4659                         return -errno;
4660
4661         if (root_fd >= 0) {
4662                 if (fchdir(root_fd) < 0)
4663                         return -errno;
4664
4665                 if (chroot(".") < 0)
4666                         return -errno;
4667         }
4668
4669         if (setresgid(0, 0, 0) < 0)
4670                 return -errno;
4671
4672         if (setgroups(0, NULL) < 0)
4673                 return -errno;
4674
4675         if (setresuid(0, 0, 0) < 0)
4676                 return -errno;
4677
4678         return 0;
4679 }
4680
4681 int getpeercred(int fd, struct ucred *ucred) {
4682         socklen_t n = sizeof(struct ucred);
4683         struct ucred u;
4684         int r;
4685
4686         assert(fd >= 0);
4687         assert(ucred);
4688
4689         r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
4690         if (r < 0)
4691                 return -errno;
4692
4693         if (n != sizeof(struct ucred))
4694                 return -EIO;
4695
4696         /* Check if the data is actually useful and not suppressed due
4697          * to namespacing issues */
4698         if (u.pid <= 0)
4699                 return -ENODATA;
4700         if (u.uid == UID_INVALID)
4701                 return -ENODATA;
4702         if (u.gid == GID_INVALID)
4703                 return -ENODATA;
4704
4705         *ucred = u;
4706         return 0;
4707 }
4708
4709 int getpeersec(int fd, char **ret) {
4710         socklen_t n = 64;
4711         char *s;
4712         int r;
4713
4714         assert(fd >= 0);
4715         assert(ret);
4716
4717         s = new0(char, n);
4718         if (!s)
4719                 return -ENOMEM;
4720
4721         r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
4722         if (r < 0) {
4723                 free(s);
4724
4725                 if (errno != ERANGE)
4726                         return -errno;
4727
4728                 s = new0(char, n);
4729                 if (!s)
4730                         return -ENOMEM;
4731
4732                 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
4733                 if (r < 0) {
4734                         free(s);
4735                         return -errno;
4736                 }
4737         }
4738
4739         if (isempty(s)) {
4740                 free(s);
4741                 return -EOPNOTSUPP;
4742         }
4743
4744         *ret = s;
4745         return 0;
4746 }
4747
4748 /* This is much like like mkostemp() but is subject to umask(). */
4749 int mkostemp_safe(char *pattern, int flags) {
4750         _cleanup_umask_ mode_t u;
4751         int fd;
4752
4753         assert(pattern);
4754
4755         u = umask(077);
4756
4757         fd = mkostemp(pattern, flags);
4758         if (fd < 0)
4759                 return -errno;
4760
4761         return fd;
4762 }
4763
4764 int open_tmpfile(const char *path, int flags) {
4765         char *p;
4766         int fd;
4767
4768         assert(path);
4769
4770 #ifdef O_TMPFILE
4771         /* Try O_TMPFILE first, if it is supported */
4772         fd = open(path, flags|O_TMPFILE|O_EXCL, S_IRUSR|S_IWUSR);
4773         if (fd >= 0)
4774                 return fd;
4775 #endif
4776
4777         /* Fall back to unguessable name + unlinking */
4778         p = strjoina(path, "/systemd-tmp-XXXXXX");
4779
4780         fd = mkostemp_safe(p, flags);
4781         if (fd < 0)
4782                 return fd;
4783
4784         unlink(p);
4785         return fd;
4786 }
4787
4788 int fd_warn_permissions(const char *path, int fd) {
4789         struct stat st;
4790
4791         if (fstat(fd, &st) < 0)
4792                 return -errno;
4793
4794         if (st.st_mode & 0111)
4795                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
4796
4797         if (st.st_mode & 0002)
4798                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
4799
4800         if (getpid() == 1 && (st.st_mode & 0044) != 0044)
4801                 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);
4802
4803         return 0;
4804 }
4805
4806 unsigned long personality_from_string(const char *p) {
4807
4808         /* Parse a personality specifier. We introduce our own
4809          * identifiers that indicate specific ABIs, rather than just
4810          * hints regarding the register size, since we want to keep
4811          * things open for multiple locally supported ABIs for the
4812          * same register size. We try to reuse the ABI identifiers
4813          * used by libseccomp. */
4814
4815 #if defined(__x86_64__)
4816
4817         if (streq(p, "x86"))
4818                 return PER_LINUX32;
4819
4820         if (streq(p, "x86-64"))
4821                 return PER_LINUX;
4822
4823 #elif defined(__i386__)
4824
4825         if (streq(p, "x86"))
4826                 return PER_LINUX;
4827 #endif
4828
4829         /* personality(7) documents that 0xffffffffUL is used for
4830          * querying the current personality, hence let's use that here
4831          * as error indicator. */
4832         return 0xffffffffUL;
4833 }
4834
4835 const char* personality_to_string(unsigned long p) {
4836
4837 #if defined(__x86_64__)
4838
4839         if (p == PER_LINUX32)
4840                 return "x86";
4841
4842         if (p == PER_LINUX)
4843                 return "x86-64";
4844
4845 #elif defined(__i386__)
4846
4847         if (p == PER_LINUX)
4848                 return "x86";
4849 #endif
4850
4851         return NULL;
4852 }
4853
4854 uint64_t physical_memory(void) {
4855         long mem;
4856
4857         /* We return this as uint64_t in case we are running as 32bit
4858          * process on a 64bit kernel with huge amounts of memory */
4859
4860         mem = sysconf(_SC_PHYS_PAGES);
4861         assert(mem > 0);
4862
4863         return (uint64_t) mem * (uint64_t) page_size();
4864 }
4865
4866 void hexdump(FILE *f, const void *p, size_t s) {
4867         const uint8_t *b = p;
4868         unsigned n = 0;
4869
4870         assert(s == 0 || b);
4871
4872         while (s > 0) {
4873                 size_t i;
4874
4875                 fprintf(f, "%04x  ", n);
4876
4877                 for (i = 0; i < 16; i++) {
4878
4879                         if (i >= s)
4880                                 fputs("   ", f);
4881                         else
4882                                 fprintf(f, "%02x ", b[i]);
4883
4884                         if (i == 7)
4885                                 fputc(' ', f);
4886                 }
4887
4888                 fputc(' ', f);
4889
4890                 for (i = 0; i < 16; i++) {
4891
4892                         if (i >= s)
4893                                 fputc(' ', f);
4894                         else
4895                                 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
4896                 }
4897
4898                 fputc('\n', f);
4899
4900                 if (s < 16)
4901                         break;
4902
4903                 n += 16;
4904                 b += 16;
4905                 s -= 16;
4906         }
4907 }
4908
4909 int update_reboot_param_file(const char *param) {
4910         int r = 0;
4911
4912         if (param) {
4913
4914                 r = write_string_file(REBOOT_PARAM_FILE, param);
4915                 if (r < 0)
4916                         log_error("Failed to write reboot param to "
4917                                   REBOOT_PARAM_FILE": %s", strerror(-r));
4918         } else
4919                 unlink(REBOOT_PARAM_FILE);
4920
4921         return r;
4922 }
4923
4924 int umount_recursive(const char *prefix, int flags) {
4925         bool again;
4926         int n = 0, r;
4927
4928         /* Try to umount everything recursively below a
4929          * directory. Also, take care of stacked mounts, and keep
4930          * unmounting them until they are gone. */
4931
4932         do {
4933                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
4934
4935                 again = false;
4936                 r = 0;
4937
4938                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
4939                 if (!proc_self_mountinfo)
4940                         return -errno;
4941
4942                 for (;;) {
4943                         _cleanup_free_ char *path = NULL, *p = NULL;
4944                         int k;
4945
4946                         k = fscanf(proc_self_mountinfo,
4947                                    "%*s "       /* (1) mount id */
4948                                    "%*s "       /* (2) parent id */
4949                                    "%*s "       /* (3) major:minor */
4950                                    "%*s "       /* (4) root */
4951                                    "%ms "       /* (5) mount point */
4952                                    "%*s"        /* (6) mount options */
4953                                    "%*[^-]"     /* (7) optional fields */
4954                                    "- "         /* (8) separator */
4955                                    "%*s "       /* (9) file system type */
4956                                    "%*s"        /* (10) mount source */
4957                                    "%*s"        /* (11) mount options 2 */
4958                                    "%*[^\n]",   /* some rubbish at the end */
4959                                    &path);
4960                         if (k != 1) {
4961                                 if (k == EOF)
4962                                         break;
4963
4964                                 continue;
4965                         }
4966
4967                         r = cunescape(path, UNESCAPE_RELAX, &p);
4968                         if (r < 0)
4969                                 return r;
4970
4971                         if (!path_startswith(p, prefix))
4972                                 continue;
4973
4974                         if (umount2(p, flags) < 0) {
4975                                 r = -errno;
4976                                 continue;
4977                         }
4978
4979                         again = true;
4980                         n++;
4981
4982                         break;
4983                 }
4984
4985         } while (again);
4986
4987         return r ? r : n;
4988 }
4989
4990 static int get_mount_flags(const char *path, unsigned long *flags) {
4991         struct statvfs buf;
4992
4993         if (statvfs(path, &buf) < 0)
4994                 return -errno;
4995         *flags = buf.f_flag;
4996         return 0;
4997 }
4998
4999 int bind_remount_recursive(const char *prefix, bool ro) {
5000         _cleanup_set_free_free_ Set *done = NULL;
5001         _cleanup_free_ char *cleaned = NULL;
5002         int r;
5003
5004         /* Recursively remount a directory (and all its submounts)
5005          * read-only or read-write. If the directory is already
5006          * mounted, we reuse the mount and simply mark it
5007          * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
5008          * operation). If it isn't we first make it one. Afterwards we
5009          * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
5010          * submounts we can access, too. When mounts are stacked on
5011          * the same mount point we only care for each individual
5012          * "top-level" mount on each point, as we cannot
5013          * influence/access the underlying mounts anyway. We do not
5014          * have any effect on future submounts that might get
5015          * propagated, they migt be writable. This includes future
5016          * submounts that have been triggered via autofs. */
5017
5018         cleaned = strdup(prefix);
5019         if (!cleaned)
5020                 return -ENOMEM;
5021
5022         path_kill_slashes(cleaned);
5023
5024         done = set_new(&string_hash_ops);
5025         if (!done)
5026                 return -ENOMEM;
5027
5028         for (;;) {
5029                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
5030                 _cleanup_set_free_free_ Set *todo = NULL;
5031                 bool top_autofs = false;
5032                 char *x;
5033                 unsigned long orig_flags;
5034
5035                 todo = set_new(&string_hash_ops);
5036                 if (!todo)
5037                         return -ENOMEM;
5038
5039                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
5040                 if (!proc_self_mountinfo)
5041                         return -errno;
5042
5043                 for (;;) {
5044                         _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
5045                         int k;
5046
5047                         k = fscanf(proc_self_mountinfo,
5048                                    "%*s "       /* (1) mount id */
5049                                    "%*s "       /* (2) parent id */
5050                                    "%*s "       /* (3) major:minor */
5051                                    "%*s "       /* (4) root */
5052                                    "%ms "       /* (5) mount point */
5053                                    "%*s"        /* (6) mount options (superblock) */
5054                                    "%*[^-]"     /* (7) optional fields */
5055                                    "- "         /* (8) separator */
5056                                    "%ms "       /* (9) file system type */
5057                                    "%*s"        /* (10) mount source */
5058                                    "%*s"        /* (11) mount options (bind mount) */
5059                                    "%*[^\n]",   /* some rubbish at the end */
5060                                    &path,
5061                                    &type);
5062                         if (k != 2) {
5063                                 if (k == EOF)
5064                                         break;
5065
5066                                 continue;
5067                         }
5068
5069                         r = cunescape(path, UNESCAPE_RELAX, &p);
5070                         if (r < 0)
5071                                 return r;
5072
5073                         /* Let's ignore autofs mounts.  If they aren't
5074                          * triggered yet, we want to avoid triggering
5075                          * them, as we don't make any guarantees for
5076                          * future submounts anyway.  If they are
5077                          * already triggered, then we will find
5078                          * another entry for this. */
5079                         if (streq(type, "autofs")) {
5080                                 top_autofs = top_autofs || path_equal(cleaned, p);
5081                                 continue;
5082                         }
5083
5084                         if (path_startswith(p, cleaned) &&
5085                             !set_contains(done, p)) {
5086
5087                                 r = set_consume(todo, p);
5088                                 p = NULL;
5089
5090                                 if (r == -EEXIST)
5091                                         continue;
5092                                 if (r < 0)
5093                                         return r;
5094                         }
5095                 }
5096
5097                 /* If we have no submounts to process anymore and if
5098                  * the root is either already done, or an autofs, we
5099                  * are done */
5100                 if (set_isempty(todo) &&
5101                     (top_autofs || set_contains(done, cleaned)))
5102                         return 0;
5103
5104                 if (!set_contains(done, cleaned) &&
5105                     !set_contains(todo, cleaned)) {
5106                         /* The prefix directory itself is not yet a
5107                          * mount, make it one. */
5108                         if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
5109                                 return -errno;
5110
5111                         orig_flags = 0;
5112                         (void) get_mount_flags(cleaned, &orig_flags);
5113                         orig_flags &= ~MS_RDONLY;
5114
5115                         if (mount(NULL, prefix, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
5116                                 return -errno;
5117
5118                         x = strdup(cleaned);
5119                         if (!x)
5120                                 return -ENOMEM;
5121
5122                         r = set_consume(done, x);
5123                         if (r < 0)
5124                                 return r;
5125                 }
5126
5127                 while ((x = set_steal_first(todo))) {
5128
5129                         r = set_consume(done, x);
5130                         if (r == -EEXIST)
5131                                 continue;
5132                         if (r < 0)
5133                                 return r;
5134
5135                         /* Try to reuse the original flag set, but
5136                          * don't care for errors, in case of
5137                          * obstructed mounts */
5138                         orig_flags = 0;
5139                         (void) get_mount_flags(x, &orig_flags);
5140                         orig_flags &= ~MS_RDONLY;
5141
5142                         if (mount(NULL, x, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
5143
5144                                 /* Deal with mount points that are
5145                                  * obstructed by a later mount */
5146
5147                                 if (errno != ENOENT)
5148                                         return -errno;
5149                         }
5150
5151                 }
5152         }
5153 }
5154
5155 int fflush_and_check(FILE *f) {
5156         assert(f);
5157
5158         errno = 0;
5159         fflush(f);
5160
5161         if (ferror(f))
5162                 return errno ? -errno : -EIO;
5163
5164         return 0;
5165 }
5166
5167 int tempfn_xxxxxx(const char *p, char **ret) {
5168         const char *fn;
5169         char *t;
5170
5171         assert(p);
5172         assert(ret);
5173
5174         /*
5175          * Turns this:
5176          *         /foo/bar/waldo
5177          *
5178          * Into this:
5179          *         /foo/bar/.#waldoXXXXXX
5180          */
5181
5182         fn = basename(p);
5183         if (!filename_is_valid(fn))
5184                 return -EINVAL;
5185
5186         t = new(char, strlen(p) + 2 + 6 + 1);
5187         if (!t)
5188                 return -ENOMEM;
5189
5190         strcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn), "XXXXXX");
5191
5192         *ret = path_kill_slashes(t);
5193         return 0;
5194 }
5195
5196 int tempfn_random(const char *p, char **ret) {
5197         const char *fn;
5198         char *t, *x;
5199         uint64_t u;
5200         unsigned i;
5201
5202         assert(p);
5203         assert(ret);
5204
5205         /*
5206          * Turns this:
5207          *         /foo/bar/waldo
5208          *
5209          * Into this:
5210          *         /foo/bar/.#waldobaa2a261115984a9
5211          */
5212
5213         fn = basename(p);
5214         if (!filename_is_valid(fn))
5215                 return -EINVAL;
5216
5217         t = new(char, strlen(p) + 2 + 16 + 1);
5218         if (!t)
5219                 return -ENOMEM;
5220
5221         x = stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn);
5222
5223         u = random_u64();
5224         for (i = 0; i < 16; i++) {
5225                 *(x++) = hexchar(u & 0xF);
5226                 u >>= 4;
5227         }
5228
5229         *x = 0;
5230
5231         *ret = path_kill_slashes(t);
5232         return 0;
5233 }
5234
5235 int tempfn_random_child(const char *p, char **ret) {
5236         char *t, *x;
5237         uint64_t u;
5238         unsigned i;
5239
5240         assert(p);
5241         assert(ret);
5242
5243         /* Turns this:
5244          *         /foo/bar/waldo
5245          * Into this:
5246          *         /foo/bar/waldo/.#3c2b6219aa75d7d0
5247          */
5248
5249         t = new(char, strlen(p) + 3 + 16 + 1);
5250         if (!t)
5251                 return -ENOMEM;
5252
5253         x = stpcpy(stpcpy(t, p), "/.#");
5254
5255         u = random_u64();
5256         for (i = 0; i < 16; i++) {
5257                 *(x++) = hexchar(u & 0xF);
5258                 u >>= 4;
5259         }
5260
5261         *x = 0;
5262
5263         *ret = path_kill_slashes(t);
5264         return 0;
5265 }
5266
5267 int take_password_lock(const char *root) {
5268
5269         struct flock flock = {
5270                 .l_type = F_WRLCK,
5271                 .l_whence = SEEK_SET,
5272                 .l_start = 0,
5273                 .l_len = 0,
5274         };
5275
5276         const char *path;
5277         int fd, r;
5278
5279         /* This is roughly the same as lckpwdf(), but not as awful. We
5280          * don't want to use alarm() and signals, hence we implement
5281          * our own trivial version of this.
5282          *
5283          * Note that shadow-utils also takes per-database locks in
5284          * addition to lckpwdf(). However, we don't given that they
5285          * are redundant as they they invoke lckpwdf() first and keep
5286          * it during everything they do. The per-database locks are
5287          * awfully racy, and thus we just won't do them. */
5288
5289         if (root)
5290                 path = strjoina(root, "/etc/.pwd.lock");
5291         else
5292                 path = "/etc/.pwd.lock";
5293
5294         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
5295         if (fd < 0)
5296                 return -errno;
5297
5298         r = fcntl(fd, F_SETLKW, &flock);
5299         if (r < 0) {
5300                 safe_close(fd);
5301                 return -errno;
5302         }
5303
5304         return fd;
5305 }
5306
5307 int is_symlink(const char *path) {
5308         struct stat info;
5309
5310         if (lstat(path, &info) < 0)
5311                 return -errno;
5312
5313         return !!S_ISLNK(info.st_mode);
5314 }
5315
5316 int is_dir(const char* path, bool follow) {
5317         struct stat st;
5318         int r;
5319
5320         if (follow)
5321                 r = stat(path, &st);
5322         else
5323                 r = lstat(path, &st);
5324         if (r < 0)
5325                 return -errno;
5326
5327         return !!S_ISDIR(st.st_mode);
5328 }
5329
5330 int is_device_node(const char *path) {
5331         struct stat info;
5332
5333         if (lstat(path, &info) < 0)
5334                 return -errno;
5335
5336         return !!(S_ISBLK(info.st_mode) || S_ISCHR(info.st_mode));
5337 }
5338
5339 int unquote_first_word(const char **p, char **ret, UnquoteFlags flags) {
5340         _cleanup_free_ char *s = NULL;
5341         size_t allocated = 0, sz = 0;
5342         int r;
5343
5344         enum {
5345                 START,
5346                 VALUE,
5347                 VALUE_ESCAPE,
5348                 SINGLE_QUOTE,
5349                 SINGLE_QUOTE_ESCAPE,
5350                 DOUBLE_QUOTE,
5351                 DOUBLE_QUOTE_ESCAPE,
5352                 SPACE,
5353         } state = START;
5354
5355         assert(p);
5356         assert(*p);
5357         assert(ret);
5358
5359         /* Parses the first word of a string, and returns it in
5360          * *ret. Removes all quotes in the process. When parsing fails
5361          * (because of an uneven number of quotes or similar), leaves
5362          * the pointer *p at the first invalid character. */
5363
5364         for (;;) {
5365                 char c = **p;
5366
5367                 switch (state) {
5368
5369                 case START:
5370                         if (c == 0)
5371                                 goto finish;
5372                         else if (strchr(WHITESPACE, c))
5373                                 break;
5374
5375                         state = VALUE;
5376                         /* fallthrough */
5377
5378                 case VALUE:
5379                         if (c == 0)
5380                                 goto finish;
5381                         else if (c == '\'')
5382                                 state = SINGLE_QUOTE;
5383                         else if (c == '\\')
5384                                 state = VALUE_ESCAPE;
5385                         else if (c == '\"')
5386                                 state = DOUBLE_QUOTE;
5387                         else if (strchr(WHITESPACE, c))
5388                                 state = SPACE;
5389                         else {
5390                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
5391                                         return -ENOMEM;
5392
5393                                 s[sz++] = c;
5394                         }
5395
5396                         break;
5397
5398                 case VALUE_ESCAPE:
5399                         if (c == 0) {
5400                                 if (flags & UNQUOTE_RELAX)
5401                                         goto finish;
5402                                 return -EINVAL;
5403                         }
5404
5405                         if (!GREEDY_REALLOC(s, allocated, sz+7))
5406                                 return -ENOMEM;
5407
5408                         if (flags & UNQUOTE_CUNESCAPE) {
5409                                 uint32_t u;
5410
5411                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
5412                                 if (r < 0)
5413                                         return -EINVAL;
5414
5415                                 (*p) += r - 1;
5416
5417                                 if (c != 0)
5418                                         s[sz++] = c; /* normal explicit char */
5419                                 else
5420                                         sz += utf8_encode_unichar(s + sz, u); /* unicode chars we'll encode as utf8 */
5421                         } else
5422                                 s[sz++] = c;
5423
5424                         state = VALUE;
5425                         break;
5426
5427                 case SINGLE_QUOTE:
5428                         if (c == 0) {
5429                                 if (flags & UNQUOTE_RELAX)
5430                                         goto finish;
5431                                 return -EINVAL;
5432                         } else if (c == '\'')
5433                                 state = VALUE;
5434                         else if (c == '\\')
5435                                 state = SINGLE_QUOTE_ESCAPE;
5436                         else {
5437                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
5438                                         return -ENOMEM;
5439
5440                                 s[sz++] = c;
5441                         }
5442
5443                         break;
5444
5445                 case SINGLE_QUOTE_ESCAPE:
5446                         if (c == 0) {
5447                                 if (flags & UNQUOTE_RELAX)
5448                                         goto finish;
5449                                 return -EINVAL;
5450                         }
5451
5452                         if (!GREEDY_REALLOC(s, allocated, sz+7))
5453                                 return -ENOMEM;
5454
5455                         if (flags & UNQUOTE_CUNESCAPE) {
5456                                 uint32_t u;
5457
5458                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
5459                                 if (r < 0)
5460                                         return -EINVAL;
5461
5462                                 (*p) += r - 1;
5463
5464                                 if (c != 0)
5465                                         s[sz++] = c;
5466                                 else
5467                                         sz += utf8_encode_unichar(s + sz, u);
5468                         } else
5469                                 s[sz++] = c;
5470
5471                         state = SINGLE_QUOTE;
5472                         break;
5473
5474                 case DOUBLE_QUOTE:
5475                         if (c == 0)
5476                                 return -EINVAL;
5477                         else if (c == '\"')
5478                                 state = VALUE;
5479                         else if (c == '\\')
5480                                 state = DOUBLE_QUOTE_ESCAPE;
5481                         else {
5482                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
5483                                         return -ENOMEM;
5484
5485                                 s[sz++] = c;
5486                         }
5487
5488                         break;
5489
5490                 case DOUBLE_QUOTE_ESCAPE:
5491                         if (c == 0) {
5492                                 if (flags & UNQUOTE_RELAX)
5493                                         goto finish;
5494                                 return -EINVAL;
5495                         }
5496
5497                         if (!GREEDY_REALLOC(s, allocated, sz+7))
5498                                 return -ENOMEM;
5499
5500                         if (flags & UNQUOTE_CUNESCAPE) {
5501                                 uint32_t u;
5502
5503                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
5504                                 if (r < 0)
5505                                         return -EINVAL;
5506
5507                                 (*p) += r - 1;
5508
5509                                 if (c != 0)
5510                                         s[sz++] = c;
5511                                 else
5512                                         sz += utf8_encode_unichar(s + sz, u);
5513                         } else
5514                                 s[sz++] = c;
5515
5516                         state = DOUBLE_QUOTE;
5517                         break;
5518
5519                 case SPACE:
5520                         if (c == 0)
5521                                 goto finish;
5522                         if (!strchr(WHITESPACE, c))
5523                                 goto finish;
5524
5525                         break;
5526                 }
5527
5528                 (*p) ++;
5529         }
5530
5531 finish:
5532         if (!s) {
5533                 *ret = NULL;
5534                 return 0;
5535         }
5536
5537         s[sz] = 0;
5538         *ret = s;
5539         s = NULL;
5540
5541         return 1;
5542 }
5543
5544 int unquote_many_words(const char **p, UnquoteFlags flags, ...) {
5545         va_list ap;
5546         char **l;
5547         int n = 0, i, c, r;
5548
5549         /* Parses a number of words from a string, stripping any
5550          * quotes if necessary. */
5551
5552         assert(p);
5553
5554         /* Count how many words are expected */
5555         va_start(ap, flags);
5556         for (;;) {
5557                 if (!va_arg(ap, char **))
5558                         break;
5559                 n++;
5560         }
5561         va_end(ap);
5562
5563         if (n <= 0)
5564                 return 0;
5565
5566         /* Read all words into a temporary array */
5567         l = newa0(char*, n);
5568         for (c = 0; c < n; c++) {
5569
5570                 r = unquote_first_word(p, &l[c], flags);
5571                 if (r < 0) {
5572                         int j;
5573
5574                         for (j = 0; j < c; j++)
5575                                 free(l[j]);
5576
5577                         return r;
5578                 }
5579
5580                 if (r == 0)
5581                         break;
5582         }
5583
5584         /* If we managed to parse all words, return them in the passed
5585          * in parameters */
5586         va_start(ap, flags);
5587         for (i = 0; i < n; i++) {
5588                 char **v;
5589
5590                 v = va_arg(ap, char **);
5591                 assert(v);
5592
5593                 *v = l[i];
5594         }
5595         va_end(ap);
5596
5597         return c;
5598 }
5599
5600 int free_and_strdup(char **p, const char *s) {
5601         char *t;
5602
5603         assert(p);
5604
5605         /* Replaces a string pointer with an strdup()ed new string,
5606          * possibly freeing the old one. */
5607
5608         if (streq_ptr(*p, s))
5609                 return 0;
5610
5611         if (s) {
5612                 t = strdup(s);
5613                 if (!t)
5614                         return -ENOMEM;
5615         } else
5616                 t = NULL;
5617
5618         free(*p);
5619         *p = t;
5620
5621         return 1;
5622 }
5623
5624 int ptsname_malloc(int fd, char **ret) {
5625         size_t l = 100;
5626
5627         assert(fd >= 0);
5628         assert(ret);
5629
5630         for (;;) {
5631                 char *c;
5632
5633                 c = new(char, l);
5634                 if (!c)
5635                         return -ENOMEM;
5636
5637                 if (ptsname_r(fd, c, l) == 0) {
5638                         *ret = c;
5639                         return 0;
5640                 }
5641                 if (errno != ERANGE) {
5642                         free(c);
5643                         return -errno;
5644                 }
5645
5646                 free(c);
5647                 l *= 2;
5648         }
5649 }
5650
5651 int openpt_in_namespace(pid_t pid, int flags) {
5652         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, rootfd = -1;
5653         _cleanup_close_pair_ int pair[2] = { -1, -1 };
5654         union {
5655                 struct cmsghdr cmsghdr;
5656                 uint8_t buf[CMSG_SPACE(sizeof(int))];
5657         } control = {};
5658         struct msghdr mh = {
5659                 .msg_control = &control,
5660                 .msg_controllen = sizeof(control),
5661         };
5662         struct cmsghdr *cmsg;
5663         siginfo_t si;
5664         pid_t child;
5665         int r;
5666
5667         assert(pid > 0);
5668
5669         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &rootfd);
5670         if (r < 0)
5671                 return r;
5672
5673         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
5674                 return -errno;
5675
5676         child = fork();
5677         if (child < 0)
5678                 return -errno;
5679
5680         if (child == 0) {
5681                 int master;
5682
5683                 pair[0] = safe_close(pair[0]);
5684
5685                 r = namespace_enter(pidnsfd, mntnsfd, -1, rootfd);
5686                 if (r < 0)
5687                         _exit(EXIT_FAILURE);
5688
5689                 master = posix_openpt(flags);
5690                 if (master < 0)
5691                         _exit(EXIT_FAILURE);
5692
5693                 cmsg = CMSG_FIRSTHDR(&mh);
5694                 cmsg->cmsg_level = SOL_SOCKET;
5695                 cmsg->cmsg_type = SCM_RIGHTS;
5696                 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
5697                 memcpy(CMSG_DATA(cmsg), &master, sizeof(int));
5698
5699                 mh.msg_controllen = cmsg->cmsg_len;
5700
5701                 if (sendmsg(pair[1], &mh, MSG_NOSIGNAL) < 0)
5702                         _exit(EXIT_FAILURE);
5703
5704                 _exit(EXIT_SUCCESS);
5705         }
5706
5707         pair[1] = safe_close(pair[1]);
5708
5709         r = wait_for_terminate(child, &si);
5710         if (r < 0)
5711                 return r;
5712         if (si.si_code != CLD_EXITED || si.si_status != EXIT_SUCCESS)
5713                 return -EIO;
5714
5715         if (recvmsg(pair[0], &mh, MSG_NOSIGNAL|MSG_CMSG_CLOEXEC) < 0)
5716                 return -errno;
5717
5718         for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg))
5719                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
5720                         int *fds;
5721                         unsigned n_fds;
5722
5723                         fds = (int*) CMSG_DATA(cmsg);
5724                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
5725
5726                         if (n_fds != 1) {
5727                                 close_many(fds, n_fds);
5728                                 return -EIO;
5729                         }
5730
5731                         return fds[0];
5732                 }
5733
5734         return -EIO;
5735 }
5736
5737 ssize_t fgetxattrat_fake(int dirfd, const char *filename, const char *attribute, void *value, size_t size, int flags) {
5738         _cleanup_close_ int fd = -1;
5739         ssize_t l;
5740
5741         /* The kernel doesn't have a fgetxattrat() command, hence let's emulate one */
5742
5743         fd = openat(dirfd, filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOATIME|(flags & AT_SYMLINK_NOFOLLOW ? O_NOFOLLOW : 0));
5744         if (fd < 0)
5745                 return -errno;
5746
5747         l = fgetxattr(fd, attribute, value, size);
5748         if (l < 0)
5749                 return -errno;
5750
5751         return l;
5752 }
5753
5754 static int parse_crtime(le64_t le, usec_t *usec) {
5755         uint64_t u;
5756
5757         assert(usec);
5758
5759         u = le64toh(le);
5760         if (u == 0 || u == (uint64_t) -1)
5761                 return -EIO;
5762
5763         *usec = (usec_t) u;
5764         return 0;
5765 }
5766
5767 int fd_getcrtime(int fd, usec_t *usec) {
5768         le64_t le;
5769         ssize_t n;
5770
5771         assert(fd >= 0);
5772         assert(usec);
5773
5774         /* Until Linux gets a real concept of birthtime/creation time,
5775          * let's fake one with xattrs */
5776
5777         n = fgetxattr(fd, "user.crtime_usec", &le, sizeof(le));
5778         if (n < 0)
5779                 return -errno;
5780         if (n != sizeof(le))
5781                 return -EIO;
5782
5783         return parse_crtime(le, usec);
5784 }
5785
5786 int fd_getcrtime_at(int dirfd, const char *name, usec_t *usec, int flags) {
5787         le64_t le;
5788         ssize_t n;
5789
5790         n = fgetxattrat_fake(dirfd, name, "user.crtime_usec", &le, sizeof(le), flags);
5791         if (n < 0)
5792                 return -errno;
5793         if (n != sizeof(le))
5794                 return -EIO;
5795
5796         return parse_crtime(le, usec);
5797 }
5798
5799 int path_getcrtime(const char *p, usec_t *usec) {
5800         le64_t le;
5801         ssize_t n;
5802
5803         assert(p);
5804         assert(usec);
5805
5806         n = getxattr(p, "user.crtime_usec", &le, sizeof(le));
5807         if (n < 0)
5808                 return -errno;
5809         if (n != sizeof(le))
5810                 return -EIO;
5811
5812         return parse_crtime(le, usec);
5813 }
5814
5815 int fd_setcrtime(int fd, usec_t usec) {
5816         le64_t le;
5817
5818         assert(fd >= 0);
5819
5820         if (usec <= 0)
5821                 usec = now(CLOCK_REALTIME);
5822
5823         le = htole64((uint64_t) usec);
5824         if (fsetxattr(fd, "user.crtime_usec", &le, sizeof(le), 0) < 0)
5825                 return -errno;
5826
5827         return 0;
5828 }
5829
5830 int chattr_fd(int fd, unsigned value, unsigned mask) {
5831         unsigned old_attr, new_attr;
5832         struct stat st;
5833
5834         assert(fd >= 0);
5835
5836         if (fstat(fd, &st) < 0)
5837                 return -errno;
5838
5839         /* Explicitly check whether this is a regular file or
5840          * directory. If it is anything else (such as a device node or
5841          * fifo), then the ioctl will not hit the file systems but
5842          * possibly drivers, where the ioctl might have different
5843          * effects. Notably, DRM is using the same ioctl() number. */
5844
5845         if (!S_ISDIR(st.st_mode) && !S_ISREG(st.st_mode))
5846                 return -ENOTTY;
5847
5848         if (mask == 0)
5849                 return 0;
5850
5851         if (ioctl(fd, FS_IOC_GETFLAGS, &old_attr) < 0)
5852                 return -errno;
5853
5854         new_attr = (old_attr & ~mask) | (value & mask);
5855         if (new_attr == old_attr)
5856                 return 0;
5857
5858         if (ioctl(fd, FS_IOC_SETFLAGS, &new_attr) < 0)
5859                 return -errno;
5860
5861         return 1;
5862 }
5863
5864 int chattr_path(const char *p, unsigned value, unsigned mask) {
5865         _cleanup_close_ int fd = -1;
5866
5867         assert(p);
5868
5869         if (mask == 0)
5870                 return 0;
5871
5872         fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
5873         if (fd < 0)
5874                 return -errno;
5875
5876         return chattr_fd(fd, value, mask);
5877 }
5878
5879 int read_attr_fd(int fd, unsigned *ret) {
5880         struct stat st;
5881
5882         assert(fd >= 0);
5883
5884         if (fstat(fd, &st) < 0)
5885                 return -errno;
5886
5887         if (!S_ISDIR(st.st_mode) && !S_ISREG(st.st_mode))
5888                 return -ENOTTY;
5889
5890         if (ioctl(fd, FS_IOC_GETFLAGS, ret) < 0)
5891                 return -errno;
5892
5893         return 0;
5894 }
5895
5896 int read_attr_path(const char *p, unsigned *ret) {
5897         _cleanup_close_ int fd = -1;
5898
5899         assert(p);
5900         assert(ret);
5901
5902         fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
5903         if (fd < 0)
5904                 return -errno;
5905
5906         return read_attr_fd(fd, ret);
5907 }
5908
5909 static size_t nul_length(const uint8_t *p, size_t sz) {
5910         size_t n = 0;
5911
5912         while (sz > 0) {
5913                 if (*p != 0)
5914                         break;
5915
5916                 n++;
5917                 p++;
5918                 sz--;
5919         }
5920
5921         return n;
5922 }
5923
5924 ssize_t sparse_write(int fd, const void *p, size_t sz, size_t run_length) {
5925         const uint8_t *q, *w, *e;
5926         ssize_t l;
5927
5928         q = w = p;
5929         e = q + sz;
5930         while (q < e) {
5931                 size_t n;
5932
5933                 n = nul_length(q, e - q);
5934
5935                 /* If there are more than the specified run length of
5936                  * NUL bytes, or if this is the beginning or the end
5937                  * of the buffer, then seek instead of write */
5938                 if ((n > run_length) ||
5939                     (n > 0 && q == p) ||
5940                     (n > 0 && q + n >= e)) {
5941                         if (q > w) {
5942                                 l = write(fd, w, q - w);
5943                                 if (l < 0)
5944                                         return -errno;
5945                                 if (l != q -w)
5946                                         return -EIO;
5947                         }
5948
5949                         if (lseek(fd, n, SEEK_CUR) == (off_t) -1)
5950                                 return -errno;
5951
5952                         q += n;
5953                         w = q;
5954                 } else if (n > 0)
5955                         q += n;
5956                 else
5957                         q ++;
5958         }
5959
5960         if (q > w) {
5961                 l = write(fd, w, q - w);
5962                 if (l < 0)
5963                         return -errno;
5964                 if (l != q - w)
5965                         return -EIO;
5966         }
5967
5968         return q - (const uint8_t*) p;
5969 }
5970
5971 void sigkill_wait(pid_t *pid) {
5972         if (!pid)
5973                 return;
5974         if (*pid <= 1)
5975                 return;
5976
5977         if (kill(*pid, SIGKILL) > 0)
5978                 (void) wait_for_terminate(*pid, NULL);
5979 }
5980
5981 int syslog_parse_priority(const char **p, int *priority, bool with_facility) {
5982         int a = 0, b = 0, c = 0;
5983         int k;
5984
5985         assert(p);
5986         assert(*p);
5987         assert(priority);
5988
5989         if ((*p)[0] != '<')
5990                 return 0;
5991
5992         if (!strchr(*p, '>'))
5993                 return 0;
5994
5995         if ((*p)[2] == '>') {
5996                 c = undecchar((*p)[1]);
5997                 k = 3;
5998         } else if ((*p)[3] == '>') {
5999                 b = undecchar((*p)[1]);
6000                 c = undecchar((*p)[2]);
6001                 k = 4;
6002         } else if ((*p)[4] == '>') {
6003                 a = undecchar((*p)[1]);
6004                 b = undecchar((*p)[2]);
6005                 c = undecchar((*p)[3]);
6006                 k = 5;
6007         } else
6008                 return 0;
6009
6010         if (a < 0 || b < 0 || c < 0 ||
6011             (!with_facility && (a || b || c > 7)))
6012                 return 0;
6013
6014         if (with_facility)
6015                 *priority = a*100 + b*10 + c;
6016         else
6017                 *priority = (*priority & LOG_FACMASK) | c;
6018
6019         *p += k;
6020         return 1;
6021 }
6022
6023 ssize_t string_table_lookup(const char * const *table, size_t len, const char *key) {
6024         size_t i;
6025
6026         if (!key)
6027                 return -1;
6028
6029         for (i = 0; i < len; ++i)
6030                 if (streq_ptr(table[i], key))
6031                         return (ssize_t)i;
6032
6033         return -1;
6034 }
6035
6036 void cmsg_close_all(struct msghdr *mh) {
6037         struct cmsghdr *cmsg;
6038
6039         assert(mh);
6040
6041         for (cmsg = CMSG_FIRSTHDR(mh); cmsg; cmsg = CMSG_NXTHDR(mh, cmsg))
6042                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS)
6043                         close_many((int*) CMSG_DATA(cmsg), (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int));
6044 }
6045
6046 int rename_noreplace(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
6047         struct stat buf;
6048         int ret;
6049
6050         ret = renameat2(olddirfd, oldpath, newdirfd, newpath, RENAME_NOREPLACE);
6051         if (ret >= 0)
6052                 return 0;
6053
6054         /* Even though renameat2() exists since Linux 3.15, btrfs added
6055          * support for it later. If it is not implemented, fallback to another
6056          * method. */
6057         if (errno != EINVAL)
6058                 return -errno;
6059
6060         /* The link()/unlink() fallback does not work on directories. But
6061          * renameat() without RENAME_NOREPLACE gives the same semantics on
6062          * directories, except when newpath is an *empty* directory. This is
6063          * good enough. */
6064         ret = fstatat(olddirfd, oldpath, &buf, AT_SYMLINK_NOFOLLOW);
6065         if (ret >= 0 && S_ISDIR(buf.st_mode)) {
6066                 ret = renameat(olddirfd, oldpath, newdirfd, newpath);
6067                 return ret >= 0 ? 0 : -errno;
6068         }
6069
6070         /* If it is not a directory, use the link()/unlink() fallback. */
6071         ret = linkat(olddirfd, oldpath, newdirfd, newpath, 0);
6072         if (ret < 0)
6073                 return -errno;
6074
6075         ret = unlinkat(olddirfd, oldpath, 0);
6076         if (ret < 0) {
6077                 /* backup errno before the following unlinkat() alters it */
6078                 ret = errno;
6079                 (void) unlinkat(newdirfd, newpath, 0);
6080                 errno = ret;
6081                 return -errno;
6082         }
6083
6084         return 0;
6085 }
6086
6087 char *shell_maybe_quote(const char *s) {
6088         const char *p;
6089         char *r, *t;
6090
6091         assert(s);
6092
6093         /* Encloses a string in double quotes if necessary to make it
6094          * OK as shell string. */
6095
6096         for (p = s; *p; p++)
6097                 if (*p <= ' ' ||
6098                     *p >= 127 ||
6099                     strchr(SHELL_NEED_QUOTES, *p))
6100                         break;
6101
6102         if (!*p)
6103                 return strdup(s);
6104
6105         r = new(char, 1+strlen(s)*2+1+1);
6106         if (!r)
6107                 return NULL;
6108
6109         t = r;
6110         *(t++) = '"';
6111         t = mempcpy(t, s, p - s);
6112
6113         for (; *p; p++) {
6114
6115                 if (strchr(SHELL_NEED_ESCAPE, *p))
6116                         *(t++) = '\\';
6117
6118                 *(t++) = *p;
6119         }
6120
6121         *(t++)= '"';
6122         *t = 0;
6123
6124         return r;
6125 }
6126
6127 int parse_mode(const char *s, mode_t *ret) {
6128         char *x;
6129         long l;
6130
6131         assert(s);
6132         assert(ret);
6133
6134         errno = 0;
6135         l = strtol(s, &x, 8);
6136         if (errno != 0)
6137                 return -errno;
6138
6139         if (!x || x == s || *x)
6140                 return -EINVAL;
6141         if (l < 0 || l  > 07777)
6142                 return -ERANGE;
6143
6144         *ret = (mode_t) l;
6145         return 0;
6146 }
6147
6148 int mount_move_root(const char *path) {
6149         assert(path);
6150
6151         if (chdir(path) < 0)
6152                 return -errno;
6153
6154         if (mount(path, "/", NULL, MS_MOVE, NULL) < 0)
6155                 return -errno;
6156
6157         if (chroot(".") < 0)
6158                 return -errno;
6159
6160         if (chdir("/") < 0)
6161                 return -errno;
6162
6163         return 0;
6164 }