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. */