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 <assert.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <signal.h>
  28 #include <stdio.h>
  29 #include <syslog.h>
  30 #include <sched.h>
  31 #include <sys/resource.h>
  32 #include <linux/sched.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <dirent.h>
  37 #include <sys/ioctl.h>
  38 #include <linux/vt.h>
  39 #include <linux/tiocl.h>
  40 #include <termios.h>
  41 #include <stdarg.h>
  42 #include <sys/inotify.h>
  43 #include <sys/poll.h>
  44 #include <libgen.h>
  45 #include <ctype.h>
  46 #include <sys/prctl.h>
  47 #include <sys/utsname.h>
  48 #include <pwd.h>
  49 #include <netinet/ip.h>
  50 #include <linux/kd.h>
  51 #include <dlfcn.h>
  52 #include <sys/wait.h>
  53 #include <sys/capability.h>
  54 #include <sys/time.h>
  55 #include <glob.h>
  56 #include <grp.h>
  57 #include <sys/mman.h>
  58
  59 #include "macro.h"
  60 #include "util.h"
  61 #include "ioprio.h"
  62 #include "missing.h"
  63 #include "log.h"
  64 #include "strv.h"
  65 #include "label.h"
  66 #include "path-util.h"
  67 #include "exit-status.h"
  68 #include "hashmap.h"
  69
  70 int saved_argc = 0;
  71 char **saved_argv = NULL;
  72
  73 size_t page_size(void) {
  74         static __thread size_t pgsz = 0;
  75         long r;
  76
  77         if (_likely_(pgsz > 0))
  78                 return pgsz;
  79
  80         assert_se((r = sysconf(_SC_PAGESIZE)) > 0);
  81
  82         pgsz = (size_t) r;
  83
  84         return pgsz;
  85 }
  86
  87 bool streq_ptr(const char *a, const char *b) {
  88
  89         /* Like streq(), but tries to make sense of NULL pointers */
  90
  91         if (a && b)
  92                 return streq(a, b);
  93
  94         if (!a && !b)
  95                 return true;
  96
  97         return false;
  98 }
  99
 100 usec_t now(clockid_t clock_id) {
 101         struct timespec ts;
 102
 103         assert_se(clock_gettime(clock_id, &ts) == 0);
 104
 105         return timespec_load(&ts);
 106 }
 107
 108 dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
 109         assert(ts);
 110
 111         ts->realtime = now(CLOCK_REALTIME);
 112         ts->monotonic = now(CLOCK_MONOTONIC);
 113
 114         return ts;
 115 }
 116
 117 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
 118         int64_t delta;
 119         assert(ts);
 120
 121         ts->realtime = u;
 122
 123         if (u == 0)
 124                 ts->monotonic = 0;
 125         else {
 126                 delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
 127
 128                 ts->monotonic = now(CLOCK_MONOTONIC);
 129
 130                 if ((int64_t) ts->monotonic > delta)
 131                         ts->monotonic -= delta;
 132                 else
 133                         ts->monotonic = 0;
 134         }
 135
 136         return ts;
 137 }
 138
 139 usec_t timespec_load(const struct timespec *ts) {
 140         assert(ts);
 141
 142         return
 143                 (usec_t) ts->tv_sec * USEC_PER_SEC +
 144                 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
 145 }
 146
 147 struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
 148         assert(ts);
 149
 150         ts->tv_sec = (time_t) (u / USEC_PER_SEC);
 151         ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
 152
 153         return ts;
 154 }
 155
 156 usec_t timeval_load(const struct timeval *tv) {
 157         assert(tv);
 158
 159         return
 160                 (usec_t) tv->tv_sec * USEC_PER_SEC +
 161                 (usec_t) tv->tv_usec;
 162 }
 163
 164 struct timeval *timeval_store(struct timeval *tv, usec_t u) {
 165         assert(tv);
 166
 167         tv->tv_sec = (time_t) (u / USEC_PER_SEC);
 168         tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
 169
 170         return tv;
 171 }
 172
 173 bool endswith(const char *s, const char *postfix) {
 174         size_t sl, pl;
 175
 176         assert(s);
 177         assert(postfix);
 178
 179         sl = strlen(s);
 180         pl = strlen(postfix);
 181
 182         if (pl == 0)
 183                 return true;
 184
 185         if (sl < pl)
 186                 return false;
 187
 188         return memcmp(s + sl - pl, postfix, pl) == 0;
 189 }
 190
 191 bool startswith(const char *s, const char *prefix) {
 192         size_t sl, pl;
 193
 194         assert(s);
 195         assert(prefix);
 196
 197         sl = strlen(s);
 198         pl = strlen(prefix);
 199
 200         if (pl == 0)
 201                 return true;
 202
 203         if (sl < pl)
 204                 return false;
 205
 206         return memcmp(s, prefix, pl) == 0;
 207 }
 208
 209 bool startswith_no_case(const char *s, const char *prefix) {
 210         size_t sl, pl;
 211         unsigned i;
 212
 213         assert(s);
 214         assert(prefix);
 215
 216         sl = strlen(s);
 217         pl = strlen(prefix);
 218
 219         if (pl == 0)
 220                 return true;
 221
 222         if (sl < pl)
 223                 return false;
 224
 225         for(i = 0; i < pl; ++i) {
 226                 if (tolower(s[i]) != tolower(prefix[i]))
 227                         return false;
 228         }
 229
 230         return true;
 231 }
 232
 233 bool first_word(const char *s, const char *word) {
 234         size_t sl, wl;
 235
 236         assert(s);
 237         assert(word);
 238
 239         sl = strlen(s);
 240         wl = strlen(word);
 241
 242         if (sl < wl)
 243                 return false;
 244
 245         if (wl == 0)
 246                 return true;
 247
 248         if (memcmp(s, word, wl) != 0)
 249                 return false;
 250
 251         return s[wl] == 0 ||
 252                 strchr(WHITESPACE, s[wl]);
 253 }
 254
 255 int close_nointr(int fd) {
 256         assert(fd >= 0);
 257
 258         for (;;) {
 259                 int r;
 260
 261                 r = close(fd);
 262                 if (r >= 0)
 263                         return r;
 264
 265                 if (errno != EINTR)
 266                         return -errno;
 267         }
 268 }
 269
 270 void close_nointr_nofail(int fd) {
 271         int saved_errno = errno;
 272
 273         /* like close_nointr() but cannot fail, and guarantees errno
 274          * is unchanged */
 275
 276         assert_se(close_nointr(fd) == 0);
 277
 278         errno = saved_errno;
 279 }
 280
 281 void close_many(const int fds[], unsigned n_fd) {
 282         unsigned i;
 283
 284         for (i = 0; i < n_fd; i++)
 285                 close_nointr_nofail(fds[i]);
 286 }
 287
 288 int parse_boolean(const char *v) {
 289         assert(v);
 290
 291         if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
 292                 return 1;
 293         else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
 294                 return 0;
 295
 296         return -EINVAL;
 297 }
 298
 299 int parse_pid(const char *s, pid_t* ret_pid) {
 300         unsigned long ul = 0;
 301         pid_t pid;
 302         int r;
 303
 304         assert(s);
 305         assert(ret_pid);
 306
 307         if ((r = safe_atolu(s, &ul)) < 0)
 308                 return r;
 309
 310         pid = (pid_t) ul;
 311
 312         if ((unsigned long) pid != ul)
 313                 return -ERANGE;
 314
 315         if (pid <= 0)
 316                 return -ERANGE;
 317
 318         *ret_pid = pid;
 319         return 0;
 320 }
 321
 322 int parse_uid(const char *s, uid_t* ret_uid) {
 323         unsigned long ul = 0;
 324         uid_t uid;
 325         int r;
 326
 327         assert(s);
 328         assert(ret_uid);
 329
 330         if ((r = safe_atolu(s, &ul)) < 0)
 331                 return r;
 332
 333         uid = (uid_t) ul;
 334
 335         if ((unsigned long) uid != ul)
 336                 return -ERANGE;
 337
 338         *ret_uid = uid;
 339         return 0;
 340 }
 341
 342 int safe_atou(const char *s, unsigned *ret_u) {
 343         char *x = NULL;
 344         unsigned long l;
 345
 346         assert(s);
 347         assert(ret_u);
 348
 349         errno = 0;
 350         l = strtoul(s, &x, 0);
 351
 352         if (!x || *x || errno)
 353                 return errno ? -errno : -EINVAL;
 354
 355         if ((unsigned long) (unsigned) l != l)
 356                 return -ERANGE;
 357
 358         *ret_u = (unsigned) l;
 359         return 0;
 360 }
 361
 362 int safe_atoi(const char *s, int *ret_i) {
 363         char *x = NULL;
 364         long l;
 365
 366         assert(s);
 367         assert(ret_i);
 368
 369         errno = 0;
 370         l = strtol(s, &x, 0);
 371
 372         if (!x || *x || errno)
 373                 return errno ? -errno : -EINVAL;
 374
 375         if ((long) (int) l != l)
 376                 return -ERANGE;
 377
 378         *ret_i = (int) l;
 379         return 0;
 380 }
 381
 382 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 383         char *x = NULL;
 384         unsigned long long l;
 385
 386         assert(s);
 387         assert(ret_llu);
 388
 389         errno = 0;
 390         l = strtoull(s, &x, 0);
 391
 392         if (!x || *x || errno)
 393                 return errno ? -errno : -EINVAL;
 394
 395         *ret_llu = l;
 396         return 0;
 397 }
 398
 399 int safe_atolli(const char *s, long long int *ret_lli) {
 400         char *x = NULL;
 401         long long l;
 402
 403         assert(s);
 404         assert(ret_lli);
 405
 406         errno = 0;
 407         l = strtoll(s, &x, 0);
 408
 409         if (!x || *x || errno)
 410                 return errno ? -errno : -EINVAL;
 411
 412         *ret_lli = l;
 413         return 0;
 414 }
 415
 416 /* Split a string into words. */
 417 char *split(const char *c, size_t *l, const char *separator, char **state) {
 418         char *current;
 419
 420         current = *state ? *state : (char*) c;
 421
 422         if (!*current || *c == 0)
 423                 return NULL;
 424
 425         current += strspn(current, separator);
 426         *l = strcspn(current, separator);
 427         *state = current+*l;
 428
 429         return (char*) current;
 430 }
 431
 432 /* Split a string into words, but consider strings enclosed in '' and
 433  * "" as words even if they include spaces. */
 434 char *split_quoted(const char *c, size_t *l, char **state) {
 435         char *current, *e;
 436         bool escaped = false;
 437
 438         current = *state ? *state : (char*) c;
 439
 440         if (!*current || *c == 0)
 441                 return NULL;
 442
 443         current += strspn(current, WHITESPACE);
 444
 445         if (*current == '\'') {
 446                 current ++;
 447
 448                 for (e = current; *e; e++) {
 449                         if (escaped)
 450                                 escaped = false;
 451                         else if (*e == '\\')
 452                                 escaped = true;
 453                         else if (*e == '\'')
 454                                 break;
 455                 }
 456
 457                 *l = e-current;
 458                 *state = *e == 0 ? e : e+1;
 459         } else if (*current == '\"') {
 460                 current ++;
 461
 462                 for (e = current; *e; e++) {
 463                         if (escaped)
 464                                 escaped = false;
 465                         else if (*e == '\\')
 466                                 escaped = true;
 467                         else if (*e == '\"')
 468                                 break;
 469                 }
 470
 471                 *l = e-current;
 472                 *state = *e == 0 ? e : e+1;
 473         } else {
 474                 for (e = current; *e; e++) {
 475                         if (escaped)
 476                                 escaped = false;
 477                         else if (*e == '\\')
 478                                 escaped = true;
 479                         else if (strchr(WHITESPACE, *e))
 480                                 break;
 481                 }
 482                 *l = e-current;
 483                 *state = e;
 484         }
 485
 486         return (char*) current;
 487 }
 488
 489 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
 490         int r;
 491         FILE *f;
 492         char fn[PATH_MAX], line[LINE_MAX], *p;
 493         long unsigned ppid;
 494
 495         assert(pid > 0);
 496         assert(_ppid);
 497
 498         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
 499         char_array_0(fn);
 500
 501         if (!(f = fopen(fn, "re")))
 502                 return -errno;
 503
 504         if (!(fgets(line, sizeof(line), f))) {
 505                 r = feof(f) ? -EIO : -errno;
 506                 fclose(f);
 507                 return r;
 508         }
 509
 510         fclose(f);
 511
 512         /* Let's skip the pid and comm fields. The latter is enclosed
 513          * in () but does not escape any () in its value, so let's
 514          * skip over it manually */
 515
 516         if (!(p = strrchr(line, ')')))
 517                 return -EIO;
 518
 519         p++;
 520
 521         if (sscanf(p, " "
 522                    "%*c "  /* state */
 523                    "%lu ", /* ppid */
 524                    &ppid) != 1)
 525                 return -EIO;
 526
 527         if ((long unsigned) (pid_t) ppid != ppid)
 528                 return -ERANGE;
 529
 530         *_ppid = (pid_t) ppid;
 531
 532         return 0;
 533 }
 534
 535 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
 536         int r;
 537         FILE *f;
 538         char fn[PATH_MAX], line[LINE_MAX], *p;
 539
 540         assert(pid > 0);
 541         assert(st);
 542
 543         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
 544         char_array_0(fn);
 545
 546         if (!(f = fopen(fn, "re")))
 547                 return -errno;
 548
 549         if (!(fgets(line, sizeof(line), f))) {
 550                 r = feof(f) ? -EIO : -errno;
 551                 fclose(f);
 552                 return r;
 553         }
 554
 555         fclose(f);
 556
 557         /* Let's skip the pid and comm fields. The latter is enclosed
 558          * in () but does not escape any () in its value, so let's
 559          * skip over it manually */
 560
 561         if (!(p = strrchr(line, ')')))
 562                 return -EIO;
 563
 564         p++;
 565
 566         if (sscanf(p, " "
 567                    "%*c "  /* state */
 568                    "%*d "  /* ppid */
 569                    "%*d "  /* pgrp */
 570                    "%*d "  /* session */
 571                    "%*d "  /* tty_nr */
 572                    "%*d "  /* tpgid */
 573                    "%*u "  /* flags */
 574                    "%*u "  /* minflt */
 575                    "%*u "  /* cminflt */
 576                    "%*u "  /* majflt */
 577                    "%*u "  /* cmajflt */
 578                    "%*u "  /* utime */
 579                    "%*u "  /* stime */
 580                    "%*d "  /* cutime */
 581                    "%*d "  /* cstime */
 582                    "%*d "  /* priority */
 583                    "%*d "  /* nice */
 584                    "%*d "  /* num_threads */
 585                    "%*d "  /* itrealvalue */
 586                    "%llu "  /* starttime */,
 587                    st) != 1)
 588                 return -EIO;
 589
 590         return 0;
 591 }
 592
 593 int write_one_line_file(const char *fn, const char *line) {
 594         FILE *f;
 595         int r;
 596
 597         assert(fn);
 598         assert(line);
 599
 600         f = fopen(fn, "we");
 601         if (!f)
 602                 return -errno;
 603
 604         errno = 0;
 605         if (fputs(line, f) < 0) {
 606                 r = -errno;
 607                 goto finish;
 608         }
 609
 610         if (!endswith(line, "\n"))
 611                 fputc('\n', f);
 612
 613         fflush(f);
 614
 615         if (ferror(f)) {
 616                 if (errno != 0)
 617                         r = -errno;
 618                 else
 619                         r = -EIO;
 620         } else
 621                 r = 0;
 622
 623 finish:
 624         fclose(f);
 625         return r;
 626 }
 627
 628 int fchmod_umask(int fd, mode_t m) {
 629         mode_t u;
 630         int r;
 631
 632         u = umask(0777);
 633         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 634         umask(u);
 635
 636         return r;
 637 }
 638
 639 int write_one_line_file_atomic(const char *fn, const char *line) {
 640         FILE *f;
 641         int r;
 642         char *p;
 643
 644         assert(fn);
 645         assert(line);
 646
 647         r = fopen_temporary(fn, &f, &p);
 648         if (r < 0)
 649                 return r;
 650
 651         fchmod_umask(fileno(f), 0644);
 652
 653         errno = 0;
 654         if (fputs(line, f) < 0) {
 655                 r = -errno;
 656                 goto finish;
 657         }
 658
 659         if (!endswith(line, "\n"))
 660                 fputc('\n', f);
 661
 662         fflush(f);
 663
 664         if (ferror(f)) {
 665                 if (errno != 0)
 666                         r = -errno;
 667                 else
 668                         r = -EIO;
 669         } else {
 670                 if (rename(p, fn) < 0)
 671                         r = -errno;
 672                 else
 673                         r = 0;
 674         }
 675
 676 finish:
 677         if (r < 0)
 678                 unlink(p);
 679
 680         fclose(f);
 681         free(p);
 682
 683         return r;
 684 }
 685
 686 int read_one_line_file(const char *fn, char **line) {
 687         FILE *f;
 688         int r;
 689         char t[LINE_MAX], *c;
 690
 691         assert(fn);
 692         assert(line);
 693
 694         f = fopen(fn, "re");
 695         if (!f)
 696                 return -errno;
 697
 698         if (!fgets(t, sizeof(t), f)) {
 699
 700                 if (ferror(f)) {
 701                         r = -errno;
 702                         goto finish;
 703                 }
 704
 705                 t[0] = 0;
 706         }
 707
 708         c = strdup(t);
 709         if (!c) {
 710                 r = -ENOMEM;
 711                 goto finish;
 712         }
 713
 714         truncate_nl(c);
 715
 716         *line = c;
 717         r = 0;
 718
 719 finish:
 720         fclose(f);
 721         return r;
 722 }
 723
 724 int read_full_file(const char *fn, char **contents, size_t *size) {
 725         FILE *f;
 726         int r;
 727         size_t n, l;
 728         char *buf = NULL;
 729         struct stat st;
 730
 731         if (!(f = fopen(fn, "re")))
 732                 return -errno;
 733
 734         if (fstat(fileno(f), &st) < 0) {
 735                 r = -errno;
 736                 goto finish;
 737         }
 738
 739         /* Safety check */
 740         if (st.st_size > 4*1024*1024) {
 741                 r = -E2BIG;
 742                 goto finish;
 743         }
 744
 745         n = st.st_size > 0 ? st.st_size : LINE_MAX;
 746         l = 0;
 747
 748         for (;;) {
 749                 char *t;
 750                 size_t k;
 751
 752                 if (!(t = realloc(buf, n+1))) {
 753                         r = -ENOMEM;
 754                         goto finish;
 755                 }
 756
 757                 buf = t;
 758                 k = fread(buf + l, 1, n - l, f);
 759
 760                 if (k <= 0) {
 761                         if (ferror(f)) {
 762                                 r = -errno;
 763                                 goto finish;
 764                         }
 765
 766                         break;
 767                 }
 768
 769                 l += k;
 770                 n *= 2;
 771
 772                 /* Safety check */
 773                 if (n > 4*1024*1024) {
 774                         r = -E2BIG;
 775                         goto finish;
 776                 }
 777         }
 778
 779         buf[l] = 0;
 780         *contents = buf;
 781         buf = NULL;
 782
 783         if (size)
 784                 *size = l;
 785
 786         r = 0;
 787
 788 finish:
 789         fclose(f);
 790         free(buf);
 791
 792         return r;
 793 }
 794
 795 int parse_env_file(
 796                 const char *fname,
 797                 const char *separator, ...) {
 798
 799         int r = 0;
 800         char *contents = NULL, *p;
 801
 802         assert(fname);
 803         assert(separator);
 804
 805         if ((r = read_full_file(fname, &contents, NULL)) < 0)
 806                 return r;
 807
 808         p = contents;
 809         for (;;) {
 810                 const char *key = NULL;
 811
 812                 p += strspn(p, separator);
 813                 p += strspn(p, WHITESPACE);
 814
 815                 if (!*p)
 816                         break;
 817
 818                 if (!strchr(COMMENTS, *p)) {
 819                         va_list ap;
 820                         char **value;
 821
 822                         va_start(ap, separator);
 823                         while ((key = va_arg(ap, char *))) {
 824                                 size_t n;
 825                                 char *v;
 826
 827                                 value = va_arg(ap, char **);
 828
 829                                 n = strlen(key);
 830                                 if (strncmp(p, key, n) != 0 ||
 831                                     p[n] != '=')
 832                                         continue;
 833
 834                                 p += n + 1;
 835                                 n = strcspn(p, separator);
 836
 837                                 if (n >= 2 &&
 838                                     strchr(QUOTES, p[0]) &&
 839                                     p[n-1] == p[0])
 840                                         v = strndup(p+1, n-2);
 841                                 else
 842                                         v = strndup(p, n);
 843
 844                                 if (!v) {
 845                                         r = -ENOMEM;
 846                                         va_end(ap);
 847                                         goto fail;
 848                                 }
 849
 850                                 if (v[0] == '\0') {
 851                                         /* return empty value strings as NULL */
 852                                         free(v);
 853                                         v = NULL;
 854                                 }
 855
 856                                 free(*value);
 857                                 *value = v;
 858
 859                                 p += n;
 860
 861                                 r ++;
 862                                 break;
 863                         }
 864                         va_end(ap);
 865                 }
 866
 867                 if (!key)
 868                         p += strcspn(p, separator);
 869         }
 870
 871 fail:
 872         free(contents);
 873         return r;
 874 }
 875
 876 int load_env_file(
 877                 const char *fname,
 878                 char ***rl) {
 879
 880         FILE *f;
 881         char **m = NULL;
 882         int r;
 883
 884         assert(fname);
 885         assert(rl);
 886
 887         if (!(f = fopen(fname, "re")))
 888                 return -errno;
 889
 890         while (!feof(f)) {
 891                 char l[LINE_MAX], *p, *u;
 892                 char **t;
 893
 894                 if (!fgets(l, sizeof(l), f)) {
 895                         if (feof(f))
 896                                 break;
 897
 898                         r = -errno;
 899                         goto finish;
 900                 }
 901
 902                 p = strstrip(l);
 903
 904                 if (!*p)
 905                         continue;
 906
 907                 if (strchr(COMMENTS, *p))
 908                         continue;
 909
 910                 if (!(u = normalize_env_assignment(p))) {
 911                         log_error("Out of memory");
 912                         r = -ENOMEM;
 913                         goto finish;
 914                 }
 915
 916                 t = strv_append(m, u);
 917                 free(u);
 918
 919                 if (!t) {
 920                         log_error("Out of memory");
 921                         r = -ENOMEM;
 922                         goto finish;
 923                 }
 924
 925                 strv_free(m);
 926                 m = t;
 927         }
 928
 929         r = 0;
 930
 931         *rl = m;
 932         m = NULL;
 933
 934 finish:
 935         if (f)
 936                 fclose(f);
 937
 938         strv_free(m);
 939
 940         return r;
 941 }
 942
 943 int write_env_file(const char *fname, char **l) {
 944         char **i, *p;
 945         FILE *f;
 946         int r;
 947
 948         r = fopen_temporary(fname, &f, &p);
 949         if (r < 0)
 950                 return r;
 951
 952         fchmod_umask(fileno(f), 0644);
 953
 954         errno = 0;
 955         STRV_FOREACH(i, l) {
 956                 fputs(*i, f);
 957                 fputc('\n', f);
 958         }
 959
 960         fflush(f);
 961
 962         if (ferror(f)) {
 963                 if (errno != 0)
 964                         r = -errno;
 965                 else
 966                         r = -EIO;
 967         } else {
 968                 if (rename(p, fname) < 0)
 969                         r = -errno;
 970                 else
 971                         r = 0;
 972         }
 973
 974         if (r < 0)
 975                 unlink(p);
 976
 977         fclose(f);
 978         free(p);
 979
 980         return r;
 981 }
 982
 983 char *truncate_nl(char *s) {
 984         assert(s);
 985
 986         s[strcspn(s, NEWLINE)] = 0;
 987         return s;
 988 }
 989
 990 int get_process_comm(pid_t pid, char **name) {
 991         int r;
 992
 993         assert(name);
 994
 995         if (pid == 0)
 996                 r = read_one_line_file("/proc/self/comm", name);
 997         else {
 998                 char *p;
 999                 if (asprintf(&p, "/proc/%lu/comm", (unsigned long) pid) < 0)
1000                         return -ENOMEM;
1001
1002                 r = read_one_line_file(p, name);
1003                 free(p);
1004         }
1005
1006         return r;
1007 }
1008
1009 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
1010         char *r, *k;
1011         int c;
1012         bool space = false;
1013         size_t left;
1014         FILE *f;
1015
1016         assert(max_length > 0);
1017         assert(line);
1018
1019         if (pid == 0)
1020                 f = fopen("/proc/self/cmdline", "re");
1021         else {
1022                 char *p;
1023                 if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
1024                         return -ENOMEM;
1025
1026                 f = fopen(p, "re");
1027                 free(p);
1028         }
1029
1030         if (!f)
1031                 return -errno;
1032
1033         r = new(char, max_length);
1034         if (!r) {
1035                 fclose(f);
1036                 return -ENOMEM;
1037         }
1038
1039         k = r;
1040         left = max_length;
1041         while ((c = getc(f)) != EOF) {
1042
1043                 if (isprint(c)) {
1044                         if (space) {
1045                                 if (left <= 4)
1046                                         break;
1047
1048                                 *(k++) = ' ';
1049                                 left--;
1050                                 space = false;
1051                         }
1052
1053                         if (left <= 4)
1054                                 break;
1055
1056                         *(k++) = (char) c;
1057                         left--;
1058                 }  else
1059                         space = true;
1060         }
1061
1062         if (left <= 4) {
1063                 size_t n = MIN(left-1, 3U);
1064                 memcpy(k, "...", n);
1065                 k[n] = 0;
1066         } else
1067                 *k = 0;
1068
1069         fclose(f);
1070
1071         /* Kernel threads have no argv[] */
1072         if (r[0] == 0) {
1073                 char *t;
1074                 int h;
1075
1076                 free(r);
1077
1078                 if (!comm_fallback)
1079                         return -ENOENT;
1080
1081                 h = get_process_comm(pid, &t);
1082                 if (h < 0)
1083                         return h;
1084
1085                 r = join("[", t, "]", NULL);
1086                 free(t);
1087
1088                 if (!r)
1089                         return -ENOMEM;
1090         }
1091
1092         *line = r;
1093         return 0;
1094 }
1095
1096 int is_kernel_thread(pid_t pid) {
1097         char *p;
1098         size_t count;
1099         char c;
1100         bool eof;
1101         FILE *f;
1102
1103         if (pid == 0)
1104                 return 0;
1105
1106         if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
1107                 return -ENOMEM;
1108
1109         f = fopen(p, "re");
1110         free(p);
1111
1112         if (!f)
1113                 return -errno;
1114
1115         count = fread(&c, 1, 1, f);
1116         eof = feof(f);
1117         fclose(f);
1118
1119         /* Kernel threads have an empty cmdline */
1120
1121         if (count <= 0)
1122                 return eof ? 1 : -errno;
1123
1124         return 0;
1125 }
1126
1127 int get_process_exe(pid_t pid, char **name) {
1128         int r;
1129
1130         assert(name);
1131
1132         if (pid == 0)
1133                 r = readlink_malloc("/proc/self/exe", name);
1134         else {
1135                 char *p;
1136                 if (asprintf(&p, "/proc/%lu/exe", (unsigned long) pid) < 0)
1137                         return -ENOMEM;
1138
1139                 r = readlink_malloc(p, name);
1140                 free(p);
1141         }
1142
1143         return r;
1144 }
1145
1146 int get_process_uid(pid_t pid, uid_t *uid) {
1147         char *p;
1148         FILE *f;
1149         int r;
1150
1151         assert(uid);
1152
1153         if (pid == 0)
1154                 return getuid();
1155
1156         if (asprintf(&p, "/proc/%lu/status", (unsigned long) pid) < 0)
1157                 return -ENOMEM;
1158
1159         f = fopen(p, "re");
1160         free(p);
1161
1162         if (!f)
1163                 return -errno;
1164
1165         while (!feof(f)) {
1166                 char line[LINE_MAX], *l;
1167
1168                 if (!fgets(line, sizeof(line), f)) {
1169                         if (feof(f))
1170                                 break;
1171
1172                         r = -errno;
1173                         goto finish;
1174                 }
1175
1176                 l = strstrip(line);
1177
1178                 if (startswith(l, "Uid:")) {
1179                         l += 4;
1180                         l += strspn(l, WHITESPACE);
1181
1182                         l[strcspn(l, WHITESPACE)] = 0;
1183
1184                         r = parse_uid(l, uid);
1185                         goto finish;
1186                 }
1187         }
1188
1189         r = -EIO;
1190
1191 finish:
1192         fclose(f);
1193
1194         return r;
1195 }
1196
1197 char *strnappend(const char *s, const char *suffix, size_t b) {
1198         size_t a;
1199         char *r;
1200
1201         if (!s && !suffix)
1202                 return strdup("");
1203
1204         if (!s)
1205                 return strndup(suffix, b);
1206
1207         if (!suffix)
1208                 return strdup(s);
1209
1210         assert(s);
1211         assert(suffix);
1212
1213         a = strlen(s);
1214
1215         if (!(r = new(char, a+b+1)))
1216                 return NULL;
1217
1218         memcpy(r, s, a);
1219         memcpy(r+a, suffix, b);
1220         r[a+b] = 0;
1221
1222         return r;
1223 }
1224
1225 char *strappend(const char *s, const char *suffix) {
1226         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
1227 }
1228
1229 int readlink_malloc(const char *p, char **r) {
1230         size_t l = 100;
1231
1232         assert(p);
1233         assert(r);
1234
1235         for (;;) {
1236                 char *c;
1237                 ssize_t n;
1238
1239                 if (!(c = new(char, l)))
1240                         return -ENOMEM;
1241
1242                 if ((n = readlink(p, c, l-1)) < 0) {
1243                         int ret = -errno;
1244                         free(c);
1245                         return ret;
1246                 }
1247
1248                 if ((size_t) n < l-1) {
1249                         c[n] = 0;
1250                         *r = c;
1251                         return 0;
1252                 }
1253
1254                 free(c);
1255                 l *= 2;
1256         }
1257 }
1258
1259 int readlink_and_make_absolute(const char *p, char **r) {
1260         char *target, *k;
1261         int j;
1262
1263         assert(p);
1264         assert(r);
1265
1266         if ((j = readlink_malloc(p, &target)) < 0)
1267                 return j;
1268
1269         k = file_in_same_dir(p, target);
1270         free(target);
1271
1272         if (!k)
1273                 return -ENOMEM;
1274
1275         *r = k;
1276         return 0;
1277 }
1278
1279 int readlink_and_canonicalize(const char *p, char **r) {
1280         char *t, *s;
1281         int j;
1282
1283         assert(p);
1284         assert(r);
1285
1286         j = readlink_and_make_absolute(p, &t);
1287         if (j < 0)
1288                 return j;
1289
1290         s = canonicalize_file_name(t);
1291         if (s) {
1292                 free(t);
1293                 *r = s;
1294         } else
1295                 *r = t;
1296
1297         path_kill_slashes(*r);
1298
1299         return 0;
1300 }
1301
1302 int reset_all_signal_handlers(void) {
1303         int sig;
1304
1305         for (sig = 1; sig < _NSIG; sig++) {
1306                 struct sigaction sa;
1307
1308                 if (sig == SIGKILL || sig == SIGSTOP)
1309                         continue;
1310
1311                 zero(sa);
1312                 sa.sa_handler = SIG_DFL;
1313                 sa.sa_flags = SA_RESTART;
1314
1315                 /* On Linux the first two RT signals are reserved by
1316                  * glibc, and sigaction() will return EINVAL for them. */
1317                 if ((sigaction(sig, &sa, NULL) < 0))
1318                         if (errno != EINVAL)
1319                                 return -errno;
1320         }
1321
1322         return 0;
1323 }
1324
1325 char *strstrip(char *s) {
1326         char *e;
1327
1328         /* Drops trailing whitespace. Modifies the string in
1329          * place. Returns pointer to first non-space character */
1330
1331         s += strspn(s, WHITESPACE);
1332
1333         for (e = strchr(s, 0); e > s; e --)
1334                 if (!strchr(WHITESPACE, e[-1]))
1335                         break;
1336
1337         *e = 0;
1338
1339         return s;
1340 }
1341
1342 char *delete_chars(char *s, const char *bad) {
1343         char *f, *t;
1344
1345         /* Drops all whitespace, regardless where in the string */
1346
1347         for (f = s, t = s; *f; f++) {
1348                 if (strchr(bad, *f))
1349                         continue;
1350
1351                 *(t++) = *f;
1352         }
1353
1354         *t = 0;
1355
1356         return s;
1357 }
1358
1359 bool in_charset(const char *s, const char* charset) {
1360         const char *i;
1361
1362         assert(s);
1363         assert(charset);
1364
1365         for (i = s; *i; i++)
1366                 if (!strchr(charset, *i))
1367                         return false;
1368
1369         return true;
1370 }
1371
1372 char *file_in_same_dir(const char *path, const char *filename) {
1373         char *e, *r;
1374         size_t k;
1375
1376         assert(path);
1377         assert(filename);
1378
1379         /* This removes the last component of path and appends
1380          * filename, unless the latter is absolute anyway or the
1381          * former isn't */
1382
1383         if (path_is_absolute(filename))
1384                 return strdup(filename);
1385
1386         if (!(e = strrchr(path, '/')))
1387                 return strdup(filename);
1388
1389         k = strlen(filename);
1390         if (!(r = new(char, e-path+1+k+1)))
1391                 return NULL;
1392
1393         memcpy(r, path, e-path+1);
1394         memcpy(r+(e-path)+1, filename, k+1);
1395
1396         return r;
1397 }
1398
1399 int rmdir_parents(const char *path, const char *stop) {
1400         size_t l;
1401         int r = 0;
1402
1403         assert(path);
1404         assert(stop);
1405
1406         l = strlen(path);
1407
1408         /* Skip trailing slashes */
1409         while (l > 0 && path[l-1] == '/')
1410                 l--;
1411
1412         while (l > 0) {
1413                 char *t;
1414
1415                 /* Skip last component */
1416                 while (l > 0 && path[l-1] != '/')
1417                         l--;
1418
1419                 /* Skip trailing slashes */
1420                 while (l > 0 && path[l-1] == '/')
1421                         l--;
1422
1423                 if (l <= 0)
1424                         break;
1425
1426                 if (!(t = strndup(path, l)))
1427                         return -ENOMEM;
1428
1429                 if (path_startswith(stop, t)) {
1430                         free(t);
1431                         return 0;
1432                 }
1433
1434                 r = rmdir(t);
1435                 free(t);
1436
1437                 if (r < 0)
1438                         if (errno != ENOENT)
1439                                 return -errno;
1440         }
1441
1442         return 0;
1443 }
1444
1445
1446 char hexchar(int x) {
1447         static const char table[16] = "0123456789abcdef";
1448
1449         return table[x & 15];
1450 }
1451
1452 int unhexchar(char c) {
1453
1454         if (c >= '0' && c <= '9')
1455                 return c - '0';
1456
1457         if (c >= 'a' && c <= 'f')
1458                 return c - 'a' + 10;
1459
1460         if (c >= 'A' && c <= 'F')
1461                 return c - 'A' + 10;
1462
1463         return -1;
1464 }
1465
1466 char octchar(int x) {
1467         return '0' + (x & 7);
1468 }
1469
1470 int unoctchar(char c) {
1471
1472         if (c >= '0' && c <= '7')
1473                 return c - '0';
1474
1475         return -1;
1476 }
1477
1478 char decchar(int x) {
1479         return '0' + (x % 10);
1480 }
1481
1482 int undecchar(char c) {
1483
1484         if (c >= '0' && c <= '9')
1485                 return c - '0';
1486
1487         return -1;
1488 }
1489
1490 char *cescape(const char *s) {
1491         char *r, *t;
1492         const char *f;
1493
1494         assert(s);
1495
1496         /* Does C style string escaping. */
1497
1498         r = new(char, strlen(s)*4 + 1);
1499         if (!r)
1500                 return NULL;
1501
1502         for (f = s, t = r; *f; f++)
1503
1504                 switch (*f) {
1505
1506                 case '\a':
1507                         *(t++) = '\\';
1508                         *(t++) = 'a';
1509                         break;
1510                 case '\b':
1511                         *(t++) = '\\';
1512                         *(t++) = 'b';
1513                         break;
1514                 case '\f':
1515                         *(t++) = '\\';
1516                         *(t++) = 'f';
1517                         break;
1518                 case '\n':
1519                         *(t++) = '\\';
1520                         *(t++) = 'n';
1521                         break;
1522                 case '\r':
1523                         *(t++) = '\\';
1524                         *(t++) = 'r';
1525                         break;
1526                 case '\t':
1527                         *(t++) = '\\';
1528                         *(t++) = 't';
1529                         break;
1530                 case '\v':
1531                         *(t++) = '\\';
1532                         *(t++) = 'v';
1533                         break;
1534                 case '\\':
1535                         *(t++) = '\\';
1536                         *(t++) = '\\';
1537                         break;
1538                 case '"':
1539                         *(t++) = '\\';
1540                         *(t++) = '"';
1541                         break;
1542                 case '\'':
1543                         *(t++) = '\\';
1544                         *(t++) = '\'';
1545                         break;
1546
1547                 default:
1548                         /* For special chars we prefer octal over
1549                          * hexadecimal encoding, simply because glib's
1550                          * g_strescape() does the same */
1551                         if ((*f < ' ') || (*f >= 127)) {
1552                                 *(t++) = '\\';
1553                                 *(t++) = octchar((unsigned char) *f >> 6);
1554                                 *(t++) = octchar((unsigned char) *f >> 3);
1555                                 *(t++) = octchar((unsigned char) *f);
1556                         } else
1557                                 *(t++) = *f;
1558                         break;
1559                 }
1560
1561         *t = 0;
1562
1563         return r;
1564 }
1565
1566 char *cunescape_length(const char *s, size_t length) {
1567         char *r, *t;
1568         const char *f;
1569
1570         assert(s);
1571
1572         /* Undoes C style string escaping */
1573
1574         r = new(char, length+1);
1575         if (!r)
1576                 return r;
1577
1578         for (f = s, t = r; f < s + length; f++) {
1579
1580                 if (*f != '\\') {
1581                         *(t++) = *f;
1582                         continue;
1583                 }
1584
1585                 f++;
1586
1587                 switch (*f) {
1588
1589                 case 'a':
1590                         *(t++) = '\a';
1591                         break;
1592                 case 'b':
1593                         *(t++) = '\b';
1594                         break;
1595                 case 'f':
1596                         *(t++) = '\f';
1597                         break;
1598                 case 'n':
1599                         *(t++) = '\n';
1600                         break;
1601                 case 'r':
1602                         *(t++) = '\r';
1603                         break;
1604                 case 't':
1605                         *(t++) = '\t';
1606                         break;
1607                 case 'v':
1608                         *(t++) = '\v';
1609                         break;
1610                 case '\\':
1611                         *(t++) = '\\';
1612                         break;
1613                 case '"':
1614                         *(t++) = '"';
1615                         break;
1616                 case '\'':
1617                         *(t++) = '\'';
1618                         break;
1619
1620                 case 's':
1621                         /* This is an extension of the XDG syntax files */
1622                         *(t++) = ' ';
1623                         break;
1624
1625                 case 'x': {
1626                         /* hexadecimal encoding */
1627                         int a, b;
1628
1629                         a = unhexchar(f[1]);
1630                         b = unhexchar(f[2]);
1631
1632                         if (a < 0 || b < 0) {
1633                                 /* Invalid escape code, let's take it literal then */
1634                                 *(t++) = '\\';
1635                                 *(t++) = 'x';
1636                         } else {
1637                                 *(t++) = (char) ((a << 4) | b);
1638                                 f += 2;
1639                         }
1640
1641                         break;
1642                 }
1643
1644                 case '0':
1645                 case '1':
1646                 case '2':
1647                 case '3':
1648                 case '4':
1649                 case '5':
1650                 case '6':
1651                 case '7': {
1652                         /* octal encoding */
1653                         int a, b, c;
1654
1655                         a = unoctchar(f[0]);
1656                         b = unoctchar(f[1]);
1657                         c = unoctchar(f[2]);
1658
1659                         if (a < 0 || b < 0 || c < 0) {
1660                                 /* Invalid escape code, let's take it literal then */
1661                                 *(t++) = '\\';
1662                                 *(t++) = f[0];
1663                         } else {
1664                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1665                                 f += 2;
1666                         }
1667
1668                         break;
1669                 }
1670
1671                 case 0:
1672                         /* premature end of string.*/
1673                         *(t++) = '\\';
1674                         goto finish;
1675
1676                 default:
1677                         /* Invalid escape code, let's take it literal then */
1678                         *(t++) = '\\';
1679                         *(t++) = *f;
1680                         break;
1681                 }
1682         }
1683
1684 finish:
1685         *t = 0;
1686         return r;
1687 }
1688
1689 char *cunescape(const char *s) {
1690         return cunescape_length(s, strlen(s));
1691 }
1692
1693 char *xescape(const char *s, const char *bad) {
1694         char *r, *t;
1695         const char *f;
1696
1697         /* Escapes all chars in bad, in addition to \ and all special
1698          * chars, in \xFF style escaping. May be reversed with
1699          * cunescape. */
1700
1701         if (!(r = new(char, strlen(s)*4+1)))
1702                 return NULL;
1703
1704         for (f = s, t = r; *f; f++) {
1705
1706                 if ((*f < ' ') || (*f >= 127) ||
1707                     (*f == '\\') || strchr(bad, *f)) {
1708                         *(t++) = '\\';
1709                         *(t++) = 'x';
1710                         *(t++) = hexchar(*f >> 4);
1711                         *(t++) = hexchar(*f);
1712                 } else
1713                         *(t++) = *f;
1714         }
1715
1716         *t = 0;
1717
1718         return r;
1719 }
1720
1721 char *bus_path_escape(const char *s) {
1722         char *r, *t;
1723         const char *f;
1724
1725         assert(s);
1726
1727         /* Escapes all chars that D-Bus' object path cannot deal
1728          * with. Can be reverse with bus_path_unescape() */
1729
1730         if (!(r = new(char, strlen(s)*3+1)))
1731                 return NULL;
1732
1733         for (f = s, t = r; *f; f++) {
1734
1735                 if (!(*f >= 'A' && *f <= 'Z') &&
1736                     !(*f >= 'a' && *f <= 'z') &&
1737                     !(*f >= '0' && *f <= '9')) {
1738                         *(t++) = '_';
1739                         *(t++) = hexchar(*f >> 4);
1740                         *(t++) = hexchar(*f);
1741                 } else
1742                         *(t++) = *f;
1743         }
1744
1745         *t = 0;
1746
1747         return r;
1748 }
1749
1750 char *bus_path_unescape(const char *f) {
1751         char *r, *t;
1752
1753         assert(f);
1754
1755         if (!(r = strdup(f)))
1756                 return NULL;
1757
1758         for (t = r; *f; f++) {
1759
1760                 if (*f == '_') {
1761                         int a, b;
1762
1763                         if ((a = unhexchar(f[1])) < 0 ||
1764                             (b = unhexchar(f[2])) < 0) {
1765                                 /* Invalid escape code, let's take it literal then */
1766                                 *(t++) = '_';
1767                         } else {
1768                                 *(t++) = (char) ((a << 4) | b);
1769                                 f += 2;
1770                         }
1771                 } else
1772                         *(t++) = *f;
1773         }
1774
1775         *t = 0;
1776
1777         return r;
1778 }
1779
1780 char *ascii_strlower(char *t) {
1781         char *p;
1782
1783         assert(t);
1784
1785         for (p = t; *p; p++)
1786                 if (*p >= 'A' && *p <= 'Z')
1787                         *p = *p - 'A' + 'a';
1788
1789         return t;
1790 }
1791
1792 bool ignore_file(const char *filename) {
1793         assert(filename);
1794
1795         return
1796                 filename[0] == '.' ||
1797                 streq(filename, "lost+found") ||
1798                 streq(filename, "aquota.user") ||
1799                 streq(filename, "aquota.group") ||
1800                 endswith(filename, "~") ||
1801                 endswith(filename, ".rpmnew") ||
1802                 endswith(filename, ".rpmsave") ||
1803                 endswith(filename, ".rpmorig") ||
1804                 endswith(filename, ".dpkg-old") ||
1805                 endswith(filename, ".dpkg-new") ||
1806                 endswith(filename, ".swp");
1807 }
1808
1809 int fd_nonblock(int fd, bool nonblock) {
1810         int flags;
1811
1812         assert(fd >= 0);
1813
1814         if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1815                 return -errno;
1816
1817         if (nonblock)
1818                 flags |= O_NONBLOCK;
1819         else
1820                 flags &= ~O_NONBLOCK;
1821
1822         if (fcntl(fd, F_SETFL, flags) < 0)
1823                 return -errno;
1824
1825         return 0;
1826 }
1827
1828 int fd_cloexec(int fd, bool cloexec) {
1829         int flags;
1830
1831         assert(fd >= 0);
1832
1833         if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1834                 return -errno;
1835
1836         if (cloexec)
1837                 flags |= FD_CLOEXEC;
1838         else
1839                 flags &= ~FD_CLOEXEC;
1840
1841         if (fcntl(fd, F_SETFD, flags) < 0)
1842                 return -errno;
1843
1844         return 0;
1845 }
1846
1847 static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1848         unsigned i;
1849
1850         assert(n_fdset == 0 || fdset);
1851
1852         for (i = 0; i < n_fdset; i++)
1853                 if (fdset[i] == fd)
1854                         return true;
1855
1856         return false;
1857 }
1858
1859 int close_all_fds(const int except[], unsigned n_except) {
1860         DIR *d;
1861         struct dirent *de;
1862         int r = 0;
1863
1864         assert(n_except == 0 || except);
1865
1866         d = opendir("/proc/self/fd");
1867         if (!d) {
1868                 int fd;
1869                 struct rlimit rl;
1870
1871                 /* When /proc isn't available (for example in chroots)
1872                  * the fallback is brute forcing through the fd
1873                  * table */
1874
1875                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1876                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1877
1878                         if (fd_in_set(fd, except, n_except))
1879                                 continue;
1880
1881                         if (close_nointr(fd) < 0)
1882                                 if (errno != EBADF && r == 0)
1883                                         r = -errno;
1884                 }
1885
1886                 return r;
1887         }
1888
1889         while ((de = readdir(d))) {
1890                 int fd = -1;
1891
1892                 if (ignore_file(de->d_name))
1893                         continue;
1894
1895                 if (safe_atoi(de->d_name, &fd) < 0)
1896                         /* Let's better ignore this, just in case */
1897                         continue;
1898
1899                 if (fd < 3)
1900                         continue;
1901
1902                 if (fd == dirfd(d))
1903                         continue;
1904
1905                 if (fd_in_set(fd, except, n_except))
1906                         continue;
1907
1908                 if (close_nointr(fd) < 0) {
1909                         /* Valgrind has its own FD and doesn't want to have it closed */
1910                         if (errno != EBADF && r == 0)
1911                                 r = -errno;
1912                 }
1913         }
1914
1915         closedir(d);
1916         return r;
1917 }
1918
1919 bool chars_intersect(const char *a, const char *b) {
1920         const char *p;
1921
1922         /* Returns true if any of the chars in a are in b. */
1923         for (p = a; *p; p++)
1924                 if (strchr(b, *p))
1925                         return true;
1926
1927         return false;
1928 }
1929
1930 char *format_timestamp(char *buf, size_t l, usec_t t) {
1931         struct tm tm;
1932         time_t sec;
1933
1934         assert(buf);
1935         assert(l > 0);
1936
1937         if (t <= 0)
1938                 return NULL;
1939
1940         sec = (time_t) (t / USEC_PER_SEC);
1941
1942         if (strftime(buf, l, "%a, %d %b %Y %H:%M:%S %z", localtime_r(&sec, &tm)) <= 0)
1943                 return NULL;
1944
1945         return buf;
1946 }
1947
1948 char *format_timestamp_pretty(char *buf, size_t l, usec_t t) {
1949         usec_t n, d;
1950
1951         n = now(CLOCK_REALTIME);
1952
1953         if (t <= 0 || t > n || t + USEC_PER_DAY*7 <= t)
1954                 return NULL;
1955
1956         d = n - t;
1957
1958         if (d >= USEC_PER_YEAR)
1959                 snprintf(buf, l, "%llu years and %llu months ago",
1960                          (unsigned long long) (d / USEC_PER_YEAR),
1961                          (unsigned long long) ((d % USEC_PER_YEAR) / USEC_PER_MONTH));
1962         else if (d >= USEC_PER_MONTH)
1963                 snprintf(buf, l, "%llu months and %llu days ago",
1964                          (unsigned long long) (d / USEC_PER_MONTH),
1965                          (unsigned long long) ((d % USEC_PER_MONTH) / USEC_PER_DAY));
1966         else if (d >= USEC_PER_WEEK)
1967                 snprintf(buf, l, "%llu weeks and %llu days ago",
1968                          (unsigned long long) (d / USEC_PER_WEEK),
1969                          (unsigned long long) ((d % USEC_PER_WEEK) / USEC_PER_DAY));
1970         else if (d >= 2*USEC_PER_DAY)
1971                 snprintf(buf, l, "%llu days ago", (unsigned long long) (d / USEC_PER_DAY));
1972         else if (d >= 25*USEC_PER_HOUR)
1973                 snprintf(buf, l, "1 day and %lluh ago",
1974                          (unsigned long long) ((d - USEC_PER_DAY) / USEC_PER_HOUR));
1975         else if (d >= 6*USEC_PER_HOUR)
1976                 snprintf(buf, l, "%lluh ago",
1977                          (unsigned long long) (d / USEC_PER_HOUR));
1978         else if (d >= USEC_PER_HOUR)
1979                 snprintf(buf, l, "%lluh %llumin ago",
1980                          (unsigned long long) (d / USEC_PER_HOUR),
1981                          (unsigned long long) ((d % USEC_PER_HOUR) / USEC_PER_MINUTE));
1982         else if (d >= 5*USEC_PER_MINUTE)
1983                 snprintf(buf, l, "%llumin ago",
1984                          (unsigned long long) (d / USEC_PER_MINUTE));
1985         else if (d >= USEC_PER_MINUTE)
1986                 snprintf(buf, l, "%llumin %llus ago",
1987                          (unsigned long long) (d / USEC_PER_MINUTE),
1988                          (unsigned long long) ((d % USEC_PER_MINUTE) / USEC_PER_SEC));
1989         else if (d >= USEC_PER_SEC)
1990                 snprintf(buf, l, "%llus ago",
1991                          (unsigned long long) (d / USEC_PER_SEC));
1992         else if (d >= USEC_PER_MSEC)
1993                 snprintf(buf, l, "%llums ago",
1994                          (unsigned long long) (d / USEC_PER_MSEC));
1995         else if (d > 0)
1996                 snprintf(buf, l, "%lluus ago",
1997                          (unsigned long long) d);
1998         else
1999                 snprintf(buf, l, "now");
2000
2001         buf[l-1] = 0;
2002         return buf;
2003 }
2004
2005 char *format_timespan(char *buf, size_t l, usec_t t) {
2006         static const struct {
2007                 const char *suffix;
2008                 usec_t usec;
2009         } table[] = {
2010                 { "w", USEC_PER_WEEK },
2011                 { "d", USEC_PER_DAY },
2012                 { "h", USEC_PER_HOUR },
2013                 { "min", USEC_PER_MINUTE },
2014                 { "s", USEC_PER_SEC },
2015                 { "ms", USEC_PER_MSEC },
2016                 { "us", 1 },
2017         };
2018
2019         unsigned i;
2020         char *p = buf;
2021
2022         assert(buf);
2023         assert(l > 0);
2024
2025         if (t == (usec_t) -1)
2026                 return NULL;
2027
2028         if (t == 0) {
2029                 snprintf(p, l, "0");
2030                 p[l-1] = 0;
2031                 return p;
2032         }
2033
2034         /* The result of this function can be parsed with parse_usec */
2035
2036         for (i = 0; i < ELEMENTSOF(table); i++) {
2037                 int k;
2038                 size_t n;
2039
2040                 if (t < table[i].usec)
2041                         continue;
2042
2043                 if (l <= 1)
2044                         break;
2045
2046                 k = snprintf(p, l, "%s%llu%s", p > buf ? " " : "", (unsigned long long) (t / table[i].usec), table[i].suffix);
2047                 n = MIN((size_t) k, l);
2048
2049                 l -= n;
2050                 p += n;
2051
2052                 t %= table[i].usec;
2053         }
2054
2055         *p = 0;
2056
2057         return buf;
2058 }
2059
2060 bool fstype_is_network(const char *fstype) {
2061         static const char * const table[] = {
2062                 "cifs",
2063                 "smbfs",
2064                 "ncpfs",
2065                 "nfs",
2066                 "nfs4",
2067                 "gfs",
2068                 "gfs2"
2069         };
2070
2071         unsigned i;
2072
2073         for (i = 0; i < ELEMENTSOF(table); i++)
2074                 if (streq(table[i], fstype))
2075                         return true;
2076
2077         return false;
2078 }
2079
2080 int chvt(int vt) {
2081         int fd, r = 0;
2082
2083         if ((fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC)) < 0)
2084                 return -errno;
2085
2086         if (vt < 0) {
2087                 int tiocl[2] = {
2088                         TIOCL_GETKMSGREDIRECT,
2089                         0
2090                 };
2091
2092                 if (ioctl(fd, TIOCLINUX, tiocl) < 0) {
2093                         r = -errno;
2094                         goto fail;
2095                 }
2096
2097                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
2098         }
2099
2100         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
2101                 r = -errno;
2102
2103 fail:
2104         close_nointr_nofail(fd);
2105         return r;
2106 }
2107
2108 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
2109         struct termios old_termios, new_termios;
2110         char c;
2111         char line[LINE_MAX];
2112
2113         assert(f);
2114         assert(ret);
2115
2116         if (tcgetattr(fileno(f), &old_termios) >= 0) {
2117                 new_termios = old_termios;
2118
2119                 new_termios.c_lflag &= ~ICANON;
2120                 new_termios.c_cc[VMIN] = 1;
2121                 new_termios.c_cc[VTIME] = 0;
2122
2123                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
2124                         size_t k;
2125
2126                         if (t != (usec_t) -1) {
2127                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
2128                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
2129                                         return -ETIMEDOUT;
2130                                 }
2131                         }
2132
2133                         k = fread(&c, 1, 1, f);
2134
2135                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
2136
2137                         if (k <= 0)
2138                                 return -EIO;
2139
2140                         if (need_nl)
2141                                 *need_nl = c != '\n';
2142
2143                         *ret = c;
2144                         return 0;
2145                 }
2146         }
2147
2148         if (t != (usec_t) -1)
2149                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
2150                         return -ETIMEDOUT;
2151
2152         if (!fgets(line, sizeof(line), f))
2153                 return -EIO;
2154
2155         truncate_nl(line);
2156
2157         if (strlen(line) != 1)
2158                 return -EBADMSG;
2159
2160         if (need_nl)
2161                 *need_nl = false;
2162
2163         *ret = line[0];
2164         return 0;
2165 }
2166
2167 int ask(char *ret, const char *replies, const char *text, ...) {
2168         bool on_tty;
2169
2170         assert(ret);
2171         assert(replies);
2172         assert(text);
2173
2174         on_tty = isatty(STDOUT_FILENO);
2175
2176         for (;;) {
2177                 va_list ap;
2178                 char c;
2179                 int r;
2180                 bool need_nl = true;
2181
2182                 if (on_tty)
2183                         fputs(ANSI_HIGHLIGHT_ON, stdout);
2184
2185                 va_start(ap, text);
2186                 vprintf(text, ap);
2187                 va_end(ap);
2188
2189                 if (on_tty)
2190                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
2191
2192                 fflush(stdout);
2193
2194                 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
2195                 if (r < 0) {
2196
2197                         if (r == -EBADMSG) {
2198                                 puts("Bad input, please try again.");
2199                                 continue;
2200                         }
2201
2202                         putchar('\n');
2203                         return r;
2204                 }
2205
2206                 if (need_nl)
2207                         putchar('\n');
2208
2209                 if (strchr(replies, c)) {
2210                         *ret = c;
2211                         return 0;
2212                 }
2213
2214                 puts("Read unexpected character, please try again.");
2215         }
2216 }
2217
2218 int reset_terminal_fd(int fd, bool switch_to_text) {
2219         struct termios termios;
2220         int r = 0;
2221
2222         /* Set terminal to some sane defaults */
2223
2224         assert(fd >= 0);
2225
2226         /* We leave locked terminal attributes untouched, so that
2227          * Plymouth may set whatever it wants to set, and we don't
2228          * interfere with that. */
2229
2230         /* Disable exclusive mode, just in case */
2231         ioctl(fd, TIOCNXCL);
2232
2233         /* Switch to text mode */
2234         if (switch_to_text)
2235                 ioctl(fd, KDSETMODE, KD_TEXT);
2236
2237         /* Enable console unicode mode */
2238         ioctl(fd, KDSKBMODE, K_UNICODE);
2239
2240         if (tcgetattr(fd, &termios) < 0) {
2241                 r = -errno;
2242                 goto finish;
2243         }
2244
2245         /* We only reset the stuff that matters to the software. How
2246          * hardware is set up we don't touch assuming that somebody
2247          * else will do that for us */
2248
2249         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
2250         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
2251         termios.c_oflag |= ONLCR;
2252         termios.c_cflag |= CREAD;
2253         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
2254
2255         termios.c_cc[VINTR]    =   03;  /* ^C */
2256         termios.c_cc[VQUIT]    =  034;  /* ^\ */
2257         termios.c_cc[VERASE]   = 0177;
2258         termios.c_cc[VKILL]    =  025;  /* ^X */
2259         termios.c_cc[VEOF]     =   04;  /* ^D */
2260         termios.c_cc[VSTART]   =  021;  /* ^Q */
2261         termios.c_cc[VSTOP]    =  023;  /* ^S */
2262         termios.c_cc[VSUSP]    =  032;  /* ^Z */
2263         termios.c_cc[VLNEXT]   =  026;  /* ^V */
2264         termios.c_cc[VWERASE]  =  027;  /* ^W */
2265         termios.c_cc[VREPRINT] =  022;  /* ^R */
2266         termios.c_cc[VEOL]     =    0;
2267         termios.c_cc[VEOL2]    =    0;
2268
2269         termios.c_cc[VTIME]  = 0;
2270         termios.c_cc[VMIN]   = 1;
2271
2272         if (tcsetattr(fd, TCSANOW, &termios) < 0)
2273                 r = -errno;
2274
2275 finish:
2276         /* Just in case, flush all crap out */
2277         tcflush(fd, TCIOFLUSH);
2278
2279         return r;
2280 }
2281
2282 int reset_terminal(const char *name) {
2283         int fd, r;
2284
2285         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2286         if (fd < 0)
2287                 return fd;
2288
2289         r = reset_terminal_fd(fd, true);
2290         close_nointr_nofail(fd);
2291
2292         return r;
2293 }
2294
2295 int open_terminal(const char *name, int mode) {
2296         int fd, r;
2297         unsigned c = 0;
2298
2299         /*
2300          * If a TTY is in the process of being closed opening it might
2301          * cause EIO. This is horribly awful, but unlikely to be
2302          * changed in the kernel. Hence we work around this problem by
2303          * retrying a couple of times.
2304          *
2305          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
2306          */
2307
2308         for (;;) {
2309                 if ((fd = open(name, mode)) >= 0)
2310                         break;
2311
2312                 if (errno != EIO)
2313                         return -errno;
2314
2315                 if (c >= 20)
2316                         return -errno;
2317
2318                 usleep(50 * USEC_PER_MSEC);
2319                 c++;
2320         }
2321
2322         if (fd < 0)
2323                 return -errno;
2324
2325         if ((r = isatty(fd)) < 0) {
2326                 close_nointr_nofail(fd);
2327                 return -errno;
2328         }
2329
2330         if (!r) {
2331                 close_nointr_nofail(fd);
2332                 return -ENOTTY;
2333         }
2334
2335         return fd;
2336 }
2337
2338 int flush_fd(int fd) {
2339         struct pollfd pollfd;
2340
2341         zero(pollfd);
2342         pollfd.fd = fd;
2343         pollfd.events = POLLIN;
2344
2345         for (;;) {
2346                 char buf[LINE_MAX];
2347                 ssize_t l;
2348                 int r;
2349
2350                 if ((r = poll(&pollfd, 1, 0)) < 0) {
2351
2352                         if (errno == EINTR)
2353                                 continue;
2354
2355                         return -errno;
2356                 }
2357
2358                 if (r == 0)
2359                         return 0;
2360
2361                 if ((l = read(fd, buf, sizeof(buf))) < 0) {
2362
2363                         if (errno == EINTR)
2364                                 continue;
2365
2366                         if (errno == EAGAIN)
2367                                 return 0;
2368
2369                         return -errno;
2370                 }
2371
2372                 if (l <= 0)
2373                         return 0;
2374         }
2375 }
2376
2377 int acquire_terminal(const char *name, bool fail, bool force, bool ignore_tiocstty_eperm) {
2378         int fd = -1, notify = -1, r, wd = -1;
2379
2380         assert(name);
2381
2382         /* We use inotify to be notified when the tty is closed. We
2383          * create the watch before checking if we can actually acquire
2384          * it, so that we don't lose any event.
2385          *
2386          * Note: strictly speaking this actually watches for the
2387          * device being closed, it does *not* really watch whether a
2388          * tty loses its controlling process. However, unless some
2389          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2390          * its tty otherwise this will not become a problem. As long
2391          * as the administrator makes sure not configure any service
2392          * on the same tty as an untrusted user this should not be a
2393          * problem. (Which he probably should not do anyway.) */
2394
2395         if (!fail && !force) {
2396                 if ((notify = inotify_init1(IN_CLOEXEC)) < 0) {
2397                         r = -errno;
2398                         goto fail;
2399                 }
2400
2401                 if ((wd = inotify_add_watch(notify, name, IN_CLOSE)) < 0) {
2402                         r = -errno;
2403                         goto fail;
2404                 }
2405         }
2406
2407         for (;;) {
2408                 if (notify >= 0)
2409                         if ((r = flush_fd(notify)) < 0)
2410                                 goto fail;
2411
2412                 /* We pass here O_NOCTTY only so that we can check the return
2413                  * value TIOCSCTTY and have a reliable way to figure out if we
2414                  * successfully became the controlling process of the tty */
2415                 if ((fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC)) < 0)
2416                         return fd;
2417
2418                 /* First, try to get the tty */
2419                 r = ioctl(fd, TIOCSCTTY, force);
2420
2421                 /* Sometimes it makes sense to ignore TIOCSCTTY
2422                  * returning EPERM, i.e. when very likely we already
2423                  * are have this controlling terminal. */
2424                 if (r < 0 && errno == EPERM && ignore_tiocstty_eperm)
2425                         r = 0;
2426
2427                 if (r < 0 && (force || fail || errno != EPERM)) {
2428                         r = -errno;
2429                         goto fail;
2430                 }
2431
2432                 if (r >= 0)
2433                         break;
2434
2435                 assert(!fail);
2436                 assert(!force);
2437                 assert(notify >= 0);
2438
2439                 for (;;) {
2440                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
2441                         ssize_t l;
2442                         struct inotify_event *e;
2443
2444                         if ((l = read(notify, inotify_buffer, sizeof(inotify_buffer))) < 0) {
2445
2446                                 if (errno == EINTR)
2447                                         continue;
2448
2449                                 r = -errno;
2450                                 goto fail;
2451                         }
2452
2453                         e = (struct inotify_event*) inotify_buffer;
2454
2455                         while (l > 0) {
2456                                 size_t step;
2457
2458                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2459                                         r = -EIO;
2460                                         goto fail;
2461                                 }
2462
2463                                 step = sizeof(struct inotify_event) + e->len;
2464                                 assert(step <= (size_t) l);
2465
2466                                 e = (struct inotify_event*) ((uint8_t*) e + step);
2467                                 l -= step;
2468                         }
2469
2470                         break;
2471                 }
2472
2473                 /* We close the tty fd here since if the old session
2474                  * ended our handle will be dead. It's important that
2475                  * we do this after sleeping, so that we don't enter
2476                  * an endless loop. */
2477                 close_nointr_nofail(fd);
2478         }
2479
2480         if (notify >= 0)
2481                 close_nointr_nofail(notify);
2482
2483         r = reset_terminal_fd(fd, true);
2484         if (r < 0)
2485                 log_warning("Failed to reset terminal: %s", strerror(-r));
2486
2487         return fd;
2488
2489 fail:
2490         if (fd >= 0)
2491                 close_nointr_nofail(fd);
2492
2493         if (notify >= 0)
2494                 close_nointr_nofail(notify);
2495
2496         return r;
2497 }
2498
2499 int release_terminal(void) {
2500         int r = 0, fd;
2501         struct sigaction sa_old, sa_new;
2502
2503         if ((fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC)) < 0)
2504                 return -errno;
2505
2506         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2507          * by our own TIOCNOTTY */
2508
2509         zero(sa_new);
2510         sa_new.sa_handler = SIG_IGN;
2511         sa_new.sa_flags = SA_RESTART;
2512         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2513
2514         if (ioctl(fd, TIOCNOTTY) < 0)
2515                 r = -errno;
2516
2517         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2518
2519         close_nointr_nofail(fd);
2520         return r;
2521 }
2522
2523 int sigaction_many(const struct sigaction *sa, ...) {
2524         va_list ap;
2525         int r = 0, sig;
2526
2527         va_start(ap, sa);
2528         while ((sig = va_arg(ap, int)) > 0)
2529                 if (sigaction(sig, sa, NULL) < 0)
2530                         r = -errno;
2531         va_end(ap);
2532
2533         return r;
2534 }
2535
2536 int ignore_signals(int sig, ...) {
2537         struct sigaction sa;
2538         va_list ap;
2539         int r = 0;
2540
2541         zero(sa);
2542         sa.sa_handler = SIG_IGN;
2543         sa.sa_flags = SA_RESTART;
2544
2545         if (sigaction(sig, &sa, NULL) < 0)
2546                 r = -errno;
2547
2548         va_start(ap, sig);
2549         while ((sig = va_arg(ap, int)) > 0)
2550                 if (sigaction(sig, &sa, NULL) < 0)
2551                         r = -errno;
2552         va_end(ap);
2553
2554         return r;
2555 }
2556
2557 int default_signals(int sig, ...) {
2558         struct sigaction sa;
2559         va_list ap;
2560         int r = 0;
2561
2562         zero(sa);
2563         sa.sa_handler = SIG_DFL;
2564         sa.sa_flags = SA_RESTART;
2565
2566         if (sigaction(sig, &sa, NULL) < 0)
2567                 r = -errno;
2568
2569         va_start(ap, sig);
2570         while ((sig = va_arg(ap, int)) > 0)
2571                 if (sigaction(sig, &sa, NULL) < 0)
2572                         r = -errno;
2573         va_end(ap);
2574
2575         return r;
2576 }
2577
2578 int close_pipe(int p[]) {
2579         int a = 0, b = 0;
2580
2581         assert(p);
2582
2583         if (p[0] >= 0) {
2584                 a = close_nointr(p[0]);
2585                 p[0] = -1;
2586         }
2587
2588         if (p[1] >= 0) {
2589                 b = close_nointr(p[1]);
2590                 p[1] = -1;
2591         }
2592
2593         return a < 0 ? a : b;
2594 }
2595
2596 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2597         uint8_t *p;
2598         ssize_t n = 0;
2599
2600         assert(fd >= 0);
2601         assert(buf);
2602
2603         p = buf;
2604
2605         while (nbytes > 0) {
2606                 ssize_t k;
2607
2608                 if ((k = read(fd, p, nbytes)) <= 0) {
2609
2610                         if (k < 0 && errno == EINTR)
2611                                 continue;
2612
2613                         if (k < 0 && errno == EAGAIN && do_poll) {
2614                                 struct pollfd pollfd;
2615
2616                                 zero(pollfd);
2617                                 pollfd.fd = fd;
2618                                 pollfd.events = POLLIN;
2619
2620                                 if (poll(&pollfd, 1, -1) < 0) {
2621                                         if (errno == EINTR)
2622                                                 continue;
2623
2624                                         return n > 0 ? n : -errno;
2625                                 }
2626
2627                                 if (pollfd.revents != POLLIN)
2628                                         return n > 0 ? n : -EIO;
2629
2630                                 continue;
2631                         }
2632
2633                         return n > 0 ? n : (k < 0 ? -errno : 0);
2634                 }
2635
2636                 p += k;
2637                 nbytes -= k;
2638                 n += k;
2639         }
2640
2641         return n;
2642 }
2643
2644 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2645         const uint8_t *p;
2646         ssize_t n = 0;
2647
2648         assert(fd >= 0);
2649         assert(buf);
2650
2651         p = buf;
2652
2653         while (nbytes > 0) {
2654                 ssize_t k;
2655
2656                 k = write(fd, p, nbytes);
2657                 if (k <= 0) {
2658
2659                         if (k < 0 && errno == EINTR)
2660                                 continue;
2661
2662                         if (k < 0 && errno == EAGAIN && do_poll) {
2663                                 struct pollfd pollfd;
2664
2665                                 zero(pollfd);
2666                                 pollfd.fd = fd;
2667                                 pollfd.events = POLLOUT;
2668
2669                                 if (poll(&pollfd, 1, -1) < 0) {
2670                                         if (errno == EINTR)
2671                                                 continue;
2672
2673                                         return n > 0 ? n : -errno;
2674                                 }
2675
2676                                 if (pollfd.revents != POLLOUT)
2677                                         return n > 0 ? n : -EIO;
2678
2679                                 continue;
2680                         }
2681
2682                         return n > 0 ? n : (k < 0 ? -errno : 0);
2683                 }
2684
2685                 p += k;
2686                 nbytes -= k;
2687                 n += k;
2688         }
2689
2690         return n;
2691 }
2692
2693 int parse_usec(const char *t, usec_t *usec) {
2694         static const struct {
2695                 const char *suffix;
2696                 usec_t usec;
2697         } table[] = {
2698                 { "sec", USEC_PER_SEC },
2699                 { "s", USEC_PER_SEC },
2700                 { "min", USEC_PER_MINUTE },
2701                 { "hr", USEC_PER_HOUR },
2702                 { "h", USEC_PER_HOUR },
2703                 { "d", USEC_PER_DAY },
2704                 { "w", USEC_PER_WEEK },
2705                 { "msec", USEC_PER_MSEC },
2706                 { "ms", USEC_PER_MSEC },
2707                 { "m", USEC_PER_MINUTE },
2708                 { "usec", 1ULL },
2709                 { "us", 1ULL },
2710                 { "", USEC_PER_SEC }, /* default is sec */
2711         };
2712
2713         const char *p;
2714         usec_t r = 0;
2715
2716         assert(t);
2717         assert(usec);
2718
2719         p = t;
2720         do {
2721                 long long l;
2722                 char *e;
2723                 unsigned i;
2724
2725                 errno = 0;
2726                 l = strtoll(p, &e, 10);
2727
2728                 if (errno != 0)
2729                         return -errno;
2730
2731                 if (l < 0)
2732                         return -ERANGE;
2733
2734                 if (e == p)
2735                         return -EINVAL;
2736
2737                 e += strspn(e, WHITESPACE);
2738
2739                 for (i = 0; i < ELEMENTSOF(table); i++)
2740                         if (startswith(e, table[i].suffix)) {
2741                                 r += (usec_t) l * table[i].usec;
2742                                 p = e + strlen(table[i].suffix);
2743                                 break;
2744                         }
2745
2746                 if (i >= ELEMENTSOF(table))
2747                         return -EINVAL;
2748
2749         } while (*p != 0);
2750
2751         *usec = r;
2752
2753         return 0;
2754 }
2755
2756 int parse_nsec(const char *t, nsec_t *nsec) {
2757         static const struct {
2758                 const char *suffix;
2759                 nsec_t nsec;
2760         } table[] = {
2761                 { "sec", NSEC_PER_SEC },
2762                 { "s", NSEC_PER_SEC },
2763                 { "min", NSEC_PER_MINUTE },
2764                 { "hr", NSEC_PER_HOUR },
2765                 { "h", NSEC_PER_HOUR },
2766                 { "d", NSEC_PER_DAY },
2767                 { "w", NSEC_PER_WEEK },
2768                 { "msec", NSEC_PER_MSEC },
2769                 { "ms", NSEC_PER_MSEC },
2770                 { "m", NSEC_PER_MINUTE },
2771                 { "usec", NSEC_PER_USEC },
2772                 { "us", NSEC_PER_USEC },
2773                 { "nsec", 1ULL },
2774                 { "ns", 1ULL },
2775                 { "", 1ULL }, /* default is nsec */
2776         };
2777
2778         const char *p;
2779         nsec_t r = 0;
2780
2781         assert(t);
2782         assert(nsec);
2783
2784         p = t;
2785         do {
2786                 long long l;
2787                 char *e;
2788                 unsigned i;
2789
2790                 errno = 0;
2791                 l = strtoll(p, &e, 10);
2792
2793                 if (errno != 0)
2794                         return -errno;
2795
2796                 if (l < 0)
2797                         return -ERANGE;
2798
2799                 if (e == p)
2800                         return -EINVAL;
2801
2802                 e += strspn(e, WHITESPACE);
2803
2804                 for (i = 0; i < ELEMENTSOF(table); i++)
2805                         if (startswith(e, table[i].suffix)) {
2806                                 r += (nsec_t) l * table[i].nsec;
2807                                 p = e + strlen(table[i].suffix);
2808                                 break;
2809                         }
2810
2811                 if (i >= ELEMENTSOF(table))
2812                         return -EINVAL;
2813
2814         } while (*p != 0);
2815
2816         *nsec = r;
2817
2818         return 0;
2819 }
2820
2821 int parse_bytes(const char *t, off_t *bytes) {
2822         static const struct {
2823                 const char *suffix;
2824                 off_t factor;
2825         } table[] = {
2826                 { "B", 1 },
2827                 { "K", 1024ULL },
2828                 { "M", 1024ULL*1024ULL },
2829                 { "G", 1024ULL*1024ULL*1024ULL },
2830                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2831                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2832                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2833                 { "", 1 },
2834         };
2835
2836         const char *p;
2837         off_t r = 0;
2838
2839         assert(t);
2840         assert(bytes);
2841
2842         p = t;
2843         do {
2844                 long long l;
2845                 char *e;
2846                 unsigned i;
2847
2848                 errno = 0;
2849                 l = strtoll(p, &e, 10);
2850
2851                 if (errno != 0)
2852                         return -errno;
2853
2854                 if (l < 0)
2855                         return -ERANGE;
2856
2857                 if (e == p)
2858                         return -EINVAL;
2859
2860                 e += strspn(e, WHITESPACE);
2861
2862                 for (i = 0; i < ELEMENTSOF(table); i++)
2863                         if (startswith(e, table[i].suffix)) {
2864                                 r += (off_t) l * table[i].factor;
2865                                 p = e + strlen(table[i].suffix);
2866                                 break;
2867                         }
2868
2869                 if (i >= ELEMENTSOF(table))
2870                         return -EINVAL;
2871
2872         } while (*p != 0);
2873
2874         *bytes = r;
2875
2876         return 0;
2877 }
2878
2879 int make_stdio(int fd) {
2880         int r, s, t;
2881
2882         assert(fd >= 0);
2883
2884         r = dup2(fd, STDIN_FILENO);
2885         s = dup2(fd, STDOUT_FILENO);
2886         t = dup2(fd, STDERR_FILENO);
2887
2888         if (fd >= 3)
2889                 close_nointr_nofail(fd);
2890
2891         if (r < 0 || s < 0 || t < 0)
2892                 return -errno;
2893
2894         fd_cloexec(STDIN_FILENO, false);
2895         fd_cloexec(STDOUT_FILENO, false);
2896         fd_cloexec(STDERR_FILENO, false);
2897
2898         return 0;
2899 }
2900
2901 int make_null_stdio(void) {
2902         int null_fd;
2903
2904         if ((null_fd = open("/dev/null", O_RDWR|O_NOCTTY)) < 0)
2905                 return -errno;
2906
2907         return make_stdio(null_fd);
2908 }
2909
2910 bool is_device_path(const char *path) {
2911
2912         /* Returns true on paths that refer to a device, either in
2913          * sysfs or in /dev */
2914
2915         return
2916                 path_startswith(path, "/dev/") ||
2917                 path_startswith(path, "/sys/");
2918 }
2919
2920 int dir_is_empty(const char *path) {
2921         DIR *d;
2922         int r;
2923         struct dirent buf, *de;
2924
2925         if (!(d = opendir(path)))
2926                 return -errno;
2927
2928         for (;;) {
2929                 if ((r = readdir_r(d, &buf, &de)) > 0) {
2930                         r = -r;
2931                         break;
2932                 }
2933
2934                 if (!de) {
2935                         r = 1;
2936                         break;
2937                 }
2938
2939                 if (!ignore_file(de->d_name)) {
2940                         r = 0;
2941                         break;
2942                 }
2943         }
2944
2945         closedir(d);
2946         return r;
2947 }
2948
2949 unsigned long long random_ull(void) {
2950         int fd;
2951         uint64_t ull;
2952         ssize_t r;
2953
2954         if ((fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY)) < 0)
2955                 goto fallback;
2956
2957         r = loop_read(fd, &ull, sizeof(ull), true);
2958         close_nointr_nofail(fd);
2959
2960         if (r != sizeof(ull))
2961                 goto fallback;
2962
2963         return ull;
2964
2965 fallback:
2966         return random() * RAND_MAX + random();
2967 }
2968
2969 void rename_process(const char name[8]) {
2970         assert(name);
2971
2972         /* This is a like a poor man's setproctitle(). It changes the
2973          * comm field, argv[0], and also the glibc's internally used
2974          * name of the process. For the first one a limit of 16 chars
2975          * applies, to the second one usually one of 10 (i.e. length
2976          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2977          * "systemd"). If you pass a longer string it will be
2978          * truncated */
2979
2980         prctl(PR_SET_NAME, name);
2981
2982         if (program_invocation_name)
2983                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2984
2985         if (saved_argc > 0) {
2986                 int i;
2987
2988                 if (saved_argv[0])
2989                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2990
2991                 for (i = 1; i < saved_argc; i++) {
2992                         if (!saved_argv[i])
2993                                 break;
2994
2995                         memset(saved_argv[i], 0, strlen(saved_argv[i]));
2996                 }
2997         }
2998 }
2999
3000 void sigset_add_many(sigset_t *ss, ...) {
3001         va_list ap;
3002         int sig;
3003
3004         assert(ss);
3005
3006         va_start(ap, ss);
3007         while ((sig = va_arg(ap, int)) > 0)
3008                 assert_se(sigaddset(ss, sig) == 0);
3009         va_end(ap);
3010 }
3011
3012 char* gethostname_malloc(void) {
3013         struct utsname u;
3014
3015         assert_se(uname(&u) >= 0);
3016
3017         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
3018                 return strdup(u.nodename);
3019
3020         return strdup(u.sysname);
3021 }
3022
3023 bool hostname_is_set(void) {
3024         struct utsname u;
3025
3026         assert_se(uname(&u) >= 0);
3027
3028         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
3029 }
3030
3031 char* getlogname_malloc(void) {
3032         uid_t uid;
3033         long bufsize;
3034         char *buf, *name;
3035         struct passwd pwbuf, *pw = NULL;
3036         struct stat st;
3037
3038         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
3039                 uid = st.st_uid;
3040         else
3041                 uid = getuid();
3042
3043         /* Shortcut things to avoid NSS lookups */
3044         if (uid == 0)
3045                 return strdup("root");
3046
3047         if ((bufsize = sysconf(_SC_GETPW_R_SIZE_MAX)) <= 0)
3048                 bufsize = 4096;
3049
3050         if (!(buf = malloc(bufsize)))
3051                 return NULL;
3052
3053         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw) {
3054                 name = strdup(pw->pw_name);
3055                 free(buf);
3056                 return name;
3057         }
3058
3059         free(buf);
3060
3061         if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
3062                 return NULL;
3063
3064         return name;
3065 }
3066
3067 int getttyname_malloc(int fd, char **r) {
3068         char path[PATH_MAX], *c;
3069         int k;
3070
3071         assert(r);
3072
3073         if ((k = ttyname_r(fd, path, sizeof(path))) != 0)
3074                 return -k;
3075
3076         char_array_0(path);
3077
3078         if (!(c = strdup(startswith(path, "/dev/") ? path + 5 : path)))
3079                 return -ENOMEM;
3080
3081         *r = c;
3082         return 0;
3083 }
3084
3085 int getttyname_harder(int fd, char **r) {
3086         int k;
3087         char *s;
3088
3089         if ((k = getttyname_malloc(fd, &s)) < 0)
3090                 return k;
3091
3092         if (streq(s, "tty")) {
3093                 free(s);
3094                 return get_ctty(0, NULL, r);
3095         }
3096
3097         *r = s;
3098         return 0;
3099 }
3100
3101 int get_ctty_devnr(pid_t pid, dev_t *d) {
3102         int k;
3103         char line[LINE_MAX], *p, *fn;
3104         unsigned long ttynr;
3105         FILE *f;
3106
3107         if (asprintf(&fn, "/proc/%lu/stat", (unsigned long) (pid <= 0 ? getpid() : pid)) < 0)
3108                 return -ENOMEM;
3109
3110         f = fopen(fn, "re");
3111         free(fn);
3112         if (!f)
3113                 return -errno;
3114
3115         if (!fgets(line, sizeof(line), f)) {
3116                 k = feof(f) ? -EIO : -errno;
3117                 fclose(f);
3118                 return k;
3119         }
3120
3121         fclose(f);
3122
3123         p = strrchr(line, ')');
3124         if (!p)
3125                 return -EIO;
3126
3127         p++;
3128
3129         if (sscanf(p, " "
3130                    "%*c "  /* state */
3131                    "%*d "  /* ppid */
3132                    "%*d "  /* pgrp */
3133                    "%*d "  /* session */
3134                    "%lu ", /* ttynr */
3135                    &ttynr) != 1)
3136                 return -EIO;
3137
3138         *d = (dev_t) ttynr;
3139         return 0;
3140 }
3141
3142 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
3143         int k;
3144         char fn[PATH_MAX], *s, *b, *p;
3145         dev_t devnr;
3146
3147         assert(r);
3148
3149         k = get_ctty_devnr(pid, &devnr);
3150         if (k < 0)
3151                 return k;
3152
3153         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
3154         char_array_0(fn);
3155
3156         if ((k = readlink_malloc(fn, &s)) < 0) {
3157
3158                 if (k != -ENOENT)
3159                         return k;
3160
3161                 /* This is an ugly hack */
3162                 if (major(devnr) == 136) {
3163                         if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
3164                                 return -ENOMEM;
3165
3166                         *r = b;
3167                         if (_devnr)
3168                                 *_devnr = devnr;
3169
3170                         return 0;
3171                 }
3172
3173                 /* Probably something like the ptys which have no
3174                  * symlink in /dev/char. Let's return something
3175                  * vaguely useful. */
3176
3177                 if (!(b = strdup(fn + 5)))
3178                         return -ENOMEM;
3179
3180                 *r = b;
3181                 if (_devnr)
3182                         *_devnr = devnr;
3183
3184                 return 0;
3185         }
3186
3187         if (startswith(s, "/dev/"))
3188                 p = s + 5;
3189         else if (startswith(s, "../"))
3190                 p = s + 3;
3191         else
3192                 p = s;
3193
3194         b = strdup(p);
3195         free(s);
3196
3197         if (!b)
3198                 return -ENOMEM;
3199
3200         *r = b;
3201         if (_devnr)
3202                 *_devnr = devnr;
3203
3204         return 0;
3205 }
3206
3207 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3208         DIR *d;
3209         int ret = 0;
3210
3211         assert(fd >= 0);
3212
3213         /* This returns the first error we run into, but nevertheless
3214          * tries to go on. This closes the passed fd. */
3215
3216         d = fdopendir(fd);
3217         if (!d) {
3218                 close_nointr_nofail(fd);
3219
3220                 return errno == ENOENT ? 0 : -errno;
3221         }
3222
3223         for (;;) {
3224                 struct dirent buf, *de;
3225                 bool is_dir, keep_around;
3226                 struct stat st;
3227                 int r;
3228
3229                 r = readdir_r(d, &buf, &de);
3230                 if (r != 0 && ret == 0) {
3231                         ret = -r;
3232                         break;
3233                 }
3234
3235                 if (!de)
3236                         break;
3237
3238                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
3239                         continue;
3240
3241                 if (de->d_type == DT_UNKNOWN ||
3242                     honour_sticky ||
3243                     (de->d_type == DT_DIR && root_dev)) {
3244                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3245                                 if (ret == 0 && errno != ENOENT)
3246                                         ret = -errno;
3247                                 continue;
3248                         }
3249
3250                         is_dir = S_ISDIR(st.st_mode);
3251                         keep_around =
3252                                 honour_sticky &&
3253                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3254                                 (st.st_mode & S_ISVTX);
3255                 } else {
3256                         is_dir = de->d_type == DT_DIR;
3257                         keep_around = false;
3258                 }
3259
3260                 if (is_dir) {
3261                         int subdir_fd;
3262
3263                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
3264                         if (root_dev && st.st_dev != root_dev->st_dev)
3265                                 continue;
3266
3267                         subdir_fd = openat(fd, de->d_name,
3268                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3269                         if (subdir_fd < 0) {
3270                                 if (ret == 0 && errno != ENOENT)
3271                                         ret = -errno;
3272                                 continue;
3273                         }
3274
3275                         r = rm_rf_children(subdir_fd, only_dirs, honour_sticky, root_dev);
3276                         if (r < 0 && ret == 0)
3277                                 ret = r;
3278
3279                         if (!keep_around)
3280                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3281                                         if (ret == 0 && errno != ENOENT)
3282                                                 ret = -errno;
3283                                 }
3284
3285                 } else if (!only_dirs && !keep_around) {
3286
3287                         if (unlinkat(fd, de->d_name, 0) < 0) {
3288                                 if (ret == 0 && errno != ENOENT)
3289                                         ret = -errno;
3290                         }
3291                 }
3292         }
3293
3294         closedir(d);
3295
3296         return ret;
3297 }
3298
3299 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3300         int fd;
3301         int r;
3302
3303         assert(path);
3304
3305         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3306         if (fd < 0) {
3307
3308                 if (errno != ENOTDIR)
3309                         return -errno;
3310
3311                 if (delete_root && !only_dirs)
3312                         if (unlink(path) < 0 && errno != ENOENT)
3313                                 return -errno;
3314
3315                 return 0;
3316         }
3317
3318         r = rm_rf_children(fd, only_dirs, honour_sticky, NULL);
3319
3320         if (delete_root) {
3321
3322                 if (honour_sticky && file_is_priv_sticky(path) > 0)
3323                         return r;
3324
3325                 if (rmdir(path) < 0 && errno != ENOENT) {
3326                         if (r == 0)
3327                                 r = -errno;
3328                 }
3329         }
3330
3331         return r;
3332 }
3333
3334 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3335         assert(path);
3336
3337         /* Under the assumption that we are running privileged we
3338          * first change the access mode and only then hand out
3339          * ownership to avoid a window where access is too open. */
3340
3341         if (mode != (mode_t) -1)
3342                 if (chmod(path, mode) < 0)
3343                         return -errno;
3344
3345         if (uid != (uid_t) -1 || gid != (gid_t) -1)
3346                 if (chown(path, uid, gid) < 0)
3347                         return -errno;
3348
3349         return 0;
3350 }
3351
3352 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3353         assert(fd >= 0);
3354
3355         /* Under the assumption that we are running privileged we
3356          * first change the access mode and only then hand out
3357          * ownership to avoid a window where access is too open. */
3358
3359         if (fchmod(fd, mode) < 0)
3360                 return -errno;
3361
3362         if (fchown(fd, uid, gid) < 0)
3363                 return -errno;
3364
3365         return 0;
3366 }
3367
3368 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3369         cpu_set_t *r;
3370         unsigned n = 1024;
3371
3372         /* Allocates the cpuset in the right size */
3373
3374         for (;;) {
3375                 if (!(r = CPU_ALLOC(n)))
3376                         return NULL;
3377
3378                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3379                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3380
3381                         if (ncpus)
3382                                 *ncpus = n;
3383
3384                         return r;
3385                 }
3386
3387                 CPU_FREE(r);
3388
3389                 if (errno != EINVAL)
3390                         return NULL;
3391
3392                 n *= 2;
3393         }
3394 }
3395
3396 void status_vprintf(const char *status, bool ellipse, const char *format, va_list ap) {
3397         char *s = NULL;
3398         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3399         int fd = -1;
3400         struct iovec iovec[5];
3401         int n = 0;
3402
3403         assert(format);
3404
3405         /* This is independent of logging, as status messages are
3406          * optional and go exclusively to the console. */
3407
3408         if (vasprintf(&s, format, ap) < 0)
3409                 goto finish;
3410
3411         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3412         if (fd < 0)
3413                 goto finish;
3414
3415         if (ellipse) {
3416                 char *e;
3417                 size_t emax, sl;
3418                 int c;
3419
3420                 c = fd_columns(fd);
3421                 if (c <= 0)
3422                         c = 80;
3423
3424                 sl = status ? strlen(status_indent) : 0;
3425
3426                 emax = c - sl - 1;
3427                 if (emax < 3)
3428                         emax = 3;
3429
3430                 e = ellipsize(s, emax, 75);
3431                 if (e) {
3432                         free(s);
3433                         s = e;
3434                 }
3435         }
3436
3437         zero(iovec);
3438
3439         if (status) {
3440                 if (!isempty(status)) {
3441                         IOVEC_SET_STRING(iovec[n++], "[");
3442                         IOVEC_SET_STRING(iovec[n++], status);
3443                         IOVEC_SET_STRING(iovec[n++], "] ");
3444                 } else
3445                         IOVEC_SET_STRING(iovec[n++], status_indent);
3446         }
3447
3448         IOVEC_SET_STRING(iovec[n++], s);
3449         IOVEC_SET_STRING(iovec[n++], "\n");
3450
3451         writev(fd, iovec, n);
3452
3453 finish:
3454         free(s);
3455
3456         if (fd >= 0)
3457                 close_nointr_nofail(fd);
3458 }
3459
3460 void status_printf(const char *status, bool ellipse, const char *format, ...) {
3461         va_list ap;
3462
3463         assert(format);
3464
3465         va_start(ap, format);
3466         status_vprintf(status, ellipse, format, ap);
3467         va_end(ap);
3468 }
3469
3470 void status_welcome(void) {
3471         char *pretty_name = NULL, *ansi_color = NULL;
3472         const char *const_pretty = NULL, *const_color = NULL;
3473         int r;
3474
3475         if ((r = parse_env_file("/etc/os-release", NEWLINE,
3476                                 "PRETTY_NAME", &pretty_name,
3477                                 "ANSI_COLOR", &ansi_color,
3478                                 NULL)) < 0) {
3479
3480                 if (r != -ENOENT)
3481                         log_warning("Failed to read /etc/os-release: %s", strerror(-r));
3482         }
3483
3484         if (!pretty_name && !const_pretty)
3485                 const_pretty = "Linux";
3486
3487         if (!ansi_color && !const_color)
3488                 const_color = "1";
3489
3490         status_printf(NULL,
3491                       false,
3492                       "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
3493                       const_color ? const_color : ansi_color,
3494                       const_pretty ? const_pretty : pretty_name);
3495
3496         free(ansi_color);
3497         free(pretty_name);
3498 }
3499
3500 char *replace_env(const char *format, char **env) {
3501         enum {
3502                 WORD,
3503                 CURLY,
3504                 VARIABLE
3505         } state = WORD;
3506
3507         const char *e, *word = format;
3508         char *r = NULL, *k;
3509
3510         assert(format);
3511
3512         for (e = format; *e; e ++) {
3513
3514                 switch (state) {
3515
3516                 case WORD:
3517                         if (*e == '$')
3518                                 state = CURLY;
3519                         break;
3520
3521                 case CURLY:
3522                         if (*e == '{') {
3523                                 if (!(k = strnappend(r, word, e-word-1)))
3524                                         goto fail;
3525
3526                                 free(r);
3527                                 r = k;
3528
3529                                 word = e-1;
3530                                 state = VARIABLE;
3531
3532                         } else if (*e == '$') {
3533                                 if (!(k = strnappend(r, word, e-word)))
3534                                         goto fail;
3535
3536                                 free(r);
3537                                 r = k;
3538
3539                                 word = e+1;
3540                                 state = WORD;
3541                         } else
3542                                 state = WORD;
3543                         break;
3544
3545                 case VARIABLE:
3546                         if (*e == '}') {
3547                                 const char *t;
3548
3549                                 if (!(t = strv_env_get_with_length(env, word+2, e-word-2)))
3550                                         t = "";
3551
3552                                 if (!(k = strappend(r, t)))
3553                                         goto fail;
3554
3555                                 free(r);
3556                                 r = k;
3557
3558                                 word = e+1;
3559                                 state = WORD;
3560                         }
3561                         break;
3562                 }
3563         }
3564
3565         if (!(k = strnappend(r, word, e-word)))
3566                 goto fail;
3567
3568         free(r);
3569         return k;
3570
3571 fail:
3572         free(r);
3573         return NULL;
3574 }
3575
3576 char **replace_env_argv(char **argv, char **env) {
3577         char **r, **i;
3578         unsigned k = 0, l = 0;
3579
3580         l = strv_length(argv);
3581
3582         if (!(r = new(char*, l+1)))
3583                 return NULL;
3584
3585         STRV_FOREACH(i, argv) {
3586
3587                 /* If $FOO appears as single word, replace it by the split up variable */
3588                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3589                         char *e;
3590                         char **w, **m;
3591                         unsigned q;
3592
3593                         if ((e = strv_env_get(env, *i+1))) {
3594
3595                                 if (!(m = strv_split_quoted(e))) {
3596                                         r[k] = NULL;
3597                                         strv_free(r);
3598                                         return NULL;
3599                                 }
3600                         } else
3601                                 m = NULL;
3602
3603                         q = strv_length(m);
3604                         l = l + q - 1;
3605
3606                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3607                                 r[k] = NULL;
3608                                 strv_free(r);
3609                                 strv_free(m);
3610                                 return NULL;
3611                         }
3612
3613                         r = w;
3614                         if (m) {
3615                                 memcpy(r + k, m, q * sizeof(char*));
3616                                 free(m);
3617                         }
3618
3619                         k += q;
3620                         continue;
3621                 }
3622
3623                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3624                 if (!(r[k++] = replace_env(*i, env))) {
3625                         strv_free(r);
3626                         return NULL;
3627                 }
3628         }
3629
3630         r[k] = NULL;
3631         return r;
3632 }
3633
3634 int fd_columns(int fd) {
3635         struct winsize ws;
3636         zero(ws);
3637
3638         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3639                 return -errno;
3640
3641         if (ws.ws_col <= 0)
3642                 return -EIO;
3643
3644         return ws.ws_col;
3645 }
3646
3647 unsigned columns(void) {
3648         static __thread int parsed_columns = 0;
3649         const char *e;
3650
3651         if (_likely_(parsed_columns > 0))
3652                 return parsed_columns;
3653
3654         e = getenv("COLUMNS");
3655         if (e)
3656                 parsed_columns = atoi(e);
3657
3658         if (parsed_columns <= 0)
3659                 parsed_columns = fd_columns(STDOUT_FILENO);
3660
3661         if (parsed_columns <= 0)
3662                 parsed_columns = 80;
3663
3664         return parsed_columns;
3665 }
3666
3667 int fd_lines(int fd) {
3668         struct winsize ws;
3669         zero(ws);
3670
3671         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3672                 return -errno;
3673
3674         if (ws.ws_row <= 0)
3675                 return -EIO;
3676
3677         return ws.ws_row;
3678 }
3679
3680 unsigned lines(void) {
3681         static __thread int parsed_lines = 0;
3682         const char *e;
3683
3684         if (_likely_(parsed_lines > 0))
3685                 return parsed_lines;
3686
3687         e = getenv("LINES");
3688         if (e)
3689                 parsed_lines = atoi(e);
3690
3691         if (parsed_lines <= 0)
3692                 parsed_lines = fd_lines(STDOUT_FILENO);
3693
3694         if (parsed_lines <= 0)
3695                 parsed_lines = 25;
3696
3697         return parsed_lines;
3698 }
3699
3700 int running_in_chroot(void) {
3701         struct stat a, b;
3702
3703         zero(a);
3704         zero(b);
3705
3706         /* Only works as root */
3707
3708         if (stat("/proc/1/root", &a) < 0)
3709                 return -errno;
3710
3711         if (stat("/", &b) < 0)
3712                 return -errno;
3713
3714         return
3715                 a.st_dev != b.st_dev ||
3716                 a.st_ino != b.st_ino;
3717 }
3718
3719 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3720         size_t x;
3721         char *r;
3722
3723         assert(s);
3724         assert(percent <= 100);
3725         assert(new_length >= 3);
3726
3727         if (old_length <= 3 || old_length <= new_length)
3728                 return strndup(s, old_length);
3729
3730         r = new0(char, new_length+1);
3731         if (!r)
3732                 return r;
3733
3734         x = (new_length * percent) / 100;
3735
3736         if (x > new_length - 3)
3737                 x = new_length - 3;
3738
3739         memcpy(r, s, x);
3740         r[x] = '.';
3741         r[x+1] = '.';
3742         r[x+2] = '.';
3743         memcpy(r + x + 3,
3744                s + old_length - (new_length - x - 3),
3745                new_length - x - 3);
3746
3747         return r;
3748 }
3749
3750 char *ellipsize(const char *s, size_t length, unsigned percent) {
3751         return ellipsize_mem(s, strlen(s), length, percent);
3752 }
3753
3754 int touch(const char *path) {
3755         int fd;
3756
3757         assert(path);
3758
3759         if ((fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644)) < 0)
3760                 return -errno;
3761
3762         close_nointr_nofail(fd);
3763         return 0;
3764 }
3765
3766 char *unquote(const char *s, const char* quotes) {
3767         size_t l;
3768         assert(s);
3769
3770         l = strlen(s);
3771         if (l < 2)
3772                 return strdup(s);
3773
3774         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3775                 return strndup(s+1, l-2);
3776
3777         return strdup(s);
3778 }
3779
3780 char *normalize_env_assignment(const char *s) {
3781         char *name, *value, *p, *r;
3782
3783         p = strchr(s, '=');
3784
3785         if (!p) {
3786                 if (!(r = strdup(s)))
3787                         return NULL;
3788
3789                 return strstrip(r);
3790         }
3791
3792         if (!(name = strndup(s, p - s)))
3793                 return NULL;
3794
3795         if (!(p = strdup(p+1))) {
3796                 free(name);
3797                 return NULL;
3798         }
3799
3800         value = unquote(strstrip(p), QUOTES);
3801         free(p);
3802
3803         if (!value) {
3804                 free(name);
3805                 return NULL;
3806         }
3807
3808         if (asprintf(&r, "%s=%s", name, value) < 0)
3809                 r = NULL;
3810
3811         free(value);
3812         free(name);
3813
3814         return r;
3815 }
3816
3817 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3818         siginfo_t dummy;
3819
3820         assert(pid >= 1);
3821
3822         if (!status)
3823                 status = &dummy;
3824
3825         for (;;) {
3826                 zero(*status);
3827
3828                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3829
3830                         if (errno == EINTR)
3831                                 continue;
3832
3833                         return -errno;
3834                 }
3835
3836                 return 0;
3837         }
3838 }
3839
3840 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3841         int r;
3842         siginfo_t status;
3843
3844         assert(name);
3845         assert(pid > 1);
3846
3847         if ((r = wait_for_terminate(pid, &status)) < 0) {
3848                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3849                 return r;
3850         }
3851
3852         if (status.si_code == CLD_EXITED) {
3853                 if (status.si_status != 0) {
3854                         log_warning("%s failed with error code %i.", name, status.si_status);
3855                         return status.si_status;
3856                 }
3857
3858                 log_debug("%s succeeded.", name);
3859                 return 0;
3860
3861         } else if (status.si_code == CLD_KILLED ||
3862                    status.si_code == CLD_DUMPED) {
3863
3864                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3865                 return -EPROTO;
3866         }
3867
3868         log_warning("%s failed due to unknown reason.", name);
3869         return -EPROTO;
3870
3871 }
3872
3873 _noreturn_ void freeze(void) {
3874
3875         /* Make sure nobody waits for us on a socket anymore */
3876         close_all_fds(NULL, 0);
3877
3878         sync();
3879
3880         for (;;)
3881                 pause();
3882 }
3883
3884 bool null_or_empty(struct stat *st) {
3885         assert(st);
3886
3887         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3888                 return true;
3889
3890         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3891                 return true;
3892
3893         return false;
3894 }
3895
3896 int null_or_empty_path(const char *fn) {
3897         struct stat st;
3898
3899         assert(fn);
3900
3901         if (stat(fn, &st) < 0)
3902                 return -errno;
3903
3904         return null_or_empty(&st);
3905 }
3906
3907 DIR *xopendirat(int fd, const char *name, int flags) {
3908         int nfd;
3909         DIR *d;
3910
3911         if ((nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags)) < 0)
3912                 return NULL;
3913
3914         if (!(d = fdopendir(nfd))) {
3915                 close_nointr_nofail(nfd);
3916                 return NULL;
3917         }
3918
3919         return d;
3920 }
3921
3922 int signal_from_string_try_harder(const char *s) {
3923         int signo;
3924         assert(s);
3925
3926         if ((signo = signal_from_string(s)) <= 0)
3927                 if (startswith(s, "SIG"))
3928                         return signal_from_string(s+3);
3929
3930         return signo;
3931 }
3932
3933 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {
3934
3935         assert(f);
3936         assert(name);
3937         assert(t);
3938
3939         if (!dual_timestamp_is_set(t))
3940                 return;
3941
3942         fprintf(f, "%s=%llu %llu\n",
3943                 name,
3944                 (unsigned long long) t->realtime,
3945                 (unsigned long long) t->monotonic);
3946 }
3947
3948 void dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
3949         unsigned long long a, b;
3950
3951         assert(value);
3952         assert(t);
3953
3954         if (sscanf(value, "%lli %llu", &a, &b) != 2)
3955                 log_debug("Failed to parse finish timestamp value %s", value);
3956         else {
3957                 t->realtime = a;
3958                 t->monotonic = b;
3959         }
3960 }
3961
3962 char *fstab_node_to_udev_node(const char *p) {
3963         char *dn, *t, *u;
3964         int r;
3965
3966         /* FIXME: to follow udev's logic 100% we need to leave valid
3967          * UTF8 chars unescaped */
3968
3969         if (startswith(p, "LABEL=")) {
3970
3971                 if (!(u = unquote(p+6, "\"\'")))
3972                         return NULL;
3973
3974                 t = xescape(u, "/ ");
3975                 free(u);
3976
3977                 if (!t)
3978                         return NULL;
3979
3980                 r = asprintf(&dn, "/dev/disk/by-label/%s", t);
3981                 free(t);
3982
3983                 if (r < 0)
3984                         return NULL;
3985
3986                 return dn;
3987         }
3988
3989         if (startswith(p, "UUID=")) {
3990
3991                 if (!(u = unquote(p+5, "\"\'")))
3992                         return NULL;
3993
3994                 t = xescape(u, "/ ");
3995                 free(u);
3996
3997                 if (!t)
3998                         return NULL;
3999
4000                 r = asprintf(&dn, "/dev/disk/by-uuid/%s", t);
4001                 free(t);
4002
4003                 if (r < 0)
4004                         return NULL;
4005
4006                 return dn;
4007         }
4008
4009         return strdup(p);
4010 }
4011
4012 bool tty_is_vc(const char *tty) {
4013         assert(tty);
4014
4015         if (startswith(tty, "/dev/"))
4016                 tty += 5;
4017
4018         return vtnr_from_tty(tty) >= 0;
4019 }
4020
4021 bool tty_is_console(const char *tty) {
4022         assert(tty);
4023
4024         if (startswith(tty, "/dev/"))
4025                 tty += 5;
4026
4027         return streq(tty, "console");
4028 }
4029
4030 int vtnr_from_tty(const char *tty) {
4031         int i, r;
4032
4033         assert(tty);
4034
4035         if (startswith(tty, "/dev/"))
4036                 tty += 5;
4037
4038         if (!startswith(tty, "tty") )
4039                 return -EINVAL;
4040
4041         if (tty[3] < '0' || tty[3] > '9')
4042                 return -EINVAL;
4043
4044         r = safe_atoi(tty+3, &i);
4045         if (r < 0)
4046                 return r;
4047
4048         if (i < 0 || i > 63)
4049                 return -EINVAL;
4050
4051         return i;
4052 }
4053
4054 bool tty_is_vc_resolve(const char *tty) {
4055         char *active = NULL;
4056         bool b;
4057
4058         assert(tty);
4059
4060         if (startswith(tty, "/dev/"))
4061                 tty += 5;
4062
4063         /* Resolve where /dev/console is pointing to, if /sys is
4064          * actually ours (i.e. not read-only-mounted which is a sign
4065          * for container setups) */
4066         if (streq(tty, "console") && path_is_read_only_fs("/sys") <= 0)
4067                 if (read_one_line_file("/sys/class/tty/console/active", &active) >= 0) {
4068                         /* If multiple log outputs are configured the
4069                          * last one is what /dev/console points to */
4070                         tty = strrchr(active, ' ');
4071                         if (tty)
4072                                 tty++;
4073                         else
4074                                 tty = active;
4075                 }
4076
4077         b = tty_is_vc(tty);
4078         free(active);
4079
4080         return b;
4081 }
4082
4083 const char *default_term_for_tty(const char *tty) {
4084         assert(tty);
4085
4086         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
4087 }
4088
4089 bool dirent_is_file(const struct dirent *de) {
4090         assert(de);
4091
4092         if (ignore_file(de->d_name))
4093                 return false;
4094
4095         if (de->d_type != DT_REG &&
4096             de->d_type != DT_LNK &&
4097             de->d_type != DT_UNKNOWN)
4098                 return false;
4099
4100         return true;
4101 }
4102
4103 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4104         assert(de);
4105
4106         if (!dirent_is_file(de))
4107                 return false;
4108
4109         return endswith(de->d_name, suffix);
4110 }
4111
4112 void execute_directory(const char *directory, DIR *d, char *argv[]) {
4113         DIR *_d = NULL;
4114         struct dirent *de;
4115         Hashmap *pids = NULL;
4116
4117         assert(directory);
4118
4119         /* Executes all binaries in a directory in parallel and waits
4120          * until all they all finished. */
4121
4122         if (!d) {
4123                 if (!(_d = opendir(directory))) {
4124
4125                         if (errno == ENOENT)
4126                                 return;
4127
4128                         log_error("Failed to enumerate directory %s: %m", directory);
4129                         return;
4130                 }
4131
4132                 d = _d;
4133         }
4134
4135         if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
4136                 log_error("Failed to allocate set.");
4137                 goto finish;
4138         }
4139
4140         while ((de = readdir(d))) {
4141                 char *path;
4142                 pid_t pid;
4143                 int k;
4144
4145                 if (!dirent_is_file(de))
4146                         continue;
4147
4148                 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
4149                         log_error("Out of memory");
4150                         continue;
4151                 }
4152
4153                 if ((pid = fork()) < 0) {
4154                         log_error("Failed to fork: %m");
4155                         free(path);
4156                         continue;
4157                 }
4158
4159                 if (pid == 0) {
4160                         char *_argv[2];
4161                         /* Child */
4162
4163                         if (!argv) {
4164                                 _argv[0] = path;
4165                                 _argv[1] = NULL;
4166                                 argv = _argv;
4167                         } else
4168                                 argv[0] = path;
4169
4170                         execv(path, argv);
4171
4172                         log_error("Failed to execute %s: %m", path);
4173                         _exit(EXIT_FAILURE);
4174                 }
4175
4176                 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
4177
4178                 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
4179                         log_error("Failed to add PID to set: %s", strerror(-k));
4180                         free(path);
4181                 }
4182         }
4183
4184         while (!hashmap_isempty(pids)) {
4185                 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
4186                 siginfo_t si;
4187                 char *path;
4188
4189                 zero(si);
4190                 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
4191
4192                         if (errno == EINTR)
4193                                 continue;
4194
4195                         log_error("waitid() failed: %m");
4196                         goto finish;
4197                 }
4198
4199                 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
4200                         if (!is_clean_exit(si.si_code, si.si_status)) {
4201                                 if (si.si_code == CLD_EXITED)
4202                                         log_error("%s exited with exit status %i.", path, si.si_status);
4203                                 else
4204                                         log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
4205                         } else
4206                                 log_debug("%s exited successfully.", path);
4207
4208                         free(path);
4209                 }
4210         }
4211
4212 finish:
4213         if (_d)
4214                 closedir(_d);
4215
4216         if (pids)
4217                 hashmap_free_free(pids);
4218 }
4219
4220 int kill_and_sigcont(pid_t pid, int sig) {
4221         int r;
4222
4223         r = kill(pid, sig) < 0 ? -errno : 0;
4224
4225         if (r >= 0)
4226                 kill(pid, SIGCONT);
4227
4228         return r;
4229 }
4230
4231 bool nulstr_contains(const char*nulstr, const char *needle) {
4232         const char *i;
4233
4234         if (!nulstr)
4235                 return false;
4236
4237         NULSTR_FOREACH(i, nulstr)
4238                 if (streq(i, needle))
4239                         return true;
4240
4241         return false;
4242 }
4243
4244 bool plymouth_running(void) {
4245         return access("/run/plymouth/pid", F_OK) >= 0;
4246 }
4247
4248 void parse_syslog_priority(char **p, int *priority) {
4249         int a = 0, b = 0, c = 0;
4250         int k;
4251
4252         assert(p);
4253         assert(*p);
4254         assert(priority);
4255
4256         if ((*p)[0] != '<')
4257                 return;
4258
4259         if (!strchr(*p, '>'))
4260                 return;
4261
4262         if ((*p)[2] == '>') {
4263                 c = undecchar((*p)[1]);
4264                 k = 3;
4265         } else if ((*p)[3] == '>') {
4266                 b = undecchar((*p)[1]);
4267                 c = undecchar((*p)[2]);
4268                 k = 4;
4269         } else if ((*p)[4] == '>') {
4270                 a = undecchar((*p)[1]);
4271                 b = undecchar((*p)[2]);
4272                 c = undecchar((*p)[3]);
4273                 k = 5;
4274         } else
4275                 return;
4276
4277         if (a < 0 || b < 0 || c < 0)
4278                 return;
4279
4280         *priority = a*100+b*10+c;
4281         *p += k;
4282 }
4283
4284 void skip_syslog_pid(char **buf) {
4285         char *p;
4286
4287         assert(buf);
4288         assert(*buf);
4289
4290         p = *buf;
4291
4292         if (*p != '[')
4293                 return;
4294
4295         p++;
4296         p += strspn(p, "0123456789");
4297
4298         if (*p != ']')
4299                 return;
4300
4301         p++;
4302
4303         *buf = p;
4304 }
4305
4306 void skip_syslog_date(char **buf) {
4307         enum {
4308                 LETTER,
4309                 SPACE,
4310                 NUMBER,
4311                 SPACE_OR_NUMBER,
4312                 COLON
4313         } sequence[] = {
4314                 LETTER, LETTER, LETTER,
4315                 SPACE,
4316                 SPACE_OR_NUMBER, NUMBER,
4317                 SPACE,
4318                 SPACE_OR_NUMBER, NUMBER,
4319                 COLON,
4320                 SPACE_OR_NUMBER, NUMBER,
4321                 COLON,
4322                 SPACE_OR_NUMBER, NUMBER,
4323                 SPACE
4324         };
4325
4326         char *p;
4327         unsigned i;
4328
4329         assert(buf);
4330         assert(*buf);
4331
4332         p = *buf;
4333
4334         for (i = 0; i < ELEMENTSOF(sequence); i++, p++) {
4335
4336                 if (!*p)
4337                         return;
4338
4339                 switch (sequence[i]) {
4340
4341                 case SPACE:
4342                         if (*p != ' ')
4343                                 return;
4344                         break;
4345
4346                 case SPACE_OR_NUMBER:
4347                         if (*p == ' ')
4348                                 break;
4349
4350                         /* fall through */
4351
4352                 case NUMBER:
4353                         if (*p < '0' || *p > '9')
4354                                 return;
4355
4356                         break;
4357
4358                 case LETTER:
4359                         if (!(*p >= 'A' && *p <= 'Z') &&
4360                             !(*p >= 'a' && *p <= 'z'))
4361                                 return;
4362
4363                         break;
4364
4365                 case COLON:
4366                         if (*p != ':')
4367                                 return;
4368                         break;
4369
4370                 }
4371         }
4372
4373         *buf = p;
4374 }
4375
4376 char* strshorten(char *s, size_t l) {
4377         assert(s);
4378
4379         if (l < strlen(s))
4380                 s[l] = 0;
4381
4382         return s;
4383 }
4384
4385 static bool hostname_valid_char(char c) {
4386         return
4387                 (c >= 'a' && c <= 'z') ||
4388                 (c >= 'A' && c <= 'Z') ||
4389                 (c >= '0' && c <= '9') ||
4390                 c == '-' ||
4391                 c == '_' ||
4392                 c == '.';
4393 }
4394
4395 bool hostname_is_valid(const char *s) {
4396         const char *p;
4397
4398         if (isempty(s))
4399                 return false;
4400
4401         for (p = s; *p; p++)
4402                 if (!hostname_valid_char(*p))
4403                         return false;
4404
4405         if (p-s > HOST_NAME_MAX)
4406                 return false;
4407
4408         return true;
4409 }
4410
4411 char* hostname_cleanup(char *s) {
4412         char *p, *d;
4413
4414         for (p = s, d = s; *p; p++)
4415                 if ((*p >= 'a' && *p <= 'z') ||
4416                     (*p >= 'A' && *p <= 'Z') ||
4417                     (*p >= '0' && *p <= '9') ||
4418                     *p == '-' ||
4419                     *p == '_' ||
4420                     *p == '.')
4421                         *(d++) = *p;
4422
4423         *d = 0;
4424
4425         strshorten(s, HOST_NAME_MAX);
4426         return s;
4427 }
4428
4429 int pipe_eof(int fd) {
4430         struct pollfd pollfd;
4431         int r;
4432
4433         zero(pollfd);
4434         pollfd.fd = fd;
4435         pollfd.events = POLLIN|POLLHUP;
4436
4437         r = poll(&pollfd, 1, 0);
4438         if (r < 0)
4439                 return -errno;
4440
4441         if (r == 0)
4442                 return 0;
4443
4444         return pollfd.revents & POLLHUP;
4445 }
4446
4447 int fd_wait_for_event(int fd, int event, usec_t t) {
4448         struct pollfd pollfd;
4449         int r;
4450
4451         zero(pollfd);
4452         pollfd.fd = fd;
4453         pollfd.events = event;
4454
4455         r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
4456         if (r < 0)
4457                 return -errno;
4458
4459         if (r == 0)
4460                 return 0;
4461
4462         return pollfd.revents;
4463 }
4464
4465 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4466         FILE *f;
4467         char *t;
4468         const char *fn;
4469         size_t k;
4470         int fd;
4471
4472         assert(path);
4473         assert(_f);
4474         assert(_temp_path);
4475
4476         t = new(char, strlen(path) + 1 + 6 + 1);
4477         if (!t)
4478                 return -ENOMEM;
4479
4480         fn = path_get_file_name(path);
4481         k = fn-path;
4482         memcpy(t, path, k);
4483         t[k] = '.';
4484         stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
4485
4486         fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
4487         if (fd < 0) {
4488                 free(t);
4489                 return -errno;
4490         }
4491
4492         f = fdopen(fd, "we");
4493         if (!f) {
4494                 unlink(t);
4495                 free(t);
4496                 return -errno;
4497         }
4498
4499         *_f = f;
4500         *_temp_path = t;
4501
4502         return 0;
4503 }
4504
4505 int terminal_vhangup_fd(int fd) {
4506         assert(fd >= 0);
4507
4508         if (ioctl(fd, TIOCVHANGUP) < 0)
4509                 return -errno;
4510
4511         return 0;
4512 }
4513
4514 int terminal_vhangup(const char *name) {
4515         int fd, r;
4516
4517         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4518         if (fd < 0)
4519                 return fd;
4520
4521         r = terminal_vhangup_fd(fd);
4522         close_nointr_nofail(fd);
4523
4524         return r;
4525 }
4526
4527 int vt_disallocate(const char *name) {
4528         int fd, r;
4529         unsigned u;
4530
4531         /* Deallocate the VT if possible. If not possible
4532          * (i.e. because it is the active one), at least clear it
4533          * entirely (including the scrollback buffer) */
4534
4535         if (!startswith(name, "/dev/"))
4536                 return -EINVAL;
4537
4538         if (!tty_is_vc(name)) {
4539                 /* So this is not a VT. I guess we cannot deallocate
4540                  * it then. But let's at least clear the screen */
4541
4542                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4543                 if (fd < 0)
4544                         return fd;
4545
4546                 loop_write(fd,
4547                            "\033[r"    /* clear scrolling region */
4548                            "\033[H"    /* move home */
4549                            "\033[2J",  /* clear screen */
4550                            10, false);
4551                 close_nointr_nofail(fd);
4552
4553                 return 0;
4554         }
4555
4556         if (!startswith(name, "/dev/tty"))
4557                 return -EINVAL;
4558
4559         r = safe_atou(name+8, &u);
4560         if (r < 0)
4561                 return r;
4562
4563         if (u <= 0)
4564                 return -EINVAL;
4565
4566         /* Try to deallocate */
4567         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4568         if (fd < 0)
4569                 return fd;
4570
4571         r = ioctl(fd, VT_DISALLOCATE, u);
4572         close_nointr_nofail(fd);
4573
4574         if (r >= 0)
4575                 return 0;
4576
4577         if (errno != EBUSY)
4578                 return -errno;
4579
4580         /* Couldn't deallocate, so let's clear it fully with
4581          * scrollback */
4582         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4583         if (fd < 0)
4584                 return fd;
4585
4586         loop_write(fd,
4587                    "\033[r"   /* clear scrolling region */
4588                    "\033[H"   /* move home */
4589                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4590                    10, false);
4591         close_nointr_nofail(fd);
4592
4593         return 0;
4594 }
4595
4596 int copy_file(const char *from, const char *to) {
4597         int r, fdf, fdt;
4598
4599         assert(from);
4600         assert(to);
4601
4602         fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4603         if (fdf < 0)
4604                 return -errno;
4605
4606         fdt = open(to, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC|O_NOCTTY, 0644);
4607         if (fdt < 0) {
4608                 close_nointr_nofail(fdf);
4609                 return -errno;
4610         }
4611
4612         for (;;) {
4613                 char buf[PIPE_BUF];
4614                 ssize_t n, k;
4615
4616                 n = read(fdf, buf, sizeof(buf));
4617                 if (n < 0) {
4618                         r = -errno;
4619
4620                         close_nointr_nofail(fdf);
4621                         close_nointr(fdt);
4622                         unlink(to);
4623
4624                         return r;
4625                 }
4626
4627                 if (n == 0)
4628                         break;
4629
4630                 errno = 0;
4631                 k = loop_write(fdt, buf, n, false);
4632                 if (n != k) {
4633                         r = k < 0 ? k : (errno ? -errno : -EIO);
4634
4635                         close_nointr_nofail(fdf);
4636                         close_nointr(fdt);
4637
4638                         unlink(to);
4639                         return r;
4640                 }
4641         }
4642
4643         close_nointr_nofail(fdf);
4644         r = close_nointr(fdt);
4645
4646         if (r < 0) {
4647                 unlink(to);
4648                 return r;
4649         }
4650
4651         return 0;
4652 }
4653
4654 int symlink_or_copy(const char *from, const char *to) {
4655         char *pf = NULL, *pt = NULL;
4656         struct stat a, b;
4657         int r;
4658
4659         assert(from);
4660         assert(to);
4661
4662         if (path_get_parent(from, &pf) < 0 ||
4663             path_get_parent(to, &pt) < 0) {
4664                 r = -ENOMEM;
4665                 goto finish;
4666         }
4667
4668         if (stat(pf, &a) < 0 ||
4669             stat(pt, &b) < 0) {
4670                 r = -errno;
4671                 goto finish;
4672         }
4673
4674         if (a.st_dev != b.st_dev) {
4675                 free(pf);
4676                 free(pt);
4677
4678                 return copy_file(from, to);
4679         }
4680
4681         if (symlink(from, to) < 0) {
4682                 r = -errno;
4683                 goto finish;
4684         }
4685
4686         r = 0;
4687
4688 finish:
4689         free(pf);
4690         free(pt);
4691
4692         return r;
4693 }
4694
4695 int symlink_or_copy_atomic(const char *from, const char *to) {
4696         char *t, *x;
4697         const char *fn;
4698         size_t k;
4699         unsigned long long ull;
4700         unsigned i;
4701         int r;
4702
4703         assert(from);
4704         assert(to);
4705
4706         t = new(char, strlen(to) + 1 + 16 + 1);
4707         if (!t)
4708                 return -ENOMEM;
4709
4710         fn = path_get_file_name(to);
4711         k = fn-to;
4712         memcpy(t, to, k);
4713         t[k] = '.';
4714         x = stpcpy(t+k+1, fn);
4715
4716         ull = random_ull();
4717         for (i = 0; i < 16; i++) {
4718                 *(x++) = hexchar(ull & 0xF);
4719                 ull >>= 4;
4720         }
4721
4722         *x = 0;
4723
4724         r = symlink_or_copy(from, t);
4725         if (r < 0) {
4726                 unlink(t);
4727                 free(t);
4728                 return r;
4729         }
4730
4731         if (rename(t, to) < 0) {
4732                 r = -errno;
4733                 unlink(t);
4734                 free(t);
4735                 return r;
4736         }
4737
4738         free(t);
4739         return r;
4740 }
4741
4742 bool display_is_local(const char *display) {
4743         assert(display);
4744
4745         return
4746                 display[0] == ':' &&
4747                 display[1] >= '0' &&
4748                 display[1] <= '9';
4749 }
4750
4751 int socket_from_display(const char *display, char **path) {
4752         size_t k;
4753         char *f, *c;
4754
4755         assert(display);
4756         assert(path);
4757
4758         if (!display_is_local(display))
4759                 return -EINVAL;
4760
4761         k = strspn(display+1, "0123456789");
4762
4763         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
4764         if (!f)
4765                 return -ENOMEM;
4766
4767         c = stpcpy(f, "/tmp/.X11-unix/X");
4768         memcpy(c, display+1, k);
4769         c[k] = 0;
4770
4771         *path = f;
4772
4773         return 0;
4774 }
4775
4776 int get_user_creds(const char **username, uid_t *uid, gid_t *gid, const char **home) {
4777         struct passwd *p;
4778         uid_t u;
4779
4780         assert(username);
4781         assert(*username);
4782
4783         /* We enforce some special rules for uid=0: in order to avoid
4784          * NSS lookups for root we hardcode its data. */
4785
4786         if (streq(*username, "root") || streq(*username, "0")) {
4787                 *username = "root";
4788
4789                 if (uid)
4790                         *uid = 0;
4791
4792                 if (gid)
4793                         *gid = 0;
4794
4795                 if (home)
4796                         *home = "/root";
4797                 return 0;
4798         }
4799
4800         if (parse_uid(*username, &u) >= 0) {
4801                 errno = 0;
4802                 p = getpwuid(u);
4803
4804                 /* If there are multiple users with the same id, make
4805                  * sure to leave $USER to the configured value instead
4806                  * of the first occurrence in the database. However if
4807                  * the uid was configured by a numeric uid, then let's
4808                  * pick the real username from /etc/passwd. */
4809                 if (p)
4810                         *username = p->pw_name;
4811         } else {
4812                 errno = 0;
4813                 p = getpwnam(*username);
4814         }
4815
4816         if (!p)
4817                 return errno != 0 ? -errno : -ESRCH;
4818
4819         if (uid)
4820                 *uid = p->pw_uid;
4821
4822         if (gid)
4823                 *gid = p->pw_gid;
4824
4825         if (home)
4826                 *home = p->pw_dir;
4827
4828         return 0;
4829 }
4830
4831 int get_group_creds(const char **groupname, gid_t *gid) {
4832         struct group *g;
4833         gid_t id;
4834
4835         assert(groupname);
4836
4837         /* We enforce some special rules for gid=0: in order to avoid
4838          * NSS lookups for root we hardcode its data. */
4839
4840         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4841                 *groupname = "root";
4842
4843                 if (gid)
4844                         *gid = 0;
4845
4846                 return 0;
4847         }
4848
4849         if (parse_gid(*groupname, &id) >= 0) {
4850                 errno = 0;
4851                 g = getgrgid(id);
4852
4853                 if (g)
4854                         *groupname = g->gr_name;
4855         } else {
4856                 errno = 0;
4857                 g = getgrnam(*groupname);
4858         }
4859
4860         if (!g)
4861                 return errno != 0 ? -errno : -ESRCH;
4862
4863         if (gid)
4864                 *gid = g->gr_gid;
4865
4866         return 0;
4867 }
4868
4869 int in_group(const char *name) {
4870         gid_t gid, *gids;
4871         int ngroups_max, r, i;
4872
4873         r = get_group_creds(&name, &gid);
4874         if (r < 0)
4875                 return r;
4876
4877         if (getgid() == gid)
4878                 return 1;
4879
4880         if (getegid() == gid)
4881                 return 1;
4882
4883         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4884         assert(ngroups_max > 0);
4885
4886         gids = alloca(sizeof(gid_t) * ngroups_max);
4887
4888         r = getgroups(ngroups_max, gids);
4889         if (r < 0)
4890                 return -errno;
4891
4892         for (i = 0; i < r; i++)
4893                 if (gids[i] == gid)
4894                         return 1;
4895
4896         return 0;
4897 }
4898
4899 int glob_exists(const char *path) {
4900         glob_t g;
4901         int r, k;
4902
4903         assert(path);
4904
4905         zero(g);
4906         errno = 0;
4907         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4908
4909         if (k == GLOB_NOMATCH)
4910                 r = 0;
4911         else if (k == GLOB_NOSPACE)
4912                 r = -ENOMEM;
4913         else if (k == 0)
4914                 r = !strv_isempty(g.gl_pathv);
4915         else
4916                 r = errno ? -errno : -EIO;
4917
4918         globfree(&g);
4919
4920         return r;
4921 }
4922
4923 int dirent_ensure_type(DIR *d, struct dirent *de) {
4924         struct stat st;
4925
4926         assert(d);
4927         assert(de);
4928
4929         if (de->d_type != DT_UNKNOWN)
4930                 return 0;
4931
4932         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4933                 return -errno;
4934
4935         de->d_type =
4936                 S_ISREG(st.st_mode)  ? DT_REG  :
4937                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4938                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4939                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4940                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4941                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4942                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4943                                        DT_UNKNOWN;
4944
4945         return 0;
4946 }
4947
4948 int in_search_path(const char *path, char **search) {
4949         char **i, *parent;
4950         int r;
4951
4952         r = path_get_parent(path, &parent);
4953         if (r < 0)
4954                 return r;
4955
4956         r = 0;
4957
4958         STRV_FOREACH(i, search) {
4959                 if (path_equal(parent, *i)) {
4960                         r = 1;
4961                         break;
4962                 }
4963         }
4964
4965         free(parent);
4966
4967         return r;
4968 }
4969
4970 int get_files_in_directory(const char *path, char ***list) {
4971         DIR *d;
4972         int r = 0;
4973         unsigned n = 0;
4974         char **l = NULL;
4975
4976         assert(path);
4977
4978         /* Returns all files in a directory in *list, and the number
4979          * of files as return value. If list is NULL returns only the
4980          * number */
4981
4982         d = opendir(path);
4983         if (!d)
4984                 return -errno;
4985
4986         for (;;) {
4987                 struct dirent buffer, *de;
4988                 int k;
4989
4990                 k = readdir_r(d, &buffer, &de);
4991                 if (k != 0) {
4992                         r = -k;
4993                         goto finish;
4994                 }
4995
4996                 if (!de)
4997                         break;
4998
4999                 dirent_ensure_type(d, de);
5000
5001                 if (!dirent_is_file(de))
5002                         continue;
5003
5004                 if (list) {
5005                         if ((unsigned) r >= n) {
5006                                 char **t;
5007
5008                                 n = MAX(16, 2*r);
5009                                 t = realloc(l, sizeof(char*) * n);
5010                                 if (!t) {
5011                                         r = -ENOMEM;
5012                                         goto finish;
5013                                 }
5014
5015                                 l = t;
5016                         }
5017
5018                         assert((unsigned) r < n);
5019
5020                         l[r] = strdup(de->d_name);
5021                         if (!l[r]) {
5022                                 r = -ENOMEM;
5023                                 goto finish;
5024                         }
5025
5026                         l[++r] = NULL;
5027                 } else
5028                         r++;
5029         }
5030
5031 finish:
5032         if (d)
5033                 closedir(d);
5034
5035         if (r >= 0) {
5036                 if (list)
5037                         *list = l;
5038         } else
5039                 strv_free(l);
5040
5041         return r;
5042 }
5043
5044 char *join(const char *x, ...) {
5045         va_list ap;
5046         size_t l;
5047         char *r, *p;
5048
5049         va_start(ap, x);
5050
5051         if (x) {
5052                 l = strlen(x);
5053
5054                 for (;;) {
5055                         const char *t;
5056
5057                         t = va_arg(ap, const char *);
5058                         if (!t)
5059                                 break;
5060
5061                         l += strlen(t);
5062                 }
5063         } else
5064                 l = 0;
5065
5066         va_end(ap);
5067
5068         r = new(char, l+1);
5069         if (!r)
5070                 return NULL;
5071
5072         if (x) {
5073                 p = stpcpy(r, x);
5074
5075                 va_start(ap, x);
5076
5077                 for (;;) {
5078                         const char *t;
5079
5080                         t = va_arg(ap, const char *);
5081                         if (!t)
5082                                 break;
5083
5084                         p = stpcpy(p, t);
5085                 }
5086
5087                 va_end(ap);
5088         } else
5089                 r[0] = 0;
5090
5091         return r;
5092 }
5093
5094 bool is_main_thread(void) {
5095         static __thread int cached = 0;
5096
5097         if (_unlikely_(cached == 0))
5098                 cached = getpid() == gettid() ? 1 : -1;
5099
5100         return cached > 0;
5101 }
5102
5103 int block_get_whole_disk(dev_t d, dev_t *ret) {
5104         char *p, *s;
5105         int r;
5106         unsigned n, m;
5107
5108         assert(ret);
5109
5110         /* If it has a queue this is good enough for us */
5111         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
5112                 return -ENOMEM;
5113
5114         r = access(p, F_OK);
5115         free(p);
5116
5117         if (r >= 0) {
5118                 *ret = d;
5119                 return 0;
5120         }
5121
5122         /* If it is a partition find the originating device */
5123         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
5124                 return -ENOMEM;
5125
5126         r = access(p, F_OK);
5127         free(p);
5128
5129         if (r < 0)
5130                 return -ENOENT;
5131
5132         /* Get parent dev_t */
5133         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
5134                 return -ENOMEM;
5135
5136         r = read_one_line_file(p, &s);
5137         free(p);
5138
5139         if (r < 0)
5140                 return r;
5141
5142         r = sscanf(s, "%u:%u", &m, &n);
5143         free(s);
5144
5145         if (r != 2)
5146                 return -EINVAL;
5147
5148         /* Only return this if it is really good enough for us. */
5149         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
5150                 return -ENOMEM;
5151
5152         r = access(p, F_OK);
5153         free(p);
5154
5155         if (r >= 0) {
5156                 *ret = makedev(m, n);
5157                 return 0;
5158         }
5159
5160         return -ENOENT;
5161 }
5162
5163 int file_is_priv_sticky(const char *p) {
5164         struct stat st;
5165
5166         assert(p);
5167
5168         if (lstat(p, &st) < 0)
5169                 return -errno;
5170
5171         return
5172                 (st.st_uid == 0 || st.st_uid == getuid()) &&
5173                 (st.st_mode & S_ISVTX);
5174 }
5175
5176 static const char *const ioprio_class_table[] = {
5177         [IOPRIO_CLASS_NONE] = "none",
5178         [IOPRIO_CLASS_RT] = "realtime",
5179         [IOPRIO_CLASS_BE] = "best-effort",
5180         [IOPRIO_CLASS_IDLE] = "idle"
5181 };
5182
5183 DEFINE_STRING_TABLE_LOOKUP(ioprio_class, int);
5184
5185 static const char *const sigchld_code_table[] = {
5186         [CLD_EXITED] = "exited",
5187         [CLD_KILLED] = "killed",
5188         [CLD_DUMPED] = "dumped",
5189         [CLD_TRAPPED] = "trapped",
5190         [CLD_STOPPED] = "stopped",
5191         [CLD_CONTINUED] = "continued",
5192 };
5193
5194 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
5195
5196 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
5197         [LOG_FAC(LOG_KERN)] = "kern",
5198         [LOG_FAC(LOG_USER)] = "user",
5199         [LOG_FAC(LOG_MAIL)] = "mail",
5200         [LOG_FAC(LOG_DAEMON)] = "daemon",
5201         [LOG_FAC(LOG_AUTH)] = "auth",
5202         [LOG_FAC(LOG_SYSLOG)] = "syslog",
5203         [LOG_FAC(LOG_LPR)] = "lpr",
5204         [LOG_FAC(LOG_NEWS)] = "news",
5205         [LOG_FAC(LOG_UUCP)] = "uucp",
5206         [LOG_FAC(LOG_CRON)] = "cron",
5207         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5208         [LOG_FAC(LOG_FTP)] = "ftp",
5209         [LOG_FAC(LOG_LOCAL0)] = "local0",
5210         [LOG_FAC(LOG_LOCAL1)] = "local1",
5211         [LOG_FAC(LOG_LOCAL2)] = "local2",
5212         [LOG_FAC(LOG_LOCAL3)] = "local3",
5213         [LOG_FAC(LOG_LOCAL4)] = "local4",
5214         [LOG_FAC(LOG_LOCAL5)] = "local5",
5215         [LOG_FAC(LOG_LOCAL6)] = "local6",
5216         [LOG_FAC(LOG_LOCAL7)] = "local7"
5217 };
5218
5219 DEFINE_STRING_TABLE_LOOKUP(log_facility_unshifted, int);
5220
5221 static const char *const log_level_table[] = {
5222         [LOG_EMERG] = "emerg",
5223         [LOG_ALERT] = "alert",
5224         [LOG_CRIT] = "crit",
5225         [LOG_ERR] = "err",
5226         [LOG_WARNING] = "warning",
5227         [LOG_NOTICE] = "notice",
5228         [LOG_INFO] = "info",
5229         [LOG_DEBUG] = "debug"
5230 };
5231
5232 DEFINE_STRING_TABLE_LOOKUP(log_level, int);
5233
5234 static const char* const sched_policy_table[] = {
5235         [SCHED_OTHER] = "other",
5236         [SCHED_BATCH] = "batch",
5237         [SCHED_IDLE] = "idle",
5238         [SCHED_FIFO] = "fifo",
5239         [SCHED_RR] = "rr"
5240 };
5241
5242 DEFINE_STRING_TABLE_LOOKUP(sched_policy, int);
5243
5244 static const char* const rlimit_table[] = {
5245         [RLIMIT_CPU] = "LimitCPU",
5246         [RLIMIT_FSIZE] = "LimitFSIZE",
5247         [RLIMIT_DATA] = "LimitDATA",
5248         [RLIMIT_STACK] = "LimitSTACK",
5249         [RLIMIT_CORE] = "LimitCORE",
5250         [RLIMIT_RSS] = "LimitRSS",
5251         [RLIMIT_NOFILE] = "LimitNOFILE",
5252         [RLIMIT_AS] = "LimitAS",
5253         [RLIMIT_NPROC] = "LimitNPROC",
5254         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5255         [RLIMIT_LOCKS] = "LimitLOCKS",
5256         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5257         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5258         [RLIMIT_NICE] = "LimitNICE",
5259         [RLIMIT_RTPRIO] = "LimitRTPRIO",
5260         [RLIMIT_RTTIME] = "LimitRTTIME"
5261 };
5262
5263 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5264
5265 static const char* const ip_tos_table[] = {
5266         [IPTOS_LOWDELAY] = "low-delay",
5267         [IPTOS_THROUGHPUT] = "throughput",
5268         [IPTOS_RELIABILITY] = "reliability",
5269         [IPTOS_LOWCOST] = "low-cost",
5270 };
5271
5272 DEFINE_STRING_TABLE_LOOKUP(ip_tos, int);
5273
5274 static const char *const __signal_table[] = {
5275         [SIGHUP] = "HUP",
5276         [SIGINT] = "INT",
5277         [SIGQUIT] = "QUIT",
5278         [SIGILL] = "ILL",
5279         [SIGTRAP] = "TRAP",
5280         [SIGABRT] = "ABRT",
5281         [SIGBUS] = "BUS",
5282         [SIGFPE] = "FPE",
5283         [SIGKILL] = "KILL",
5284         [SIGUSR1] = "USR1",
5285         [SIGSEGV] = "SEGV",
5286         [SIGUSR2] = "USR2",
5287         [SIGPIPE] = "PIPE",
5288         [SIGALRM] = "ALRM",
5289         [SIGTERM] = "TERM",
5290 #ifdef SIGSTKFLT
5291         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
5292 #endif
5293         [SIGCHLD] = "CHLD",
5294         [SIGCONT] = "CONT",
5295         [SIGSTOP] = "STOP",
5296         [SIGTSTP] = "TSTP",
5297         [SIGTTIN] = "TTIN",
5298         [SIGTTOU] = "TTOU",
5299         [SIGURG] = "URG",
5300         [SIGXCPU] = "XCPU",
5301         [SIGXFSZ] = "XFSZ",
5302         [SIGVTALRM] = "VTALRM",
5303         [SIGPROF] = "PROF",
5304         [SIGWINCH] = "WINCH",
5305         [SIGIO] = "IO",
5306         [SIGPWR] = "PWR",
5307         [SIGSYS] = "SYS"
5308 };
5309
5310 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5311
5312 const char *signal_to_string(int signo) {
5313         static __thread char buf[12];
5314         const char *name;
5315
5316         name = __signal_to_string(signo);
5317         if (name)
5318                 return name;
5319
5320         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5321                 snprintf(buf, sizeof(buf) - 1, "RTMIN+%d", signo - SIGRTMIN);
5322         else
5323                 snprintf(buf, sizeof(buf) - 1, "%d", signo);
5324         char_array_0(buf);
5325         return buf;
5326 }
5327
5328 int signal_from_string(const char *s) {
5329         int signo;
5330         int offset = 0;
5331         unsigned u;
5332
5333         signo =__signal_from_string(s);
5334         if (signo > 0)
5335                 return signo;
5336
5337         if (startswith(s, "RTMIN+")) {
5338                 s += 6;
5339                 offset = SIGRTMIN;
5340         }
5341         if (safe_atou(s, &u) >= 0) {
5342                 signo = (int) u + offset;
5343                 if (signo > 0 && signo < _NSIG)
5344                         return signo;
5345         }
5346         return -1;
5347 }
5348
5349 bool kexec_loaded(void) {
5350        bool loaded = false;
5351        char *s;
5352
5353        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5354                if (s[0] == '1')
5355                        loaded = true;
5356                free(s);
5357        }
5358        return loaded;
5359 }
5360
5361 int strdup_or_null(const char *a, char **b) {
5362         char *c;
5363
5364         assert(b);
5365
5366         if (!a) {
5367                 *b = NULL;
5368                 return 0;
5369         }
5370
5371         c = strdup(a);
5372         if (!c)
5373                 return -ENOMEM;
5374
5375         *b = c;
5376         return 0;
5377 }
5378
5379 int prot_from_flags(int flags) {
5380
5381         switch (flags & O_ACCMODE) {
5382
5383         case O_RDONLY:
5384                 return PROT_READ;
5385
5386         case O_WRONLY:
5387                 return PROT_WRITE;
5388
5389         case O_RDWR:
5390                 return PROT_READ|PROT_WRITE;
5391
5392         default:
5393                 return -EINVAL;
5394         }
5395 }
5396
5397 char *format_bytes(char *buf, size_t l, off_t t) {
5398         unsigned i;
5399
5400         static const struct {
5401                 const char *suffix;
5402                 off_t factor;
5403         } table[] = {
5404                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5405                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5406                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5407                 { "G", 1024ULL*1024ULL*1024ULL },
5408                 { "M", 1024ULL*1024ULL },
5409                 { "K", 1024ULL },
5410         };
5411
5412         for (i = 0; i < ELEMENTSOF(table); i++) {
5413
5414                 if (t >= table[i].factor) {
5415                         snprintf(buf, l,
5416                                  "%llu.%llu%s",
5417                                  (unsigned long long) (t / table[i].factor),
5418                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5419                                  table[i].suffix);
5420
5421                         goto finish;
5422                 }
5423         }
5424
5425         snprintf(buf, l, "%lluB", (unsigned long long) t);
5426
5427 finish:
5428         buf[l-1] = 0;
5429         return buf;
5430
5431 }
5432
5433 void* memdup(const void *p, size_t l) {
5434         void *r;
5435
5436         assert(p);
5437
5438         r = malloc(l);
5439         if (!r)
5440                 return NULL;
5441
5442         memcpy(r, p, l);
5443         return r;
5444 }
5445
5446 int fd_inc_sndbuf(int fd, size_t n) {
5447         int r, value;
5448         socklen_t l = sizeof(value);
5449
5450         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5451         if (r >= 0 &&
5452             l == sizeof(value) &&
5453             (size_t) value >= n*2)
5454                 return 0;
5455
5456         value = (int) n;
5457         r = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value));
5458         if (r < 0)
5459                 return -errno;
5460
5461         return 1;
5462 }
5463
5464 int fd_inc_rcvbuf(int fd, size_t n) {
5465         int r, value;
5466         socklen_t l = sizeof(value);
5467
5468         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5469         if (r >= 0 &&
5470             l == sizeof(value) &&
5471             (size_t) value >= n*2)
5472                 return 0;
5473
5474         value = (int) n;
5475         r = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
5476         if (r < 0)
5477                 return -errno;
5478
5479         return 1;
5480 }
5481
5482 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5483         pid_t parent_pid, agent_pid;
5484         int fd;
5485         bool stdout_is_tty, stderr_is_tty;
5486         unsigned n, i;
5487         va_list ap;
5488         char **l;
5489
5490         assert(pid);
5491         assert(path);
5492
5493         parent_pid = getpid();
5494
5495         /* Spawns a temporary TTY agent, making sure it goes away when
5496          * we go away */
5497
5498         agent_pid = fork();
5499         if (agent_pid < 0)
5500                 return -errno;
5501
5502         if (agent_pid != 0) {
5503                 *pid = agent_pid;
5504                 return 0;
5505         }
5506
5507         /* In the child:
5508          *
5509          * Make sure the agent goes away when the parent dies */
5510         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5511                 _exit(EXIT_FAILURE);
5512
5513         /* Check whether our parent died before we were able
5514          * to set the death signal */
5515         if (getppid() != parent_pid)
5516                 _exit(EXIT_SUCCESS);
5517
5518         /* Don't leak fds to the agent */
5519         close_all_fds(except, n_except);
5520
5521         stdout_is_tty = isatty(STDOUT_FILENO);
5522         stderr_is_tty = isatty(STDERR_FILENO);
5523
5524         if (!stdout_is_tty || !stderr_is_tty) {
5525                 /* Detach from stdout/stderr. and reopen
5526                  * /dev/tty for them. This is important to
5527                  * ensure that when systemctl is started via
5528                  * popen() or a similar call that expects to
5529                  * read EOF we actually do generate EOF and
5530                  * not delay this indefinitely by because we
5531                  * keep an unused copy of stdin around. */
5532                 fd = open("/dev/tty", O_WRONLY);
5533                 if (fd < 0) {
5534                         log_error("Failed to open /dev/tty: %m");
5535                         _exit(EXIT_FAILURE);
5536                 }
5537
5538                 if (!stdout_is_tty)
5539                         dup2(fd, STDOUT_FILENO);
5540
5541                 if (!stderr_is_tty)
5542                         dup2(fd, STDERR_FILENO);
5543
5544                 if (fd > 2)
5545                         close(fd);
5546         }
5547
5548         /* Count arguments */
5549         va_start(ap, path);
5550         for (n = 0; va_arg(ap, char*); n++)
5551                 ;
5552         va_end(ap);
5553
5554         /* Allocate strv */
5555         l = alloca(sizeof(char *) * (n + 1));
5556
5557         /* Fill in arguments */
5558         va_start(ap, path);
5559         for (i = 0; i <= n; i++)
5560                 l[i] = va_arg(ap, char*);
5561         va_end(ap);
5562
5563         execv(path, l);
5564         _exit(EXIT_FAILURE);
5565 }
5566
5567 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5568         struct rlimit highest, fixed;
5569
5570         assert(rlim);
5571
5572         if (setrlimit(resource, rlim) >= 0)
5573                 return 0;
5574
5575         if (errno != EPERM)
5576                 return -errno;
5577
5578         /* So we failed to set the desired setrlimit, then let's try
5579          * to get as close as we can */
5580         assert_se(getrlimit(resource, &highest) == 0);
5581
5582         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5583         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5584
5585         if (setrlimit(resource, &fixed) < 0)
5586                 return -errno;
5587
5588         return 0;
5589 }
5590
5591 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5592         char path[sizeof("/proc/")-1+10+sizeof("/environ")], *value = NULL;
5593         int r;
5594         FILE *f;
5595         bool done = false;
5596         size_t l;
5597
5598         assert(field);
5599         assert(_value);
5600
5601         if (pid == 0)
5602                 pid = getpid();
5603
5604         snprintf(path, sizeof(path), "/proc/%lu/environ", (unsigned long) pid);
5605         char_array_0(path);
5606
5607         f = fopen(path, "re");
5608         if (!f)
5609                 return -errno;
5610
5611         l = strlen(field);
5612         r = 0;
5613
5614         do {
5615                 char line[LINE_MAX];
5616                 unsigned i;
5617
5618                 for (i = 0; i < sizeof(line)-1; i++) {
5619                         int c;
5620
5621                         c = getc(f);
5622                         if (_unlikely_(c == EOF)) {
5623                                 done = true;
5624                                 break;
5625                         } else if (c == 0)
5626                                 break;
5627
5628                         line[i] = c;
5629                 }
5630                 line[i] = 0;
5631
5632                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5633                         value = strdup(line + l + 1);
5634                         if (!value) {
5635                                 r = -ENOMEM;
5636                                 break;
5637                         }
5638
5639                         r = 1;
5640                         break;
5641                 }
5642
5643         } while (!done);
5644
5645         fclose(f);
5646
5647         if (r >= 0)
5648                 *_value = value;
5649
5650         return r;
5651 }
5652
5653 int can_sleep(const char *type) {
5654         char *p, *w, *state;
5655         size_t l, k;
5656         bool found = false;
5657         int r;
5658
5659         assert(type);
5660
5661         r = read_one_line_file("/sys/power/state", &p);
5662         if (r < 0)
5663                 return r == -ENOENT ? 0 : r;
5664
5665         k = strlen(type);
5666
5667         FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state) {
5668                 if (l == k && strncmp(w, type, l) == 0) {
5669                         found = true;
5670                         break;
5671                 }
5672         }
5673
5674         free(p);
5675         return found;
5676 }
5677
5678 bool is_valid_documentation_url(const char *url) {
5679         assert(url);
5680
5681         if (startswith(url, "http://") && url[7])
5682                 return true;
5683
5684         if (startswith(url, "https://") && url[8])
5685                 return true;
5686
5687         if (startswith(url, "file:") && url[5])
5688                 return true;
5689
5690         if (startswith(url, "info:") && url[5])
5691                 return true;
5692
5693         if (startswith(url, "man:") && url[4])
5694                 return true;
5695
5696         return false;
5697 }
5698
5699 bool in_initrd(void) {
5700         static int saved = -1;
5701
5702         if (saved < 0)
5703                 saved = access("/etc/initrd-release", F_OK) >= 0;
5704
5705         return saved;
5706 }
5707
5708 void warn_melody(void) {
5709         int fd;
5710
5711         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5712         if (fd < 0)
5713                 return;
5714
5715         /* Yeah, this is synchronous. Kinda sucks. Bute well... */
5716
5717         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5718         usleep(125*USEC_PER_MSEC);
5719
5720         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5721         usleep(125*USEC_PER_MSEC);
5722
5723         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5724         usleep(125*USEC_PER_MSEC);
5725
5726         ioctl(fd, KIOCSOUND, 0);
5727         close_nointr_nofail(fd);
5728 }