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 <ctype.h>
  45 #include <sys/prctl.h>
  46 #include <sys/utsname.h>
  47 #include <pwd.h>
  48 #include <netinet/ip.h>
  49 #include <linux/kd.h>
  50 #include <dlfcn.h>
  51 #include <sys/wait.h>
  52 #include <sys/time.h>
  53 #include <glob.h>
  54 #include <grp.h>
  55 #include <sys/mman.h>
  56 #include <sys/vfs.h>
  57 #include <sys/mount.h>
  58 #include <linux/magic.h>
  59 #include <limits.h>
  60 #include <langinfo.h>
  61 #include <locale.h>
  62 #include <sys/personality.h>
  63 #include <libgen.h>
  64 #undef basename
  65
  66 #ifdef HAVE_SYS_AUXV_H
  67 #include <sys/auxv.h>
  68 #endif
  69
  70 #include "macro.h"
  71 #include "util.h"
  72 #include "ioprio.h"
  73 #include "missing.h"
  74 #include "log.h"
  75 #include "strv.h"
  76 #include "label.h"
  77 #include "mkdir.h"
  78 #include "path-util.h"
  79 #include "exit-status.h"
  80 #include "hashmap.h"
  81 #include "env-util.h"
  82 #include "fileio.h"
  83 #include "device-nodes.h"
  84 #include "utf8.h"
  85 #include "gunicode.h"
  86 #include "virt.h"
  87 #include "def.h"
  88
  89 int saved_argc = 0;
  90 char **saved_argv = NULL;
  91
  92 static volatile unsigned cached_columns = 0;
  93 static volatile unsigned cached_lines = 0;
  94
  95 size_t page_size(void) {
  96         static thread_local size_t pgsz = 0;
  97         long r;
  98
  99         if (_likely_(pgsz > 0))
 100                 return pgsz;
 101
 102         r = sysconf(_SC_PAGESIZE);
 103         assert(r > 0);
 104
 105         pgsz = (size_t) r;
 106         return pgsz;
 107 }
 108
 109 bool streq_ptr(const char *a, const char *b) {
 110
 111         /* Like streq(), but tries to make sense of NULL pointers */
 112
 113         if (a && b)
 114                 return streq(a, b);
 115
 116         if (!a && !b)
 117                 return true;
 118
 119         return false;
 120 }
 121
 122 char* endswith(const char *s, const char *postfix) {
 123         size_t sl, pl;
 124
 125         assert(s);
 126         assert(postfix);
 127
 128         sl = strlen(s);
 129         pl = strlen(postfix);
 130
 131         if (pl == 0)
 132                 return (char*) s + sl;
 133
 134         if (sl < pl)
 135                 return NULL;
 136
 137         if (memcmp(s + sl - pl, postfix, pl) != 0)
 138                 return NULL;
 139
 140         return (char*) s + sl - pl;
 141 }
 142
 143 bool first_word(const char *s, const char *word) {
 144         size_t sl, wl;
 145
 146         assert(s);
 147         assert(word);
 148
 149         sl = strlen(s);
 150         wl = strlen(word);
 151
 152         if (sl < wl)
 153                 return false;
 154
 155         if (wl == 0)
 156                 return true;
 157
 158         if (memcmp(s, word, wl) != 0)
 159                 return false;
 160
 161         return s[wl] == 0 ||
 162                 strchr(WHITESPACE, s[wl]);
 163 }
 164
 165 int close_nointr(int fd) {
 166         int r;
 167
 168         assert(fd >= 0);
 169         r = close(fd);
 170         if (r >= 0)
 171                 return r;
 172         else if (errno == EINTR)
 173                 /*
 174                  * Just ignore EINTR; a retry loop is the wrong
 175                  * thing to do on Linux.
 176                  *
 177                  * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
 178                  * https://bugzilla.gnome.org/show_bug.cgi?id=682819
 179                  * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
 180                  * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
 181                  */
 182                 return 0;
 183         else
 184                 return -errno;
 185 }
 186
 187 int safe_close(int fd) {
 188
 189         /*
 190          * Like close_nointr() but cannot fail. Guarantees errno is
 191          * unchanged. Is a NOP with negative fds passed, and returns
 192          * -1, so that it can be used in this syntax:
 193          *
 194          * fd = safe_close(fd);
 195          */
 196
 197         if (fd >= 0) {
 198                 PROTECT_ERRNO;
 199
 200                 /* The kernel might return pretty much any error code
 201                  * via close(), but the fd will be closed anyway. The
 202                  * only condition we want to check for here is whether
 203                  * the fd was invalid at all... */
 204
 205                 assert_se(close_nointr(fd) != -EBADF);
 206         }
 207
 208         return -1;
 209 }
 210
 211 void close_many(const int fds[], unsigned n_fd) {
 212         unsigned i;
 213
 214         assert(fds || n_fd <= 0);
 215
 216         for (i = 0; i < n_fd; i++)
 217                 safe_close(fds[i]);
 218 }
 219
 220 int unlink_noerrno(const char *path) {
 221         PROTECT_ERRNO;
 222         int r;
 223
 224         r = unlink(path);
 225         if (r < 0)
 226                 return -errno;
 227
 228         return 0;
 229 }
 230
 231 int parse_boolean(const char *v) {
 232         assert(v);
 233
 234         if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
 235                 return 1;
 236         else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
 237                 return 0;
 238
 239         return -EINVAL;
 240 }
 241
 242 int parse_pid(const char *s, pid_t* ret_pid) {
 243         unsigned long ul = 0;
 244         pid_t pid;
 245         int r;
 246
 247         assert(s);
 248         assert(ret_pid);
 249
 250         r = safe_atolu(s, &ul);
 251         if (r < 0)
 252                 return r;
 253
 254         pid = (pid_t) ul;
 255
 256         if ((unsigned long) pid != ul)
 257                 return -ERANGE;
 258
 259         if (pid <= 0)
 260                 return -ERANGE;
 261
 262         *ret_pid = pid;
 263         return 0;
 264 }
 265
 266 int parse_uid(const char *s, uid_t* ret_uid) {
 267         unsigned long ul = 0;
 268         uid_t uid;
 269         int r;
 270
 271         assert(s);
 272         assert(ret_uid);
 273
 274         r = safe_atolu(s, &ul);
 275         if (r < 0)
 276                 return r;
 277
 278         uid = (uid_t) ul;
 279
 280         if ((unsigned long) uid != ul)
 281                 return -ERANGE;
 282
 283         /* Some libc APIs use (uid_t) -1 as special placeholder */
 284         if (uid == (uid_t) 0xFFFFFFFF)
 285                 return -ENXIO;
 286
 287         /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
 288         if (uid == (uid_t) 0xFFFF)
 289                 return -ENXIO;
 290
 291         *ret_uid = uid;
 292         return 0;
 293 }
 294
 295 int safe_atou(const char *s, unsigned *ret_u) {
 296         char *x = NULL;
 297         unsigned long l;
 298
 299         assert(s);
 300         assert(ret_u);
 301
 302         errno = 0;
 303         l = strtoul(s, &x, 0);
 304
 305         if (!x || x == s || *x || errno)
 306                 return errno > 0 ? -errno : -EINVAL;
 307
 308         if ((unsigned long) (unsigned) l != l)
 309                 return -ERANGE;
 310
 311         *ret_u = (unsigned) l;
 312         return 0;
 313 }
 314
 315 int safe_atoi(const char *s, int *ret_i) {
 316         char *x = NULL;
 317         long l;
 318
 319         assert(s);
 320         assert(ret_i);
 321
 322         errno = 0;
 323         l = strtol(s, &x, 0);
 324
 325         if (!x || x == s || *x || errno)
 326                 return errno > 0 ? -errno : -EINVAL;
 327
 328         if ((long) (int) l != l)
 329                 return -ERANGE;
 330
 331         *ret_i = (int) l;
 332         return 0;
 333 }
 334
 335 int safe_atou8(const char *s, uint8_t *ret) {
 336         char *x = NULL;
 337         unsigned long l;
 338
 339         assert(s);
 340         assert(ret);
 341
 342         errno = 0;
 343         l = strtoul(s, &x, 0);
 344
 345         if (!x || x == s || *x || errno)
 346                 return errno > 0 ? -errno : -EINVAL;
 347
 348         if ((unsigned long) (uint8_t) l != l)
 349                 return -ERANGE;
 350
 351         *ret = (uint8_t) l;
 352         return 0;
 353 }
 354
 355 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 356         char *x = NULL;
 357         unsigned long long l;
 358
 359         assert(s);
 360         assert(ret_llu);
 361
 362         errno = 0;
 363         l = strtoull(s, &x, 0);
 364
 365         if (!x || x == s || *x || errno)
 366                 return errno ? -errno : -EINVAL;
 367
 368         *ret_llu = l;
 369         return 0;
 370 }
 371
 372 int safe_atolli(const char *s, long long int *ret_lli) {
 373         char *x = NULL;
 374         long long l;
 375
 376         assert(s);
 377         assert(ret_lli);
 378
 379         errno = 0;
 380         l = strtoll(s, &x, 0);
 381
 382         if (!x || x == s || *x || errno)
 383                 return errno ? -errno : -EINVAL;
 384
 385         *ret_lli = l;
 386         return 0;
 387 }
 388
 389 int safe_atod(const char *s, double *ret_d) {
 390         char *x = NULL;
 391         double d = 0;
 392
 393         assert(s);
 394         assert(ret_d);
 395
 396         RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
 397                 errno = 0;
 398                 d = strtod(s, &x);
 399         }
 400
 401         if (!x || x == s || *x || errno)
 402                 return errno ? -errno : -EINVAL;
 403
 404         *ret_d = (double) d;
 405         return 0;
 406 }
 407
 408 static size_t strcspn_escaped(const char *s, const char *reject) {
 409         bool escaped = false;
 410         size_t n;
 411
 412         for (n=0; s[n]; n++) {
 413                 if (escaped)
 414                         escaped = false;
 415                 else if (s[n] == '\\')
 416                         escaped = true;
 417                 else if (strchr(reject, s[n]))
 418                         break;
 419         }
 420         /* if s ends in \, return index of previous char */
 421         return n - escaped;
 422 }
 423
 424 /* Split a string into words. */
 425 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
 426         const char *current;
 427
 428         current = *state;
 429
 430         if (!*current) {
 431                 assert(**state == '\0');
 432                 return NULL;
 433         }
 434
 435         current += strspn(current, separator);
 436         if (!*current) {
 437                 *state = current;
 438                 return NULL;
 439         }
 440
 441         if (quoted && strchr("\'\"", *current)) {
 442                 char quotechars[2] = {*current, '\0'};
 443
 444                 *l = strcspn_escaped(current + 1, quotechars);
 445                 if (current[*l + 1] == '\0' ||
 446                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
 447                         /* right quote missing or garbage at the end*/
 448                         *state = current;
 449                         return NULL;
 450                 }
 451                 assert(current[*l + 1] == quotechars[0]);
 452                 *state = current++ + *l + 2;
 453         } else if (quoted) {
 454                 *l = strcspn_escaped(current, separator);
 455                 *state = current + *l;
 456         } else {
 457                 *l = strcspn(current, separator);
 458                 *state = current + *l;
 459         }
 460
 461         return current;
 462 }
 463
 464 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
 465         int r;
 466         _cleanup_free_ char *line = NULL;
 467         long unsigned ppid;
 468         const char *p;
 469
 470         assert(pid >= 0);
 471         assert(_ppid);
 472
 473         if (pid == 0) {
 474                 *_ppid = getppid();
 475                 return 0;
 476         }
 477
 478         p = procfs_file_alloca(pid, "stat");
 479         r = read_one_line_file(p, &line);
 480         if (r < 0)
 481                 return r;
 482
 483         /* Let's skip the pid and comm fields. The latter is enclosed
 484          * in () but does not escape any () in its value, so let's
 485          * skip over it manually */
 486
 487         p = strrchr(line, ')');
 488         if (!p)
 489                 return -EIO;
 490
 491         p++;
 492
 493         if (sscanf(p, " "
 494                    "%*c "  /* state */
 495                    "%lu ", /* ppid */
 496                    &ppid) != 1)
 497                 return -EIO;
 498
 499         if ((long unsigned) (pid_t) ppid != ppid)
 500                 return -ERANGE;
 501
 502         *_ppid = (pid_t) ppid;
 503
 504         return 0;
 505 }
 506
 507 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
 508         int r;
 509         _cleanup_free_ char *line = NULL;
 510         const char *p;
 511
 512         assert(pid >= 0);
 513         assert(st);
 514
 515         p = procfs_file_alloca(pid, "stat");
 516         r = read_one_line_file(p, &line);
 517         if (r < 0)
 518                 return r;
 519
 520         /* Let's skip the pid and comm fields. The latter is enclosed
 521          * in () but does not escape any () in its value, so let's
 522          * skip over it manually */
 523
 524         p = strrchr(line, ')');
 525         if (!p)
 526                 return -EIO;
 527
 528         p++;
 529
 530         if (sscanf(p, " "
 531                    "%*c "  /* state */
 532                    "%*d "  /* ppid */
 533                    "%*d "  /* pgrp */
 534                    "%*d "  /* session */
 535                    "%*d "  /* tty_nr */
 536                    "%*d "  /* tpgid */
 537                    "%*u "  /* flags */
 538                    "%*u "  /* minflt */
 539                    "%*u "  /* cminflt */
 540                    "%*u "  /* majflt */
 541                    "%*u "  /* cmajflt */
 542                    "%*u "  /* utime */
 543                    "%*u "  /* stime */
 544                    "%*d "  /* cutime */
 545                    "%*d "  /* cstime */
 546                    "%*d "  /* priority */
 547                    "%*d "  /* nice */
 548                    "%*d "  /* num_threads */
 549                    "%*d "  /* itrealvalue */
 550                    "%llu "  /* starttime */,
 551                    st) != 1)
 552                 return -EIO;
 553
 554         return 0;
 555 }
 556
 557 int fchmod_umask(int fd, mode_t m) {
 558         mode_t u;
 559         int r;
 560
 561         u = umask(0777);
 562         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 563         umask(u);
 564
 565         return r;
 566 }
 567
 568 char *truncate_nl(char *s) {
 569         assert(s);
 570
 571         s[strcspn(s, NEWLINE)] = 0;
 572         return s;
 573 }
 574
 575 int get_process_state(pid_t pid) {
 576         const char *p;
 577         char state;
 578         int r;
 579         _cleanup_free_ char *line = NULL;
 580
 581         assert(pid >= 0);
 582
 583         p = procfs_file_alloca(pid, "stat");
 584         r = read_one_line_file(p, &line);
 585         if (r < 0)
 586                 return r;
 587
 588         p = strrchr(line, ')');
 589         if (!p)
 590                 return -EIO;
 591
 592         p++;
 593
 594         if (sscanf(p, " %c", &state) != 1)
 595                 return -EIO;
 596
 597         return (unsigned char) state;
 598 }
 599
 600 int get_process_comm(pid_t pid, char **name) {
 601         const char *p;
 602         int r;
 603
 604         assert(name);
 605         assert(pid >= 0);
 606
 607         p = procfs_file_alloca(pid, "comm");
 608
 609         r = read_one_line_file(p, name);
 610         if (r == -ENOENT)
 611                 return -ESRCH;
 612
 613         return r;
 614 }
 615
 616 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
 617         _cleanup_fclose_ FILE *f = NULL;
 618         char *r = NULL, *k;
 619         const char *p;
 620         int c;
 621
 622         assert(line);
 623         assert(pid >= 0);
 624
 625         p = procfs_file_alloca(pid, "cmdline");
 626
 627         f = fopen(p, "re");
 628         if (!f)
 629                 return -errno;
 630
 631         if (max_length == 0) {
 632                 size_t len = 0, allocated = 0;
 633
 634                 while ((c = getc(f)) != EOF) {
 635
 636                         if (!GREEDY_REALLOC(r, allocated, len+2)) {
 637                                 free(r);
 638                                 return -ENOMEM;
 639                         }
 640
 641                         r[len++] = isprint(c) ? c : ' ';
 642                 }
 643
 644                 if (len > 0)
 645                         r[len-1] = 0;
 646
 647         } else {
 648                 bool space = false;
 649                 size_t left;
 650
 651                 r = new(char, max_length);
 652                 if (!r)
 653                         return -ENOMEM;
 654
 655                 k = r;
 656                 left = max_length;
 657                 while ((c = getc(f)) != EOF) {
 658
 659                         if (isprint(c)) {
 660                                 if (space) {
 661                                         if (left <= 4)
 662                                                 break;
 663
 664                                         *(k++) = ' ';
 665                                         left--;
 666                                         space = false;
 667                                 }
 668
 669                                 if (left <= 4)
 670                                         break;
 671
 672                                 *(k++) = (char) c;
 673                                 left--;
 674                         }  else
 675                                 space = true;
 676                 }
 677
 678                 if (left <= 4) {
 679                         size_t n = MIN(left-1, 3U);
 680                         memcpy(k, "...", n);
 681                         k[n] = 0;
 682                 } else
 683                         *k = 0;
 684         }
 685
 686         /* Kernel threads have no argv[] */
 687         if (r == NULL || r[0] == 0) {
 688                 _cleanup_free_ char *t = NULL;
 689                 int h;
 690
 691                 free(r);
 692
 693                 if (!comm_fallback)
 694                         return -ENOENT;
 695
 696                 h = get_process_comm(pid, &t);
 697                 if (h < 0)
 698                         return h;
 699
 700                 r = strjoin("[", t, "]", NULL);
 701                 if (!r)
 702                         return -ENOMEM;
 703         }
 704
 705         *line = r;
 706         return 0;
 707 }
 708
 709 int is_kernel_thread(pid_t pid) {
 710         const char *p;
 711         size_t count;
 712         char c;
 713         bool eof;
 714         FILE *f;
 715
 716         if (pid == 0)
 717                 return 0;
 718
 719         assert(pid > 0);
 720
 721         p = procfs_file_alloca(pid, "cmdline");
 722         f = fopen(p, "re");
 723         if (!f)
 724                 return -errno;
 725
 726         count = fread(&c, 1, 1, f);
 727         eof = feof(f);
 728         fclose(f);
 729
 730         /* Kernel threads have an empty cmdline */
 731
 732         if (count <= 0)
 733                 return eof ? 1 : -errno;
 734
 735         return 0;
 736 }
 737
 738 int get_process_capeff(pid_t pid, char **capeff) {
 739         const char *p;
 740
 741         assert(capeff);
 742         assert(pid >= 0);
 743
 744         p = procfs_file_alloca(pid, "status");
 745
 746         return get_status_field(p, "\nCapEff:", capeff);
 747 }
 748
 749 int get_process_exe(pid_t pid, char **name) {
 750         const char *p;
 751         char *d;
 752         int r;
 753
 754         assert(pid >= 0);
 755         assert(name);
 756
 757         p = procfs_file_alloca(pid, "exe");
 758
 759         r = readlink_malloc(p, name);
 760         if (r < 0)
 761                 return r == -ENOENT ? -ESRCH : r;
 762
 763         d = endswith(*name, " (deleted)");
 764         if (d)
 765                 *d = '\0';
 766
 767         return 0;
 768 }
 769
 770 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
 771         _cleanup_fclose_ FILE *f = NULL;
 772         char line[LINE_MAX];
 773         const char *p;
 774
 775         assert(field);
 776         assert(uid);
 777
 778         if (pid == 0)
 779                 return getuid();
 780
 781         p = procfs_file_alloca(pid, "status");
 782         f = fopen(p, "re");
 783         if (!f)
 784                 return -errno;
 785
 786         FOREACH_LINE(line, f, return -errno) {
 787                 char *l;
 788
 789                 l = strstrip(line);
 790
 791                 if (startswith(l, field)) {
 792                         l += strlen(field);
 793                         l += strspn(l, WHITESPACE);
 794
 795                         l[strcspn(l, WHITESPACE)] = 0;
 796
 797                         return parse_uid(l, uid);
 798                 }
 799         }
 800
 801         return -EIO;
 802 }
 803
 804 int get_process_uid(pid_t pid, uid_t *uid) {
 805         return get_process_id(pid, "Uid:", uid);
 806 }
 807
 808 int get_process_gid(pid_t pid, gid_t *gid) {
 809         assert_cc(sizeof(uid_t) == sizeof(gid_t));
 810         return get_process_id(pid, "Gid:", gid);
 811 }
 812
 813 char *strnappend(const char *s, const char *suffix, size_t b) {
 814         size_t a;
 815         char *r;
 816
 817         if (!s && !suffix)
 818                 return strdup("");
 819
 820         if (!s)
 821                 return strndup(suffix, b);
 822
 823         if (!suffix)
 824                 return strdup(s);
 825
 826         assert(s);
 827         assert(suffix);
 828
 829         a = strlen(s);
 830         if (b > ((size_t) -1) - a)
 831                 return NULL;
 832
 833         r = new(char, a+b+1);
 834         if (!r)
 835                 return NULL;
 836
 837         memcpy(r, s, a);
 838         memcpy(r+a, suffix, b);
 839         r[a+b] = 0;
 840
 841         return r;
 842 }
 843
 844 char *strappend(const char *s, const char *suffix) {
 845         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
 846 }
 847
 848 int readlinkat_malloc(int fd, const char *p, char **ret) {
 849         size_t l = 100;
 850         int r;
 851
 852         assert(p);
 853         assert(ret);
 854
 855         for (;;) {
 856                 char *c;
 857                 ssize_t n;
 858
 859                 c = new(char, l);
 860                 if (!c)
 861                         return -ENOMEM;
 862
 863                 n = readlinkat(fd, p, c, l-1);
 864                 if (n < 0) {
 865                         r = -errno;
 866                         free(c);
 867                         return r;
 868                 }
 869
 870                 if ((size_t) n < l-1) {
 871                         c[n] = 0;
 872                         *ret = c;
 873                         return 0;
 874                 }
 875
 876                 free(c);
 877                 l *= 2;
 878         }
 879 }
 880
 881 int readlink_malloc(const char *p, char **ret) {
 882         return readlinkat_malloc(AT_FDCWD, p, ret);
 883 }
 884
 885 int readlink_and_make_absolute(const char *p, char **r) {
 886         _cleanup_free_ char *target = NULL;
 887         char *k;
 888         int j;
 889
 890         assert(p);
 891         assert(r);
 892
 893         j = readlink_malloc(p, &target);
 894         if (j < 0)
 895                 return j;
 896
 897         k = file_in_same_dir(p, target);
 898         if (!k)
 899                 return -ENOMEM;
 900
 901         *r = k;
 902         return 0;
 903 }
 904
 905 int readlink_and_canonicalize(const char *p, char **r) {
 906         char *t, *s;
 907         int j;
 908
 909         assert(p);
 910         assert(r);
 911
 912         j = readlink_and_make_absolute(p, &t);
 913         if (j < 0)
 914                 return j;
 915
 916         s = canonicalize_file_name(t);
 917         if (s) {
 918                 free(t);
 919                 *r = s;
 920         } else
 921                 *r = t;
 922
 923         path_kill_slashes(*r);
 924
 925         return 0;
 926 }
 927
 928 int reset_all_signal_handlers(void) {
 929         int sig;
 930
 931         for (sig = 1; sig < _NSIG; sig++) {
 932                 struct sigaction sa = {
 933                         .sa_handler = SIG_DFL,
 934                         .sa_flags = SA_RESTART,
 935                 };
 936
 937                 if (sig == SIGKILL || sig == SIGSTOP)
 938                         continue;
 939
 940                 /* On Linux the first two RT signals are reserved by
 941                  * glibc, and sigaction() will return EINVAL for them. */
 942                 if ((sigaction(sig, &sa, NULL) < 0))
 943                         if (errno != EINVAL)
 944                                 return -errno;
 945         }
 946
 947         return 0;
 948 }
 949
 950 char *strstrip(char *s) {
 951         char *e;
 952
 953         /* Drops trailing whitespace. Modifies the string in
 954          * place. Returns pointer to first non-space character */
 955
 956         s += strspn(s, WHITESPACE);
 957
 958         for (e = strchr(s, 0); e > s; e --)
 959                 if (!strchr(WHITESPACE, e[-1]))
 960                         break;
 961
 962         *e = 0;
 963
 964         return s;
 965 }
 966
 967 char *delete_chars(char *s, const char *bad) {
 968         char *f, *t;
 969
 970         /* Drops all whitespace, regardless where in the string */
 971
 972         for (f = s, t = s; *f; f++) {
 973                 if (strchr(bad, *f))
 974                         continue;
 975
 976                 *(t++) = *f;
 977         }
 978
 979         *t = 0;
 980
 981         return s;
 982 }
 983
 984 char *file_in_same_dir(const char *path, const char *filename) {
 985         char *e, *r;
 986         size_t k;
 987
 988         assert(path);
 989         assert(filename);
 990
 991         /* This removes the last component of path and appends
 992          * filename, unless the latter is absolute anyway or the
 993          * former isn't */
 994
 995         if (path_is_absolute(filename))
 996                 return strdup(filename);
 997
 998         if (!(e = strrchr(path, '/')))
 999                 return strdup(filename);
1000
1001         k = strlen(filename);
1002         if (!(r = new(char, e-path+1+k+1)))
1003                 return NULL;
1004
1005         memcpy(r, path, e-path+1);
1006         memcpy(r+(e-path)+1, filename, k+1);
1007
1008         return r;
1009 }
1010
1011 int rmdir_parents(const char *path, const char *stop) {
1012         size_t l;
1013         int r = 0;
1014
1015         assert(path);
1016         assert(stop);
1017
1018         l = strlen(path);
1019
1020         /* Skip trailing slashes */
1021         while (l > 0 && path[l-1] == '/')
1022                 l--;
1023
1024         while (l > 0) {
1025                 char *t;
1026
1027                 /* Skip last component */
1028                 while (l > 0 && path[l-1] != '/')
1029                         l--;
1030
1031                 /* Skip trailing slashes */
1032                 while (l > 0 && path[l-1] == '/')
1033                         l--;
1034
1035                 if (l <= 0)
1036                         break;
1037
1038                 if (!(t = strndup(path, l)))
1039                         return -ENOMEM;
1040
1041                 if (path_startswith(stop, t)) {
1042                         free(t);
1043                         return 0;
1044                 }
1045
1046                 r = rmdir(t);
1047                 free(t);
1048
1049                 if (r < 0)
1050                         if (errno != ENOENT)
1051                                 return -errno;
1052         }
1053
1054         return 0;
1055 }
1056
1057 char hexchar(int x) {
1058         static const char table[16] = "0123456789abcdef";
1059
1060         return table[x & 15];
1061 }
1062
1063 int unhexchar(char c) {
1064
1065         if (c >= '0' && c <= '9')
1066                 return c - '0';
1067
1068         if (c >= 'a' && c <= 'f')
1069                 return c - 'a' + 10;
1070
1071         if (c >= 'A' && c <= 'F')
1072                 return c - 'A' + 10;
1073
1074         return -1;
1075 }
1076
1077 char *hexmem(const void *p, size_t l) {
1078         char *r, *z;
1079         const uint8_t *x;
1080
1081         z = r = malloc(l * 2 + 1);
1082         if (!r)
1083                 return NULL;
1084
1085         for (x = p; x < (const uint8_t*) p + l; x++) {
1086                 *(z++) = hexchar(*x >> 4);
1087                 *(z++) = hexchar(*x & 15);
1088         }
1089
1090         *z = 0;
1091         return r;
1092 }
1093
1094 void *unhexmem(const char *p, size_t l) {
1095         uint8_t *r, *z;
1096         const char *x;
1097
1098         assert(p);
1099
1100         z = r = malloc((l + 1) / 2 + 1);
1101         if (!r)
1102                 return NULL;
1103
1104         for (x = p; x < p + l; x += 2) {
1105                 int a, b;
1106
1107                 a = unhexchar(x[0]);
1108                 if (x+1 < p + l)
1109                         b = unhexchar(x[1]);
1110                 else
1111                         b = 0;
1112
1113                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1114         }
1115
1116         *z = 0;
1117         return r;
1118 }
1119
1120 char octchar(int x) {
1121         return '0' + (x & 7);
1122 }
1123
1124 int unoctchar(char c) {
1125
1126         if (c >= '0' && c <= '7')
1127                 return c - '0';
1128
1129         return -1;
1130 }
1131
1132 char decchar(int x) {
1133         return '0' + (x % 10);
1134 }
1135
1136 int undecchar(char c) {
1137
1138         if (c >= '0' && c <= '9')
1139                 return c - '0';
1140
1141         return -1;
1142 }
1143
1144 char *cescape(const char *s) {
1145         char *r, *t;
1146         const char *f;
1147
1148         assert(s);
1149
1150         /* Does C style string escaping. */
1151
1152         r = new(char, strlen(s)*4 + 1);
1153         if (!r)
1154                 return NULL;
1155
1156         for (f = s, t = r; *f; f++)
1157
1158                 switch (*f) {
1159
1160                 case '\a':
1161                         *(t++) = '\\';
1162                         *(t++) = 'a';
1163                         break;
1164                 case '\b':
1165                         *(t++) = '\\';
1166                         *(t++) = 'b';
1167                         break;
1168                 case '\f':
1169                         *(t++) = '\\';
1170                         *(t++) = 'f';
1171                         break;
1172                 case '\n':
1173                         *(t++) = '\\';
1174                         *(t++) = 'n';
1175                         break;
1176                 case '\r':
1177                         *(t++) = '\\';
1178                         *(t++) = 'r';
1179                         break;
1180                 case '\t':
1181                         *(t++) = '\\';
1182                         *(t++) = 't';
1183                         break;
1184                 case '\v':
1185                         *(t++) = '\\';
1186                         *(t++) = 'v';
1187                         break;
1188                 case '\\':
1189                         *(t++) = '\\';
1190                         *(t++) = '\\';
1191                         break;
1192                 case '"':
1193                         *(t++) = '\\';
1194                         *(t++) = '"';
1195                         break;
1196                 case '\'':
1197                         *(t++) = '\\';
1198                         *(t++) = '\'';
1199                         break;
1200
1201                 default:
1202                         /* For special chars we prefer octal over
1203                          * hexadecimal encoding, simply because glib's
1204                          * g_strescape() does the same */
1205                         if ((*f < ' ') || (*f >= 127)) {
1206                                 *(t++) = '\\';
1207                                 *(t++) = octchar((unsigned char) *f >> 6);
1208                                 *(t++) = octchar((unsigned char) *f >> 3);
1209                                 *(t++) = octchar((unsigned char) *f);
1210                         } else
1211                                 *(t++) = *f;
1212                         break;
1213                 }
1214
1215         *t = 0;
1216
1217         return r;
1218 }
1219
1220 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1221         char *r, *t;
1222         const char *f;
1223         size_t pl;
1224
1225         assert(s);
1226
1227         /* Undoes C style string escaping, and optionally prefixes it. */
1228
1229         pl = prefix ? strlen(prefix) : 0;
1230
1231         r = new(char, pl+length+1);
1232         if (!r)
1233                 return NULL;
1234
1235         if (prefix)
1236                 memcpy(r, prefix, pl);
1237
1238         for (f = s, t = r + pl; f < s + length; f++) {
1239
1240                 if (*f != '\\') {
1241                         *(t++) = *f;
1242                         continue;
1243                 }
1244
1245                 f++;
1246
1247                 switch (*f) {
1248
1249                 case 'a':
1250                         *(t++) = '\a';
1251                         break;
1252                 case 'b':
1253                         *(t++) = '\b';
1254                         break;
1255                 case 'f':
1256                         *(t++) = '\f';
1257                         break;
1258                 case 'n':
1259                         *(t++) = '\n';
1260                         break;
1261                 case 'r':
1262                         *(t++) = '\r';
1263                         break;
1264                 case 't':
1265                         *(t++) = '\t';
1266                         break;
1267                 case 'v':
1268                         *(t++) = '\v';
1269                         break;
1270                 case '\\':
1271                         *(t++) = '\\';
1272                         break;
1273                 case '"':
1274                         *(t++) = '"';
1275                         break;
1276                 case '\'':
1277                         *(t++) = '\'';
1278                         break;
1279
1280                 case 's':
1281                         /* This is an extension of the XDG syntax files */
1282                         *(t++) = ' ';
1283                         break;
1284
1285                 case 'x': {
1286                         /* hexadecimal encoding */
1287                         int a, b;
1288
1289                         a = unhexchar(f[1]);
1290                         b = unhexchar(f[2]);
1291
1292                         if (a < 0 || b < 0 || (a == 0 && b == 0)) {
1293                                 /* Invalid escape code, let's take it literal then */
1294                                 *(t++) = '\\';
1295                                 *(t++) = 'x';
1296                         } else {
1297                                 *(t++) = (char) ((a << 4) | b);
1298                                 f += 2;
1299                         }
1300
1301                         break;
1302                 }
1303
1304                 case '0':
1305                 case '1':
1306                 case '2':
1307                 case '3':
1308                 case '4':
1309                 case '5':
1310                 case '6':
1311                 case '7': {
1312                         /* octal encoding */
1313                         int a, b, c;
1314
1315                         a = unoctchar(f[0]);
1316                         b = unoctchar(f[1]);
1317                         c = unoctchar(f[2]);
1318
1319                         if (a < 0 || b < 0 || c < 0 || (a == 0 && b == 0 && c == 0)) {
1320                                 /* Invalid escape code, let's take it literal then */
1321                                 *(t++) = '\\';
1322                                 *(t++) = f[0];
1323                         } else {
1324                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1325                                 f += 2;
1326                         }
1327
1328                         break;
1329                 }
1330
1331                 case 0:
1332                         /* premature end of string.*/
1333                         *(t++) = '\\';
1334                         goto finish;
1335
1336                 default:
1337                         /* Invalid escape code, let's take it literal then */
1338                         *(t++) = '\\';
1339                         *(t++) = *f;
1340                         break;
1341                 }
1342         }
1343
1344 finish:
1345         *t = 0;
1346         return r;
1347 }
1348
1349 char *cunescape_length(const char *s, size_t length) {
1350         return cunescape_length_with_prefix(s, length, NULL);
1351 }
1352
1353 char *cunescape(const char *s) {
1354         assert(s);
1355
1356         return cunescape_length(s, strlen(s));
1357 }
1358
1359 char *xescape(const char *s, const char *bad) {
1360         char *r, *t;
1361         const char *f;
1362
1363         /* Escapes all chars in bad, in addition to \ and all special
1364          * chars, in \xFF style escaping. May be reversed with
1365          * cunescape. */
1366
1367         r = new(char, strlen(s) * 4 + 1);
1368         if (!r)
1369                 return NULL;
1370
1371         for (f = s, t = r; *f; f++) {
1372
1373                 if ((*f < ' ') || (*f >= 127) ||
1374                     (*f == '\\') || strchr(bad, *f)) {
1375                         *(t++) = '\\';
1376                         *(t++) = 'x';
1377                         *(t++) = hexchar(*f >> 4);
1378                         *(t++) = hexchar(*f);
1379                 } else
1380                         *(t++) = *f;
1381         }
1382
1383         *t = 0;
1384
1385         return r;
1386 }
1387
1388 char *ascii_strlower(char *t) {
1389         char *p;
1390
1391         assert(t);
1392
1393         for (p = t; *p; p++)
1394                 if (*p >= 'A' && *p <= 'Z')
1395                         *p = *p - 'A' + 'a';
1396
1397         return t;
1398 }
1399
1400 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1401         assert(filename);
1402
1403         return
1404                 filename[0] == '.' ||
1405                 streq(filename, "lost+found") ||
1406                 streq(filename, "aquota.user") ||
1407                 streq(filename, "aquota.group") ||
1408                 endswith(filename, ".rpmnew") ||
1409                 endswith(filename, ".rpmsave") ||
1410                 endswith(filename, ".rpmorig") ||
1411                 endswith(filename, ".dpkg-old") ||
1412                 endswith(filename, ".dpkg-new") ||
1413                 endswith(filename, ".swp");
1414 }
1415
1416 bool ignore_file(const char *filename) {
1417         assert(filename);
1418
1419         if (endswith(filename, "~"))
1420                 return true;
1421
1422         return ignore_file_allow_backup(filename);
1423 }
1424
1425 int fd_nonblock(int fd, bool nonblock) {
1426         int flags, nflags;
1427
1428         assert(fd >= 0);
1429
1430         flags = fcntl(fd, F_GETFL, 0);
1431         if (flags < 0)
1432                 return -errno;
1433
1434         if (nonblock)
1435                 nflags = flags | O_NONBLOCK;
1436         else
1437                 nflags = flags & ~O_NONBLOCK;
1438
1439         if (nflags == flags)
1440                 return 0;
1441
1442         if (fcntl(fd, F_SETFL, nflags) < 0)
1443                 return -errno;
1444
1445         return 0;
1446 }
1447
1448 int fd_cloexec(int fd, bool cloexec) {
1449         int flags, nflags;
1450
1451         assert(fd >= 0);
1452
1453         flags = fcntl(fd, F_GETFD, 0);
1454         if (flags < 0)
1455                 return -errno;
1456
1457         if (cloexec)
1458                 nflags = flags | FD_CLOEXEC;
1459         else
1460                 nflags = flags & ~FD_CLOEXEC;
1461
1462         if (nflags == flags)
1463                 return 0;
1464
1465         if (fcntl(fd, F_SETFD, nflags) < 0)
1466                 return -errno;
1467
1468         return 0;
1469 }
1470
1471 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1472         unsigned i;
1473
1474         assert(n_fdset == 0 || fdset);
1475
1476         for (i = 0; i < n_fdset; i++)
1477                 if (fdset[i] == fd)
1478                         return true;
1479
1480         return false;
1481 }
1482
1483 int close_all_fds(const int except[], unsigned n_except) {
1484         _cleanup_closedir_ DIR *d = NULL;
1485         struct dirent *de;
1486         int r = 0;
1487
1488         assert(n_except == 0 || except);
1489
1490         d = opendir("/proc/self/fd");
1491         if (!d) {
1492                 int fd;
1493                 struct rlimit rl;
1494
1495                 /* When /proc isn't available (for example in chroots)
1496                  * the fallback is brute forcing through the fd
1497                  * table */
1498
1499                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1500                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1501
1502                         if (fd_in_set(fd, except, n_except))
1503                                 continue;
1504
1505                         if (close_nointr(fd) < 0)
1506                                 if (errno != EBADF && r == 0)
1507                                         r = -errno;
1508                 }
1509
1510                 return r;
1511         }
1512
1513         while ((de = readdir(d))) {
1514                 int fd = -1;
1515
1516                 if (ignore_file(de->d_name))
1517                         continue;
1518
1519                 if (safe_atoi(de->d_name, &fd) < 0)
1520                         /* Let's better ignore this, just in case */
1521                         continue;
1522
1523                 if (fd < 3)
1524                         continue;
1525
1526                 if (fd == dirfd(d))
1527                         continue;
1528
1529                 if (fd_in_set(fd, except, n_except))
1530                         continue;
1531
1532                 if (close_nointr(fd) < 0) {
1533                         /* Valgrind has its own FD and doesn't want to have it closed */
1534                         if (errno != EBADF && r == 0)
1535                                 r = -errno;
1536                 }
1537         }
1538
1539         return r;
1540 }
1541
1542 bool chars_intersect(const char *a, const char *b) {
1543         const char *p;
1544
1545         /* Returns true if any of the chars in a are in b. */
1546         for (p = a; *p; p++)
1547                 if (strchr(b, *p))
1548                         return true;
1549
1550         return false;
1551 }
1552
1553 bool fstype_is_network(const char *fstype) {
1554         static const char table[] =
1555                 "cifs\0"
1556                 "smbfs\0"
1557                 "sshfs\0"
1558                 "ncpfs\0"
1559                 "ncp\0"
1560                 "nfs\0"
1561                 "nfs4\0"
1562                 "gfs\0"
1563                 "gfs2\0"
1564                 "glusterfs\0";
1565
1566         const char *x;
1567
1568         x = startswith(fstype, "fuse.");
1569         if (x)
1570                 fstype = x;
1571
1572         return nulstr_contains(table, fstype);
1573 }
1574
1575 int chvt(int vt) {
1576         _cleanup_close_ int fd;
1577
1578         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1579         if (fd < 0)
1580                 return -errno;
1581
1582         if (vt < 0) {
1583                 int tiocl[2] = {
1584                         TIOCL_GETKMSGREDIRECT,
1585                         0
1586                 };
1587
1588                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1589                         return -errno;
1590
1591                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1592         }
1593
1594         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1595                 return -errno;
1596
1597         return 0;
1598 }
1599
1600 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1601         struct termios old_termios, new_termios;
1602         char c, line[LINE_MAX];
1603
1604         assert(f);
1605         assert(ret);
1606
1607         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1608                 new_termios = old_termios;
1609
1610                 new_termios.c_lflag &= ~ICANON;
1611                 new_termios.c_cc[VMIN] = 1;
1612                 new_termios.c_cc[VTIME] = 0;
1613
1614                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1615                         size_t k;
1616
1617                         if (t != USEC_INFINITY) {
1618                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1619                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1620                                         return -ETIMEDOUT;
1621                                 }
1622                         }
1623
1624                         k = fread(&c, 1, 1, f);
1625
1626                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1627
1628                         if (k <= 0)
1629                                 return -EIO;
1630
1631                         if (need_nl)
1632                                 *need_nl = c != '\n';
1633
1634                         *ret = c;
1635                         return 0;
1636                 }
1637         }
1638
1639         if (t != USEC_INFINITY) {
1640                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1641                         return -ETIMEDOUT;
1642         }
1643
1644         errno = 0;
1645         if (!fgets(line, sizeof(line), f))
1646                 return errno ? -errno : -EIO;
1647
1648         truncate_nl(line);
1649
1650         if (strlen(line) != 1)
1651                 return -EBADMSG;
1652
1653         if (need_nl)
1654                 *need_nl = false;
1655
1656         *ret = line[0];
1657         return 0;
1658 }
1659
1660 int ask_char(char *ret, const char *replies, const char *text, ...) {
1661         int r;
1662
1663         assert(ret);
1664         assert(replies);
1665         assert(text);
1666
1667         for (;;) {
1668                 va_list ap;
1669                 char c;
1670                 bool need_nl = true;
1671
1672                 if (on_tty())
1673                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1674
1675                 va_start(ap, text);
1676                 vprintf(text, ap);
1677                 va_end(ap);
1678
1679                 if (on_tty())
1680                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1681
1682                 fflush(stdout);
1683
1684                 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1685                 if (r < 0) {
1686
1687                         if (r == -EBADMSG) {
1688                                 puts("Bad input, please try again.");
1689                                 continue;
1690                         }
1691
1692                         putchar('\n');
1693                         return r;
1694                 }
1695
1696                 if (need_nl)
1697                         putchar('\n');
1698
1699                 if (strchr(replies, c)) {
1700                         *ret = c;
1701                         return 0;
1702                 }
1703
1704                 puts("Read unexpected character, please try again.");
1705         }
1706 }
1707
1708 int ask_string(char **ret, const char *text, ...) {
1709         assert(ret);
1710         assert(text);
1711
1712         for (;;) {
1713                 char line[LINE_MAX];
1714                 va_list ap;
1715
1716                 if (on_tty())
1717                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1718
1719                 va_start(ap, text);
1720                 vprintf(text, ap);
1721                 va_end(ap);
1722
1723                 if (on_tty())
1724                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1725
1726                 fflush(stdout);
1727
1728                 errno = 0;
1729                 if (!fgets(line, sizeof(line), stdin))
1730                         return errno ? -errno : -EIO;
1731
1732                 if (!endswith(line, "\n"))
1733                         putchar('\n');
1734                 else {
1735                         char *s;
1736
1737                         if (isempty(line))
1738                                 continue;
1739
1740                         truncate_nl(line);
1741                         s = strdup(line);
1742                         if (!s)
1743                                 return -ENOMEM;
1744
1745                         *ret = s;
1746                         return 0;
1747                 }
1748         }
1749 }
1750
1751 int reset_terminal_fd(int fd, bool switch_to_text) {
1752         struct termios termios;
1753         int r = 0;
1754
1755         /* Set terminal to some sane defaults */
1756
1757         assert(fd >= 0);
1758
1759         /* We leave locked terminal attributes untouched, so that
1760          * Plymouth may set whatever it wants to set, and we don't
1761          * interfere with that. */
1762
1763         /* Disable exclusive mode, just in case */
1764         ioctl(fd, TIOCNXCL);
1765
1766         /* Switch to text mode */
1767         if (switch_to_text)
1768                 ioctl(fd, KDSETMODE, KD_TEXT);
1769
1770         /* Enable console unicode mode */
1771         ioctl(fd, KDSKBMODE, K_UNICODE);
1772
1773         if (tcgetattr(fd, &termios) < 0) {
1774                 r = -errno;
1775                 goto finish;
1776         }
1777
1778         /* We only reset the stuff that matters to the software. How
1779          * hardware is set up we don't touch assuming that somebody
1780          * else will do that for us */
1781
1782         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1783         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1784         termios.c_oflag |= ONLCR;
1785         termios.c_cflag |= CREAD;
1786         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1787
1788         termios.c_cc[VINTR]    =   03;  /* ^C */
1789         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1790         termios.c_cc[VERASE]   = 0177;
1791         termios.c_cc[VKILL]    =  025;  /* ^X */
1792         termios.c_cc[VEOF]     =   04;  /* ^D */
1793         termios.c_cc[VSTART]   =  021;  /* ^Q */
1794         termios.c_cc[VSTOP]    =  023;  /* ^S */
1795         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1796         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1797         termios.c_cc[VWERASE]  =  027;  /* ^W */
1798         termios.c_cc[VREPRINT] =  022;  /* ^R */
1799         termios.c_cc[VEOL]     =    0;
1800         termios.c_cc[VEOL2]    =    0;
1801
1802         termios.c_cc[VTIME]  = 0;
1803         termios.c_cc[VMIN]   = 1;
1804
1805         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1806                 r = -errno;
1807
1808 finish:
1809         /* Just in case, flush all crap out */
1810         tcflush(fd, TCIOFLUSH);
1811
1812         return r;
1813 }
1814
1815 int reset_terminal(const char *name) {
1816         _cleanup_close_ int fd = -1;
1817
1818         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1819         if (fd < 0)
1820                 return fd;
1821
1822         return reset_terminal_fd(fd, true);
1823 }
1824
1825 int open_terminal(const char *name, int mode) {
1826         int fd, r;
1827         unsigned c = 0;
1828
1829         /*
1830          * If a TTY is in the process of being closed opening it might
1831          * cause EIO. This is horribly awful, but unlikely to be
1832          * changed in the kernel. Hence we work around this problem by
1833          * retrying a couple of times.
1834          *
1835          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1836          */
1837
1838         assert(!(mode & O_CREAT));
1839
1840         for (;;) {
1841                 fd = open(name, mode, 0);
1842                 if (fd >= 0)
1843                         break;
1844
1845                 if (errno != EIO)
1846                         return -errno;
1847
1848                 /* Max 1s in total */
1849                 if (c >= 20)
1850                         return -errno;
1851
1852                 usleep(50 * USEC_PER_MSEC);
1853                 c++;
1854         }
1855
1856         if (fd < 0)
1857                 return -errno;
1858
1859         r = isatty(fd);
1860         if (r < 0) {
1861                 safe_close(fd);
1862                 return -errno;
1863         }
1864
1865         if (!r) {
1866                 safe_close(fd);
1867                 return -ENOTTY;
1868         }
1869
1870         return fd;
1871 }
1872
1873 int flush_fd(int fd) {
1874         struct pollfd pollfd = {
1875                 .fd = fd,
1876                 .events = POLLIN,
1877         };
1878
1879         for (;;) {
1880                 char buf[LINE_MAX];
1881                 ssize_t l;
1882                 int r;
1883
1884                 r = poll(&pollfd, 1, 0);
1885                 if (r < 0) {
1886                         if (errno == EINTR)
1887                                 continue;
1888
1889                         return -errno;
1890
1891                 } else if (r == 0)
1892                         return 0;
1893
1894                 l = read(fd, buf, sizeof(buf));
1895                 if (l < 0) {
1896
1897                         if (errno == EINTR)
1898                                 continue;
1899
1900                         if (errno == EAGAIN)
1901                                 return 0;
1902
1903                         return -errno;
1904                 } else if (l == 0)
1905                         return 0;
1906         }
1907 }
1908
1909 int acquire_terminal(
1910                 const char *name,
1911                 bool fail,
1912                 bool force,
1913                 bool ignore_tiocstty_eperm,
1914                 usec_t timeout) {
1915
1916         int fd = -1, notify = -1, r = 0, wd = -1;
1917         usec_t ts = 0;
1918
1919         assert(name);
1920
1921         /* We use inotify to be notified when the tty is closed. We
1922          * create the watch before checking if we can actually acquire
1923          * it, so that we don't lose any event.
1924          *
1925          * Note: strictly speaking this actually watches for the
1926          * device being closed, it does *not* really watch whether a
1927          * tty loses its controlling process. However, unless some
1928          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1929          * its tty otherwise this will not become a problem. As long
1930          * as the administrator makes sure not configure any service
1931          * on the same tty as an untrusted user this should not be a
1932          * problem. (Which he probably should not do anyway.) */
1933
1934         if (timeout != USEC_INFINITY)
1935                 ts = now(CLOCK_MONOTONIC);
1936
1937         if (!fail && !force) {
1938                 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
1939                 if (notify < 0) {
1940                         r = -errno;
1941                         goto fail;
1942                 }
1943
1944                 wd = inotify_add_watch(notify, name, IN_CLOSE);
1945                 if (wd < 0) {
1946                         r = -errno;
1947                         goto fail;
1948                 }
1949         }
1950
1951         for (;;) {
1952                 struct sigaction sa_old, sa_new = {
1953                         .sa_handler = SIG_IGN,
1954                         .sa_flags = SA_RESTART,
1955                 };
1956
1957                 if (notify >= 0) {
1958                         r = flush_fd(notify);
1959                         if (r < 0)
1960                                 goto fail;
1961                 }
1962
1963                 /* We pass here O_NOCTTY only so that we can check the return
1964                  * value TIOCSCTTY and have a reliable way to figure out if we
1965                  * successfully became the controlling process of the tty */
1966                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1967                 if (fd < 0)
1968                         return fd;
1969
1970                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1971                  * if we already own the tty. */
1972                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1973
1974                 /* First, try to get the tty */
1975                 if (ioctl(fd, TIOCSCTTY, force) < 0)
1976                         r = -errno;
1977
1978                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1979
1980                 /* Sometimes it makes sense to ignore TIOCSCTTY
1981                  * returning EPERM, i.e. when very likely we already
1982                  * are have this controlling terminal. */
1983                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1984                         r = 0;
1985
1986                 if (r < 0 && (force || fail || r != -EPERM)) {
1987                         goto fail;
1988                 }
1989
1990                 if (r >= 0)
1991                         break;
1992
1993                 assert(!fail);
1994                 assert(!force);
1995                 assert(notify >= 0);
1996
1997                 for (;;) {
1998                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1999                         ssize_t l;
2000                         struct inotify_event *e;
2001
2002                         if (timeout != USEC_INFINITY) {
2003                                 usec_t n;
2004
2005                                 n = now(CLOCK_MONOTONIC);
2006                                 if (ts + timeout < n) {
2007                                         r = -ETIMEDOUT;
2008                                         goto fail;
2009                                 }
2010
2011                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2012                                 if (r < 0)
2013                                         goto fail;
2014
2015                                 if (r == 0) {
2016                                         r = -ETIMEDOUT;
2017                                         goto fail;
2018                                 }
2019                         }
2020
2021                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
2022                         if (l < 0) {
2023
2024                                 if (errno == EINTR || errno == EAGAIN)
2025                                         continue;
2026
2027                                 r = -errno;
2028                                 goto fail;
2029                         }
2030
2031                         e = (struct inotify_event*) inotify_buffer;
2032
2033                         while (l > 0) {
2034                                 size_t step;
2035
2036                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2037                                         r = -EIO;
2038                                         goto fail;
2039                                 }
2040
2041                                 step = sizeof(struct inotify_event) + e->len;
2042                                 assert(step <= (size_t) l);
2043
2044                                 e = (struct inotify_event*) ((uint8_t*) e + step);
2045                                 l -= step;
2046                         }
2047
2048                         break;
2049                 }
2050
2051                 /* We close the tty fd here since if the old session
2052                  * ended our handle will be dead. It's important that
2053                  * we do this after sleeping, so that we don't enter
2054                  * an endless loop. */
2055                 safe_close(fd);
2056         }
2057
2058         safe_close(notify);
2059
2060         r = reset_terminal_fd(fd, true);
2061         if (r < 0)
2062                 log_warning("Failed to reset terminal: %s", strerror(-r));
2063
2064         return fd;
2065
2066 fail:
2067         safe_close(fd);
2068         safe_close(notify);
2069
2070         return r;
2071 }
2072
2073 int release_terminal(void) {
2074         int r = 0;
2075         struct sigaction sa_old, sa_new = {
2076                 .sa_handler = SIG_IGN,
2077                 .sa_flags = SA_RESTART,
2078         };
2079         _cleanup_close_ int fd;
2080
2081         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2082         if (fd < 0)
2083                 return -errno;
2084
2085         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2086          * by our own TIOCNOTTY */
2087         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2088
2089         if (ioctl(fd, TIOCNOTTY) < 0)
2090                 r = -errno;
2091
2092         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2093
2094         return r;
2095 }
2096
2097 int sigaction_many(const struct sigaction *sa, ...) {
2098         va_list ap;
2099         int r = 0, sig;
2100
2101         va_start(ap, sa);
2102         while ((sig = va_arg(ap, int)) > 0)
2103                 if (sigaction(sig, sa, NULL) < 0)
2104                         r = -errno;
2105         va_end(ap);
2106
2107         return r;
2108 }
2109
2110 int ignore_signals(int sig, ...) {
2111         struct sigaction sa = {
2112                 .sa_handler = SIG_IGN,
2113                 .sa_flags = SA_RESTART,
2114         };
2115         va_list ap;
2116         int r = 0;
2117
2118         if (sigaction(sig, &sa, NULL) < 0)
2119                 r = -errno;
2120
2121         va_start(ap, sig);
2122         while ((sig = va_arg(ap, int)) > 0)
2123                 if (sigaction(sig, &sa, NULL) < 0)
2124                         r = -errno;
2125         va_end(ap);
2126
2127         return r;
2128 }
2129
2130 int default_signals(int sig, ...) {
2131         struct sigaction sa = {
2132                 .sa_handler = SIG_DFL,
2133                 .sa_flags = SA_RESTART,
2134         };
2135         va_list ap;
2136         int r = 0;
2137
2138         if (sigaction(sig, &sa, NULL) < 0)
2139                 r = -errno;
2140
2141         va_start(ap, sig);
2142         while ((sig = va_arg(ap, int)) > 0)
2143                 if (sigaction(sig, &sa, NULL) < 0)
2144                         r = -errno;
2145         va_end(ap);
2146
2147         return r;
2148 }
2149
2150 void safe_close_pair(int p[]) {
2151         assert(p);
2152
2153         if (p[0] == p[1]) {
2154                 /* Special case pairs which use the same fd in both
2155                  * directions... */
2156                 p[0] = p[1] = safe_close(p[0]);
2157                 return;
2158         }
2159
2160         p[0] = safe_close(p[0]);
2161         p[1] = safe_close(p[1]);
2162 }
2163
2164 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2165         uint8_t *p = buf;
2166         ssize_t n = 0;
2167
2168         assert(fd >= 0);
2169         assert(buf);
2170
2171         while (nbytes > 0) {
2172                 ssize_t k;
2173
2174                 k = read(fd, p, nbytes);
2175                 if (k < 0 && errno == EINTR)
2176                         continue;
2177
2178                 if (k < 0 && errno == EAGAIN && do_poll) {
2179
2180                         /* We knowingly ignore any return value here,
2181                          * and expect that any error/EOF is reported
2182                          * via read() */
2183
2184                         fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2185                         continue;
2186                 }
2187
2188                 if (k <= 0)
2189                         return n > 0 ? n : (k < 0 ? -errno : 0);
2190
2191                 p += k;
2192                 nbytes -= k;
2193                 n += k;
2194         }
2195
2196         return n;
2197 }
2198
2199 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2200         const uint8_t *p = buf;
2201         ssize_t n = 0;
2202
2203         assert(fd >= 0);
2204         assert(buf);
2205
2206         while (nbytes > 0) {
2207                 ssize_t k;
2208
2209                 k = write(fd, p, nbytes);
2210                 if (k < 0 && errno == EINTR)
2211                         continue;
2212
2213                 if (k < 0 && errno == EAGAIN && do_poll) {
2214
2215                         /* We knowingly ignore any return value here,
2216                          * and expect that any error/EOF is reported
2217                          * via write() */
2218
2219                         fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2220                         continue;
2221                 }
2222
2223                 if (k <= 0)
2224                         return n > 0 ? n : (k < 0 ? -errno : 0);
2225
2226                 p += k;
2227                 nbytes -= k;
2228                 n += k;
2229         }
2230
2231         return n;
2232 }
2233
2234 int parse_size(const char *t, off_t base, off_t *size) {
2235
2236         /* Soo, sometimes we want to parse IEC binary suffxies, and
2237          * sometimes SI decimal suffixes. This function can parse
2238          * both. Which one is the right way depends on the
2239          * context. Wikipedia suggests that SI is customary for
2240          * hardrware metrics and network speeds, while IEC is
2241          * customary for most data sizes used by software and volatile
2242          * (RAM) memory. Hence be careful which one you pick!
2243          *
2244          * In either case we use just K, M, G as suffix, and not Ki,
2245          * Mi, Gi or so (as IEC would suggest). That's because that's
2246          * frickin' ugly. But this means you really need to make sure
2247          * to document which base you are parsing when you use this
2248          * call. */
2249
2250         struct table {
2251                 const char *suffix;
2252                 unsigned long long factor;
2253         };
2254
2255         static const struct table iec[] = {
2256                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2257                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2258                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2259                 { "G", 1024ULL*1024ULL*1024ULL },
2260                 { "M", 1024ULL*1024ULL },
2261                 { "K", 1024ULL },
2262                 { "B", 1 },
2263                 { "", 1 },
2264         };
2265
2266         static const struct table si[] = {
2267                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2268                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2269                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2270                 { "G", 1000ULL*1000ULL*1000ULL },
2271                 { "M", 1000ULL*1000ULL },
2272                 { "K", 1000ULL },
2273                 { "B", 1 },
2274                 { "", 1 },
2275         };
2276
2277         const struct table *table;
2278         const char *p;
2279         unsigned long long r = 0;
2280         unsigned n_entries, start_pos = 0;
2281
2282         assert(t);
2283         assert(base == 1000 || base == 1024);
2284         assert(size);
2285
2286         if (base == 1000) {
2287                 table = si;
2288                 n_entries = ELEMENTSOF(si);
2289         } else {
2290                 table = iec;
2291                 n_entries = ELEMENTSOF(iec);
2292         }
2293
2294         p = t;
2295         do {
2296                 long long l;
2297                 unsigned long long l2;
2298                 double frac = 0;
2299                 char *e;
2300                 unsigned i;
2301
2302                 errno = 0;
2303                 l = strtoll(p, &e, 10);
2304
2305                 if (errno > 0)
2306                         return -errno;
2307
2308                 if (l < 0)
2309                         return -ERANGE;
2310
2311                 if (e == p)
2312                         return -EINVAL;
2313
2314                 if (*e == '.') {
2315                         e++;
2316                         if (*e >= '0' && *e <= '9') {
2317                                 char *e2;
2318
2319                                 /* strotoull itself would accept space/+/- */
2320                                 l2 = strtoull(e, &e2, 10);
2321
2322                                 if (errno == ERANGE)
2323                                         return -errno;
2324
2325                                 /* Ignore failure. E.g. 10.M is valid */
2326                                 frac = l2;
2327                                 for (; e < e2; e++)
2328                                         frac /= 10;
2329                         }
2330                 }
2331
2332                 e += strspn(e, WHITESPACE);
2333
2334                 for (i = start_pos; i < n_entries; i++)
2335                         if (startswith(e, table[i].suffix)) {
2336                                 unsigned long long tmp;
2337                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2338                                         return -ERANGE;
2339                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2340                                 if (tmp > ULLONG_MAX - r)
2341                                         return -ERANGE;
2342
2343                                 r += tmp;
2344                                 if ((unsigned long long) (off_t) r != r)
2345                                         return -ERANGE;
2346
2347                                 p = e + strlen(table[i].suffix);
2348
2349                                 start_pos = i + 1;
2350                                 break;
2351                         }
2352
2353                 if (i >= n_entries)
2354                         return -EINVAL;
2355
2356         } while (*p);
2357
2358         *size = r;
2359
2360         return 0;
2361 }
2362
2363 int make_stdio(int fd) {
2364         int r, s, t;
2365
2366         assert(fd >= 0);
2367
2368         r = dup3(fd, STDIN_FILENO, 0);
2369         s = dup3(fd, STDOUT_FILENO, 0);
2370         t = dup3(fd, STDERR_FILENO, 0);
2371
2372         if (fd >= 3)
2373                 safe_close(fd);
2374
2375         if (r < 0 || s < 0 || t < 0)
2376                 return -errno;
2377
2378         /* We rely here that the new fd has O_CLOEXEC not set */
2379
2380         return 0;
2381 }
2382
2383 int make_null_stdio(void) {
2384         int null_fd;
2385
2386         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2387         if (null_fd < 0)
2388                 return -errno;
2389
2390         return make_stdio(null_fd);
2391 }
2392
2393 bool is_device_path(const char *path) {
2394
2395         /* Returns true on paths that refer to a device, either in
2396          * sysfs or in /dev */
2397
2398         return
2399                 path_startswith(path, "/dev/") ||
2400                 path_startswith(path, "/sys/");
2401 }
2402
2403 int dir_is_empty(const char *path) {
2404         _cleanup_closedir_ DIR *d;
2405
2406         d = opendir(path);
2407         if (!d)
2408                 return -errno;
2409
2410         for (;;) {
2411                 struct dirent *de;
2412
2413                 errno = 0;
2414                 de = readdir(d);
2415                 if (!de && errno != 0)
2416                         return -errno;
2417
2418                 if (!de)
2419                         return 1;
2420
2421                 if (!ignore_file(de->d_name))
2422                         return 0;
2423         }
2424 }
2425
2426 char* dirname_malloc(const char *path) {
2427         char *d, *dir, *dir2;
2428
2429         d = strdup(path);
2430         if (!d)
2431                 return NULL;
2432         dir = dirname(d);
2433         assert(dir);
2434
2435         if (dir != d) {
2436                 dir2 = strdup(dir);
2437                 free(d);
2438                 return dir2;
2439         }
2440
2441         return dir;
2442 }
2443
2444 int dev_urandom(void *p, size_t n) {
2445         _cleanup_close_ int fd;
2446         ssize_t k;
2447
2448         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2449         if (fd < 0)
2450                 return errno == ENOENT ? -ENOSYS : -errno;
2451
2452         k = loop_read(fd, p, n, true);
2453         if (k < 0)
2454                 return (int) k;
2455         if ((size_t) k != n)
2456                 return -EIO;
2457
2458         return 0;
2459 }
2460
2461 void random_bytes(void *p, size_t n) {
2462         static bool srand_called = false;
2463         uint8_t *q;
2464         int r;
2465
2466         r = dev_urandom(p, n);
2467         if (r >= 0)
2468                 return;
2469
2470         /* If some idiot made /dev/urandom unavailable to us, he'll
2471          * get a PRNG instead. */
2472
2473         if (!srand_called) {
2474                 unsigned x = 0;
2475
2476 #ifdef HAVE_SYS_AUXV_H
2477                 /* The kernel provides us with a bit of entropy in
2478                  * auxv, so let's try to make use of that to seed the
2479                  * pseudo-random generator. It's better than
2480                  * nothing... */
2481
2482                 void *auxv;
2483
2484                 auxv = (void*) getauxval(AT_RANDOM);
2485                 if (auxv)
2486                         x ^= *(unsigned*) auxv;
2487 #endif
2488
2489                 x ^= (unsigned) now(CLOCK_REALTIME);
2490                 x ^= (unsigned) gettid();
2491
2492                 srand(x);
2493                 srand_called = true;
2494         }
2495
2496         for (q = p; q < (uint8_t*) p + n; q ++)
2497                 *q = rand();
2498 }
2499
2500 void rename_process(const char name[8]) {
2501         assert(name);
2502
2503         /* This is a like a poor man's setproctitle(). It changes the
2504          * comm field, argv[0], and also the glibc's internally used
2505          * name of the process. For the first one a limit of 16 chars
2506          * applies, to the second one usually one of 10 (i.e. length
2507          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2508          * "systemd"). If you pass a longer string it will be
2509          * truncated */
2510
2511         prctl(PR_SET_NAME, name);
2512
2513         if (program_invocation_name)
2514                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2515
2516         if (saved_argc > 0) {
2517                 int i;
2518
2519                 if (saved_argv[0])
2520                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2521
2522                 for (i = 1; i < saved_argc; i++) {
2523                         if (!saved_argv[i])
2524                                 break;
2525
2526                         memzero(saved_argv[i], strlen(saved_argv[i]));
2527                 }
2528         }
2529 }
2530
2531 void sigset_add_many(sigset_t *ss, ...) {
2532         va_list ap;
2533         int sig;
2534
2535         assert(ss);
2536
2537         va_start(ap, ss);
2538         while ((sig = va_arg(ap, int)) > 0)
2539                 assert_se(sigaddset(ss, sig) == 0);
2540         va_end(ap);
2541 }
2542
2543 int sigprocmask_many(int how, ...) {
2544         va_list ap;
2545         sigset_t ss;
2546         int sig;
2547
2548         assert_se(sigemptyset(&ss) == 0);
2549
2550         va_start(ap, how);
2551         while ((sig = va_arg(ap, int)) > 0)
2552                 assert_se(sigaddset(&ss, sig) == 0);
2553         va_end(ap);
2554
2555         if (sigprocmask(how, &ss, NULL) < 0)
2556                 return -errno;
2557
2558         return 0;
2559 }
2560
2561 char* gethostname_malloc(void) {
2562         struct utsname u;
2563
2564         assert_se(uname(&u) >= 0);
2565
2566         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2567                 return strdup(u.nodename);
2568
2569         return strdup(u.sysname);
2570 }
2571
2572 bool hostname_is_set(void) {
2573         struct utsname u;
2574
2575         assert_se(uname(&u) >= 0);
2576
2577         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2578 }
2579
2580 static char *lookup_uid(uid_t uid) {
2581         long bufsize;
2582         char *name;
2583         _cleanup_free_ char *buf = NULL;
2584         struct passwd pwbuf, *pw = NULL;
2585
2586         /* Shortcut things to avoid NSS lookups */
2587         if (uid == 0)
2588                 return strdup("root");
2589
2590         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2591         if (bufsize <= 0)
2592                 bufsize = 4096;
2593
2594         buf = malloc(bufsize);
2595         if (!buf)
2596                 return NULL;
2597
2598         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2599                 return strdup(pw->pw_name);
2600
2601         if (asprintf(&name, UID_FMT, uid) < 0)
2602                 return NULL;
2603
2604         return name;
2605 }
2606
2607 char* getlogname_malloc(void) {
2608         uid_t uid;
2609         struct stat st;
2610
2611         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2612                 uid = st.st_uid;
2613         else
2614                 uid = getuid();
2615
2616         return lookup_uid(uid);
2617 }
2618
2619 char *getusername_malloc(void) {
2620         const char *e;
2621
2622         e = getenv("USER");
2623         if (e)
2624                 return strdup(e);
2625
2626         return lookup_uid(getuid());
2627 }
2628
2629 int getttyname_malloc(int fd, char **r) {
2630         char path[PATH_MAX], *c;
2631         int k;
2632
2633         assert(r);
2634
2635         k = ttyname_r(fd, path, sizeof(path));
2636         if (k > 0)
2637                 return -k;
2638
2639         char_array_0(path);
2640
2641         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2642         if (!c)
2643                 return -ENOMEM;
2644
2645         *r = c;
2646         return 0;
2647 }
2648
2649 int getttyname_harder(int fd, char **r) {
2650         int k;
2651         char *s;
2652
2653         k = getttyname_malloc(fd, &s);
2654         if (k < 0)
2655                 return k;
2656
2657         if (streq(s, "tty")) {
2658                 free(s);
2659                 return get_ctty(0, NULL, r);
2660         }
2661
2662         *r = s;
2663         return 0;
2664 }
2665
2666 int get_ctty_devnr(pid_t pid, dev_t *d) {
2667         int r;
2668         _cleanup_free_ char *line = NULL;
2669         const char *p;
2670         unsigned long ttynr;
2671
2672         assert(pid >= 0);
2673
2674         p = procfs_file_alloca(pid, "stat");
2675         r = read_one_line_file(p, &line);
2676         if (r < 0)
2677                 return r;
2678
2679         p = strrchr(line, ')');
2680         if (!p)
2681                 return -EIO;
2682
2683         p++;
2684
2685         if (sscanf(p, " "
2686                    "%*c "  /* state */
2687                    "%*d "  /* ppid */
2688                    "%*d "  /* pgrp */
2689                    "%*d "  /* session */
2690                    "%lu ", /* ttynr */
2691                    &ttynr) != 1)
2692                 return -EIO;
2693
2694         if (major(ttynr) == 0 && minor(ttynr) == 0)
2695                 return -ENOENT;
2696
2697         if (d)
2698                 *d = (dev_t) ttynr;
2699
2700         return 0;
2701 }
2702
2703 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2704         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2705         _cleanup_free_ char *s = NULL;
2706         const char *p;
2707         dev_t devnr;
2708         int k;
2709
2710         assert(r);
2711
2712         k = get_ctty_devnr(pid, &devnr);
2713         if (k < 0)
2714                 return k;
2715
2716         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2717
2718         k = readlink_malloc(fn, &s);
2719         if (k < 0) {
2720
2721                 if (k != -ENOENT)
2722                         return k;
2723
2724                 /* This is an ugly hack */
2725                 if (major(devnr) == 136) {
2726                         asprintf(&b, "pts/%u", minor(devnr));
2727                         goto finish;
2728                 }
2729
2730                 /* Probably something like the ptys which have no
2731                  * symlink in /dev/char. Let's return something
2732                  * vaguely useful. */
2733
2734                 b = strdup(fn + 5);
2735                 goto finish;
2736         }
2737
2738         if (startswith(s, "/dev/"))
2739                 p = s + 5;
2740         else if (startswith(s, "../"))
2741                 p = s + 3;
2742         else
2743                 p = s;
2744
2745         b = strdup(p);
2746
2747 finish:
2748         if (!b)
2749                 return -ENOMEM;
2750
2751         *r = b;
2752         if (_devnr)
2753                 *_devnr = devnr;
2754
2755         return 0;
2756 }
2757
2758 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2759         _cleanup_closedir_ DIR *d = NULL;
2760         int ret = 0;
2761
2762         assert(fd >= 0);
2763
2764         /* This returns the first error we run into, but nevertheless
2765          * tries to go on. This closes the passed fd. */
2766
2767         d = fdopendir(fd);
2768         if (!d) {
2769                 safe_close(fd);
2770
2771                 return errno == ENOENT ? 0 : -errno;
2772         }
2773
2774         for (;;) {
2775                 struct dirent *de;
2776                 bool is_dir, keep_around;
2777                 struct stat st;
2778                 int r;
2779
2780                 errno = 0;
2781                 de = readdir(d);
2782                 if (!de) {
2783                         if (errno != 0 && ret == 0)
2784                                 ret = -errno;
2785                         return ret;
2786                 }
2787
2788                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2789                         continue;
2790
2791                 if (de->d_type == DT_UNKNOWN ||
2792                     honour_sticky ||
2793                     (de->d_type == DT_DIR && root_dev)) {
2794                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2795                                 if (ret == 0 && errno != ENOENT)
2796                                         ret = -errno;
2797                                 continue;
2798                         }
2799
2800                         is_dir = S_ISDIR(st.st_mode);
2801                         keep_around =
2802                                 honour_sticky &&
2803                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2804                                 (st.st_mode & S_ISVTX);
2805                 } else {
2806                         is_dir = de->d_type == DT_DIR;
2807                         keep_around = false;
2808                 }
2809
2810                 if (is_dir) {
2811                         int subdir_fd;
2812
2813                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2814                         if (root_dev && st.st_dev != root_dev->st_dev)
2815                                 continue;
2816
2817                         subdir_fd = openat(fd, de->d_name,
2818                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2819                         if (subdir_fd < 0) {
2820                                 if (ret == 0 && errno != ENOENT)
2821                                         ret = -errno;
2822                                 continue;
2823                         }
2824
2825                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2826                         if (r < 0 && ret == 0)
2827                                 ret = r;
2828
2829                         if (!keep_around)
2830                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2831                                         if (ret == 0 && errno != ENOENT)
2832                                                 ret = -errno;
2833                                 }
2834
2835                 } else if (!only_dirs && !keep_around) {
2836
2837                         if (unlinkat(fd, de->d_name, 0) < 0) {
2838                                 if (ret == 0 && errno != ENOENT)
2839                                         ret = -errno;
2840                         }
2841                 }
2842         }
2843 }
2844
2845 _pure_ static int is_temporary_fs(struct statfs *s) {
2846         assert(s);
2847
2848         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2849                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2850 }
2851
2852 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2853         struct statfs s;
2854
2855         assert(fd >= 0);
2856
2857         if (fstatfs(fd, &s) < 0) {
2858                 safe_close(fd);
2859                 return -errno;
2860         }
2861
2862         /* We refuse to clean disk file systems with this call. This
2863          * is extra paranoia just to be sure we never ever remove
2864          * non-state data */
2865         if (!is_temporary_fs(&s)) {
2866                 log_error("Attempted to remove disk file system, and we can't allow that.");
2867                 safe_close(fd);
2868                 return -EPERM;
2869         }
2870
2871         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2872 }
2873
2874 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2875         int fd, r;
2876         struct statfs s;
2877
2878         assert(path);
2879
2880         /* We refuse to clean the root file system with this
2881          * call. This is extra paranoia to never cause a really
2882          * seriously broken system. */
2883         if (path_equal(path, "/")) {
2884                 log_error("Attempted to remove entire root file system, and we can't allow that.");
2885                 return -EPERM;
2886         }
2887
2888         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2889         if (fd < 0) {
2890
2891                 if (errno != ENOTDIR)
2892                         return -errno;
2893
2894                 if (!dangerous) {
2895                         if (statfs(path, &s) < 0)
2896                                 return -errno;
2897
2898                         if (!is_temporary_fs(&s)) {
2899                                 log_error("Attempted to remove disk file system, and we can't allow that.");
2900                                 return -EPERM;
2901                         }
2902                 }
2903
2904                 if (delete_root && !only_dirs)
2905                         if (unlink(path) < 0 && errno != ENOENT)
2906                                 return -errno;
2907
2908                 return 0;
2909         }
2910
2911         if (!dangerous) {
2912                 if (fstatfs(fd, &s) < 0) {
2913                         safe_close(fd);
2914                         return -errno;
2915                 }
2916
2917                 if (!is_temporary_fs(&s)) {
2918                         log_error("Attempted to remove disk file system, and we can't allow that.");
2919                         safe_close(fd);
2920                         return -EPERM;
2921                 }
2922         }
2923
2924         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2925         if (delete_root) {
2926
2927                 if (honour_sticky && file_is_priv_sticky(path) > 0)
2928                         return r;
2929
2930                 if (rmdir(path) < 0 && errno != ENOENT) {
2931                         if (r == 0)
2932                                 r = -errno;
2933                 }
2934         }
2935
2936         return r;
2937 }
2938
2939 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2940         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2941 }
2942
2943 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2944         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2945 }
2946
2947 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2948         assert(path);
2949
2950         /* Under the assumption that we are running privileged we
2951          * first change the access mode and only then hand out
2952          * ownership to avoid a window where access is too open. */
2953
2954         if (mode != (mode_t) -1)
2955                 if (chmod(path, mode) < 0)
2956                         return -errno;
2957
2958         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2959                 if (chown(path, uid, gid) < 0)
2960                         return -errno;
2961
2962         return 0;
2963 }
2964
2965 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2966         assert(fd >= 0);
2967
2968         /* Under the assumption that we are running privileged we
2969          * first change the access mode and only then hand out
2970          * ownership to avoid a window where access is too open. */
2971
2972         if (mode != (mode_t) -1)
2973                 if (fchmod(fd, mode) < 0)
2974                         return -errno;
2975
2976         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2977                 if (fchown(fd, uid, gid) < 0)
2978                         return -errno;
2979
2980         return 0;
2981 }
2982
2983 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2984         cpu_set_t *r;
2985         unsigned n = 1024;
2986
2987         /* Allocates the cpuset in the right size */
2988
2989         for (;;) {
2990                 if (!(r = CPU_ALLOC(n)))
2991                         return NULL;
2992
2993                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2994                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2995
2996                         if (ncpus)
2997                                 *ncpus = n;
2998
2999                         return r;
3000                 }
3001
3002                 CPU_FREE(r);
3003
3004                 if (errno != EINVAL)
3005                         return NULL;
3006
3007                 n *= 2;
3008         }
3009 }
3010
3011 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3012         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3013         _cleanup_free_ char *s = NULL;
3014         _cleanup_close_ int fd = -1;
3015         struct iovec iovec[6] = {};
3016         int n = 0;
3017         static bool prev_ephemeral;
3018
3019         assert(format);
3020
3021         /* This is independent of logging, as status messages are
3022          * optional and go exclusively to the console. */
3023
3024         if (vasprintf(&s, format, ap) < 0)
3025                 return log_oom();
3026
3027         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3028         if (fd < 0)
3029                 return fd;
3030
3031         if (ellipse) {
3032                 char *e;
3033                 size_t emax, sl;
3034                 int c;
3035
3036                 c = fd_columns(fd);
3037                 if (c <= 0)
3038                         c = 80;
3039
3040                 sl = status ? sizeof(status_indent)-1 : 0;
3041
3042                 emax = c - sl - 1;
3043                 if (emax < 3)
3044                         emax = 3;
3045
3046                 e = ellipsize(s, emax, 75);
3047                 if (e) {
3048                         free(s);
3049                         s = e;
3050                 }
3051         }
3052
3053         if (prev_ephemeral)
3054                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3055         prev_ephemeral = ephemeral;
3056
3057         if (status) {
3058                 if (!isempty(status)) {
3059                         IOVEC_SET_STRING(iovec[n++], "[");
3060                         IOVEC_SET_STRING(iovec[n++], status);
3061                         IOVEC_SET_STRING(iovec[n++], "] ");
3062                 } else
3063                         IOVEC_SET_STRING(iovec[n++], status_indent);
3064         }
3065
3066         IOVEC_SET_STRING(iovec[n++], s);
3067         if (!ephemeral)
3068                 IOVEC_SET_STRING(iovec[n++], "\n");
3069
3070         if (writev(fd, iovec, n) < 0)
3071                 return -errno;
3072
3073         return 0;
3074 }
3075
3076 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3077         va_list ap;
3078         int r;
3079
3080         assert(format);
3081
3082         va_start(ap, format);
3083         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3084         va_end(ap);
3085
3086         return r;
3087 }
3088
3089 char *replace_env(const char *format, char **env) {
3090         enum {
3091                 WORD,
3092                 CURLY,
3093                 VARIABLE
3094         } state = WORD;
3095
3096         const char *e, *word = format;
3097         char *r = NULL, *k;
3098
3099         assert(format);
3100
3101         for (e = format; *e; e ++) {
3102
3103                 switch (state) {
3104
3105                 case WORD:
3106                         if (*e == '$')
3107                                 state = CURLY;
3108                         break;
3109
3110                 case CURLY:
3111                         if (*e == '{') {
3112                                 if (!(k = strnappend(r, word, e-word-1)))
3113                                         goto fail;
3114
3115                                 free(r);
3116                                 r = k;
3117
3118                                 word = e-1;
3119                                 state = VARIABLE;
3120
3121                         } else if (*e == '$') {
3122                                 if (!(k = strnappend(r, word, e-word)))
3123                                         goto fail;
3124
3125                                 free(r);
3126                                 r = k;
3127
3128                                 word = e+1;
3129                                 state = WORD;
3130                         } else
3131                                 state = WORD;
3132                         break;
3133
3134                 case VARIABLE:
3135                         if (*e == '}') {
3136                                 const char *t;
3137
3138                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3139
3140                                 k = strappend(r, t);
3141                                 if (!k)
3142                                         goto fail;
3143
3144                                 free(r);
3145                                 r = k;
3146
3147                                 word = e+1;
3148                                 state = WORD;
3149                         }
3150                         break;
3151                 }
3152         }
3153
3154         if (!(k = strnappend(r, word, e-word)))
3155                 goto fail;
3156
3157         free(r);
3158         return k;
3159
3160 fail:
3161         free(r);
3162         return NULL;
3163 }
3164
3165 char **replace_env_argv(char **argv, char **env) {
3166         char **ret, **i;
3167         unsigned k = 0, l = 0;
3168
3169         l = strv_length(argv);
3170
3171         ret = new(char*, l+1);
3172         if (!ret)
3173                 return NULL;
3174
3175         STRV_FOREACH(i, argv) {
3176
3177                 /* If $FOO appears as single word, replace it by the split up variable */
3178                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3179                         char *e;
3180                         char **w, **m;
3181                         unsigned q;
3182
3183                         e = strv_env_get(env, *i+1);
3184                         if (e) {
3185                                 int r;
3186
3187                                 r = strv_split_quoted(&m, e);
3188                                 if (r < 0) {
3189                                         ret[k] = NULL;
3190                                         strv_free(ret);
3191                                         return NULL;
3192                                 }
3193                         } else
3194                                 m = NULL;
3195
3196                         q = strv_length(m);
3197                         l = l + q - 1;
3198
3199                         w = realloc(ret, sizeof(char*) * (l+1));
3200                         if (!w) {
3201                                 ret[k] = NULL;
3202                                 strv_free(ret);
3203                                 strv_free(m);
3204                                 return NULL;
3205                         }
3206
3207                         ret = w;
3208                         if (m) {
3209                                 memcpy(ret + k, m, q * sizeof(char*));
3210                                 free(m);
3211                         }
3212
3213                         k += q;
3214                         continue;
3215                 }
3216
3217                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3218                 ret[k] = replace_env(*i, env);
3219                 if (!ret[k]) {
3220                         strv_free(ret);
3221                         return NULL;
3222                 }
3223                 k++;
3224         }
3225
3226         ret[k] = NULL;
3227         return ret;
3228 }
3229
3230 int fd_columns(int fd) {
3231         struct winsize ws = {};
3232
3233         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3234                 return -errno;
3235
3236         if (ws.ws_col <= 0)
3237                 return -EIO;
3238
3239         return ws.ws_col;
3240 }
3241
3242 unsigned columns(void) {
3243         const char *e;
3244         int c;
3245
3246         if (_likely_(cached_columns > 0))
3247                 return cached_columns;
3248
3249         c = 0;
3250         e = getenv("COLUMNS");
3251         if (e)
3252                 safe_atoi(e, &c);
3253
3254         if (c <= 0)
3255                 c = fd_columns(STDOUT_FILENO);
3256
3257         if (c <= 0)
3258                 c = 80;
3259
3260         cached_columns = c;
3261         return c;
3262 }
3263
3264 int fd_lines(int fd) {
3265         struct winsize ws = {};
3266
3267         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3268                 return -errno;
3269
3270         if (ws.ws_row <= 0)
3271                 return -EIO;
3272
3273         return ws.ws_row;
3274 }
3275
3276 unsigned lines(void) {
3277         const char *e;
3278         unsigned l;
3279
3280         if (_likely_(cached_lines > 0))
3281                 return cached_lines;
3282
3283         l = 0;
3284         e = getenv("LINES");
3285         if (e)
3286                 safe_atou(e, &l);
3287
3288         if (l <= 0)
3289                 l = fd_lines(STDOUT_FILENO);
3290
3291         if (l <= 0)
3292                 l = 24;
3293
3294         cached_lines = l;
3295         return cached_lines;
3296 }
3297
3298 /* intended to be used as a SIGWINCH sighandler */
3299 void columns_lines_cache_reset(int signum) {
3300         cached_columns = 0;
3301         cached_lines = 0;
3302 }
3303
3304 bool on_tty(void) {
3305         static int cached_on_tty = -1;
3306
3307         if (_unlikely_(cached_on_tty < 0))
3308                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3309
3310         return cached_on_tty;
3311 }
3312
3313 int files_same(const char *filea, const char *fileb) {
3314         struct stat a, b;
3315
3316         if (stat(filea, &a) < 0)
3317                 return -errno;
3318
3319         if (stat(fileb, &b) < 0)
3320                 return -errno;
3321
3322         return a.st_dev == b.st_dev &&
3323                a.st_ino == b.st_ino;
3324 }
3325
3326 int running_in_chroot(void) {
3327         int ret;
3328
3329         ret = files_same("/proc/1/root", "/");
3330         if (ret < 0)
3331                 return ret;
3332
3333         return ret == 0;
3334 }
3335
3336 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3337         size_t x;
3338         char *r;
3339
3340         assert(s);
3341         assert(percent <= 100);
3342         assert(new_length >= 3);
3343
3344         if (old_length <= 3 || old_length <= new_length)
3345                 return strndup(s, old_length);
3346
3347         r = new0(char, new_length+1);
3348         if (!r)
3349                 return NULL;
3350
3351         x = (new_length * percent) / 100;
3352
3353         if (x > new_length - 3)
3354                 x = new_length - 3;
3355
3356         memcpy(r, s, x);
3357         r[x] = '.';
3358         r[x+1] = '.';
3359         r[x+2] = '.';
3360         memcpy(r + x + 3,
3361                s + old_length - (new_length - x - 3),
3362                new_length - x - 3);
3363
3364         return r;
3365 }
3366
3367 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3368         size_t x;
3369         char *e;
3370         const char *i, *j;
3371         unsigned k, len, len2;
3372
3373         assert(s);
3374         assert(percent <= 100);
3375         assert(new_length >= 3);
3376
3377         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3378         if (ascii_is_valid(s))
3379                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3380
3381         if (old_length <= 3 || old_length <= new_length)
3382                 return strndup(s, old_length);
3383
3384         x = (new_length * percent) / 100;
3385
3386         if (x > new_length - 3)
3387                 x = new_length - 3;
3388
3389         k = 0;
3390         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3391                 int c;
3392
3393                 c = utf8_encoded_to_unichar(i);
3394                 if (c < 0)
3395                         return NULL;
3396                 k += unichar_iswide(c) ? 2 : 1;
3397         }
3398
3399         if (k > x) /* last character was wide and went over quota */
3400                 x ++;
3401
3402         for (j = s + old_length; k < new_length && j > i; ) {
3403                 int c;
3404
3405                 j = utf8_prev_char(j);
3406                 c = utf8_encoded_to_unichar(j);
3407                 if (c < 0)
3408                         return NULL;
3409                 k += unichar_iswide(c) ? 2 : 1;
3410         }
3411         assert(i <= j);
3412
3413         /* we don't actually need to ellipsize */
3414         if (i == j)
3415                 return memdup(s, old_length + 1);
3416
3417         /* make space for ellipsis */
3418         j = utf8_next_char(j);
3419
3420         len = i - s;
3421         len2 = s + old_length - j;
3422         e = new(char, len + 3 + len2 + 1);
3423         if (!e)
3424                 return NULL;
3425
3426         /*
3427         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3428                old_length, new_length, x, len, len2, k);
3429         */
3430
3431         memcpy(e, s, len);
3432         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3433         e[len + 1] = 0x80;
3434         e[len + 2] = 0xa6;
3435
3436         memcpy(e + len + 3, j, len2 + 1);
3437
3438         return e;
3439 }
3440
3441 char *ellipsize(const char *s, size_t length, unsigned percent) {
3442         return ellipsize_mem(s, strlen(s), length, percent);
3443 }
3444
3445 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3446         _cleanup_close_ int fd;
3447         int r;
3448
3449         assert(path);
3450
3451         if (parents)
3452                 mkdir_parents(path, 0755);
3453
3454         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3455         if (fd < 0)
3456                 return -errno;
3457
3458         if (mode > 0) {
3459                 r = fchmod(fd, mode);
3460                 if (r < 0)
3461                         return -errno;
3462         }
3463
3464         if (uid != (uid_t) -1 || gid != (gid_t) -1) {
3465                 r = fchown(fd, uid, gid);
3466                 if (r < 0)
3467                         return -errno;
3468         }
3469
3470         if (stamp != USEC_INFINITY) {
3471                 struct timespec ts[2];
3472
3473                 timespec_store(&ts[0], stamp);
3474                 ts[1] = ts[0];
3475                 r = futimens(fd, ts);
3476         } else
3477                 r = futimens(fd, NULL);
3478         if (r < 0)
3479                 return -errno;
3480
3481         return 0;
3482 }
3483
3484 int touch(const char *path) {
3485         return touch_file(path, false, USEC_INFINITY, (uid_t) -1, (gid_t) -1, 0);
3486 }
3487
3488 char *unquote(const char *s, const char* quotes) {
3489         size_t l;
3490         assert(s);
3491
3492         /* This is rather stupid, simply removes the heading and
3493          * trailing quotes if there is one. Doesn't care about
3494          * escaping or anything. We should make this smarter one
3495          * day...*/
3496
3497         l = strlen(s);
3498         if (l < 2)
3499                 return strdup(s);
3500
3501         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3502                 return strndup(s+1, l-2);
3503
3504         return strdup(s);
3505 }
3506
3507 char *normalize_env_assignment(const char *s) {
3508         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3509         char *eq, *r;
3510
3511         eq = strchr(s, '=');
3512         if (!eq) {
3513                 char *t;
3514
3515                 r = strdup(s);
3516                 if (!r)
3517                         return NULL;
3518
3519                 t = strstrip(r);
3520                 if (t == r)
3521                         return r;
3522
3523                 memmove(r, t, strlen(t) + 1);
3524                 return r;
3525         }
3526
3527         name = strndup(s, eq - s);
3528         if (!name)
3529                 return NULL;
3530
3531         p = strdup(eq + 1);
3532         if (!p)
3533                 return NULL;
3534
3535         value = unquote(strstrip(p), QUOTES);
3536         if (!value)
3537                 return NULL;
3538
3539         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3540                 r = NULL;
3541
3542         return r;
3543 }
3544
3545 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3546         siginfo_t dummy;
3547
3548         assert(pid >= 1);
3549
3550         if (!status)
3551                 status = &dummy;
3552
3553         for (;;) {
3554                 zero(*status);
3555
3556                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3557
3558                         if (errno == EINTR)
3559                                 continue;
3560
3561                         return -errno;
3562                 }
3563
3564                 return 0;
3565         }
3566 }
3567
3568 /*
3569  * Return values:
3570  * < 0 : wait_for_terminate() failed to get the state of the
3571  *       process, the process was terminated by a signal, or
3572  *       failed for an unknown reason.
3573  * >=0 : The process terminated normally, and its exit code is
3574  *       returned.
3575  *
3576  * That is, success is indicated by a return value of zero, and an
3577  * error is indicated by a non-zero value.
3578  */
3579 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3580         int r;
3581         siginfo_t status;
3582
3583         assert(name);
3584         assert(pid > 1);
3585
3586         r = wait_for_terminate(pid, &status);
3587         if (r < 0) {
3588                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3589                 return r;
3590         }
3591
3592         if (status.si_code == CLD_EXITED) {
3593                 if (status.si_status != 0) {
3594                         log_warning("%s failed with error code %i.", name, status.si_status);
3595                         return status.si_status;
3596                 }
3597
3598                 log_debug("%s succeeded.", name);
3599                 return 0;
3600
3601         } else if (status.si_code == CLD_KILLED ||
3602                    status.si_code == CLD_DUMPED) {
3603
3604                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3605                 return -EPROTO;
3606         }
3607
3608         log_warning("%s failed due to unknown reason.", name);
3609         return -EPROTO;
3610 }
3611
3612 noreturn void freeze(void) {
3613
3614         /* Make sure nobody waits for us on a socket anymore */
3615         close_all_fds(NULL, 0);
3616
3617         sync();
3618
3619         for (;;)
3620                 pause();
3621 }
3622
3623 bool null_or_empty(struct stat *st) {
3624         assert(st);
3625
3626         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3627                 return true;
3628
3629         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3630                 return true;
3631
3632         return false;
3633 }
3634
3635 int null_or_empty_path(const char *fn) {
3636         struct stat st;
3637
3638         assert(fn);
3639
3640         if (stat(fn, &st) < 0)
3641                 return -errno;
3642
3643         return null_or_empty(&st);
3644 }
3645
3646 int null_or_empty_fd(int fd) {
3647         struct stat st;
3648
3649         assert(fd >= 0);
3650
3651         if (fstat(fd, &st) < 0)
3652                 return -errno;
3653
3654         return null_or_empty(&st);
3655 }
3656
3657 DIR *xopendirat(int fd, const char *name, int flags) {
3658         int nfd;
3659         DIR *d;
3660
3661         assert(!(flags & O_CREAT));
3662
3663         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3664         if (nfd < 0)
3665                 return NULL;
3666
3667         d = fdopendir(nfd);
3668         if (!d) {
3669                 safe_close(nfd);
3670                 return NULL;
3671         }
3672
3673         return d;
3674 }
3675
3676 int signal_from_string_try_harder(const char *s) {
3677         int signo;
3678         assert(s);
3679
3680         signo = signal_from_string(s);
3681         if (signo <= 0)
3682                 if (startswith(s, "SIG"))
3683                         return signal_from_string(s+3);
3684
3685         return signo;
3686 }
3687
3688 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3689         _cleanup_free_ char *t = NULL, *u = NULL;
3690         size_t enc_len;
3691
3692         u = unquote(tagvalue, "\"\'");
3693         if (!u)
3694                 return NULL;
3695
3696         enc_len = strlen(u) * 4 + 1;
3697         t = new(char, enc_len);
3698         if (!t)
3699                 return NULL;
3700
3701         if (encode_devnode_name(u, t, enc_len) < 0)
3702                 return NULL;
3703
3704         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3705 }
3706
3707 char *fstab_node_to_udev_node(const char *p) {
3708         assert(p);
3709
3710         if (startswith(p, "LABEL="))
3711                 return tag_to_udev_node(p+6, "label");
3712
3713         if (startswith(p, "UUID="))
3714                 return tag_to_udev_node(p+5, "uuid");
3715
3716         if (startswith(p, "PARTUUID="))
3717                 return tag_to_udev_node(p+9, "partuuid");
3718
3719         if (startswith(p, "PARTLABEL="))
3720                 return tag_to_udev_node(p+10, "partlabel");
3721
3722         return strdup(p);
3723 }
3724
3725 bool tty_is_vc(const char *tty) {
3726         assert(tty);
3727
3728         return vtnr_from_tty(tty) >= 0;
3729 }
3730
3731 bool tty_is_console(const char *tty) {
3732         assert(tty);
3733
3734         if (startswith(tty, "/dev/"))
3735                 tty += 5;
3736
3737         return streq(tty, "console");
3738 }
3739
3740 int vtnr_from_tty(const char *tty) {
3741         int i, r;
3742
3743         assert(tty);
3744
3745         if (startswith(tty, "/dev/"))
3746                 tty += 5;
3747
3748         if (!startswith(tty, "tty") )
3749                 return -EINVAL;
3750
3751         if (tty[3] < '0' || tty[3] > '9')
3752                 return -EINVAL;
3753
3754         r = safe_atoi(tty+3, &i);
3755         if (r < 0)
3756                 return r;
3757
3758         if (i < 0 || i > 63)
3759                 return -EINVAL;
3760
3761         return i;
3762 }
3763
3764 char *resolve_dev_console(char **active) {
3765         char *tty;
3766
3767         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3768          * (i.e. not read-only-mounted which is a sign for container setups) */
3769
3770         if (path_is_read_only_fs("/sys") > 0)
3771                 return NULL;
3772
3773         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3774                 return NULL;
3775
3776         /* If multiple log outputs are configured the last one is what
3777          * /dev/console points to */
3778         tty = strrchr(*active, ' ');
3779         if (tty)
3780                 tty++;
3781         else
3782                 tty = *active;
3783
3784         if (streq(tty, "tty0")) {
3785                 char *tmp;
3786
3787                 /* Get the active VC (e.g. tty1) */
3788                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3789                         free(*active);
3790                         tty = *active = tmp;
3791                 }
3792         }
3793
3794         return tty;
3795 }
3796
3797 bool tty_is_vc_resolve(const char *tty) {
3798         _cleanup_free_ char *active = NULL;
3799
3800         assert(tty);
3801
3802         if (startswith(tty, "/dev/"))
3803                 tty += 5;
3804
3805         if (streq(tty, "console")) {
3806                 tty = resolve_dev_console(&active);
3807                 if (!tty)
3808                         return false;
3809         }
3810
3811         return tty_is_vc(tty);
3812 }
3813
3814 const char *default_term_for_tty(const char *tty) {
3815         assert(tty);
3816
3817         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3818 }
3819
3820 bool dirent_is_file(const struct dirent *de) {
3821         assert(de);
3822
3823         if (ignore_file(de->d_name))
3824                 return false;
3825
3826         if (de->d_type != DT_REG &&
3827             de->d_type != DT_LNK &&
3828             de->d_type != DT_UNKNOWN)
3829                 return false;
3830
3831         return true;
3832 }
3833
3834 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3835         assert(de);
3836
3837         if (de->d_type != DT_REG &&
3838             de->d_type != DT_LNK &&
3839             de->d_type != DT_UNKNOWN)
3840                 return false;
3841
3842         if (ignore_file_allow_backup(de->d_name))
3843                 return false;
3844
3845         return endswith(de->d_name, suffix);
3846 }
3847
3848 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
3849         pid_t executor_pid;
3850         int r;
3851
3852         assert(directory);
3853
3854         /* Executes all binaries in a directory in parallel and waits
3855          * for them to finish. Optionally a timeout is applied. */
3856
3857         executor_pid = fork();
3858         if (executor_pid < 0) {
3859                 log_error("Failed to fork: %m");
3860                 return;
3861
3862         } else if (executor_pid == 0) {
3863                 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
3864                 _cleanup_closedir_ DIR *_d = NULL;
3865                 struct dirent *de;
3866                 sigset_t ss;
3867
3868                 /* We fork this all off from a child process so that
3869                  * we can somewhat cleanly make use of SIGALRM to set
3870                  * a time limit */
3871
3872                 reset_all_signal_handlers();
3873
3874                 assert_se(sigemptyset(&ss) == 0);
3875                 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
3876
3877                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3878
3879                 if (!d) {
3880                         d = _d = opendir(directory);
3881                         if (!d) {
3882                                 if (errno == ENOENT)
3883                                         _exit(EXIT_SUCCESS);
3884
3885                                 log_error("Failed to enumerate directory %s: %m", directory);
3886                                 _exit(EXIT_FAILURE);
3887                         }
3888                 }
3889
3890                 pids = hashmap_new(NULL, NULL);
3891                 if (!pids) {
3892                         log_oom();
3893                         _exit(EXIT_FAILURE);
3894                 }
3895
3896                 FOREACH_DIRENT(de, d, break) {
3897                         _cleanup_free_ char *path = NULL;
3898                         pid_t pid;
3899
3900                         if (!dirent_is_file(de))
3901                                 continue;
3902
3903                         path = strjoin(directory, "/", de->d_name, NULL);
3904                         if (!path) {
3905                                 log_oom();
3906                                 _exit(EXIT_FAILURE);
3907                         }
3908
3909                         pid = fork();
3910                         if (pid < 0) {
3911                                 log_error("Failed to fork: %m");
3912                                 continue;
3913                         } else if (pid == 0) {
3914                                 char *_argv[2];
3915
3916                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3917
3918                                 if (!argv) {
3919                                         _argv[0] = path;
3920                                         _argv[1] = NULL;
3921                                         argv = _argv;
3922                                 } else
3923                                         argv[0] = path;
3924
3925                                 execv(path, argv);
3926                                 log_error("Failed to execute %s: %m", path);
3927                                 _exit(EXIT_FAILURE);
3928                         }
3929
3930
3931                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
3932
3933                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
3934                         if (r < 0) {
3935                                 log_oom();
3936                                 _exit(EXIT_FAILURE);
3937                         }
3938
3939                         path = NULL;
3940                 }
3941
3942                 /* Abort execution of this process after the
3943                  * timout. We simply rely on SIGALRM as default action
3944                  * terminating the process, and turn on alarm(). */
3945
3946                 if (timeout != USEC_INFINITY)
3947                         alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
3948
3949                 while (!hashmap_isempty(pids)) {
3950                         _cleanup_free_ char *path = NULL;
3951                         pid_t pid;
3952
3953                         pid = PTR_TO_UINT(hashmap_first_key(pids));
3954                         assert(pid > 0);
3955
3956                         path = hashmap_remove(pids, UINT_TO_PTR(pid));
3957                         assert(path);
3958
3959                         wait_for_terminate_and_warn(path, pid);
3960                 }
3961
3962                 _exit(EXIT_SUCCESS);
3963         }
3964
3965         wait_for_terminate_and_warn(directory, executor_pid);
3966 }
3967
3968 int kill_and_sigcont(pid_t pid, int sig) {
3969         int r;
3970
3971         r = kill(pid, sig) < 0 ? -errno : 0;
3972
3973         if (r >= 0)
3974                 kill(pid, SIGCONT);
3975
3976         return r;
3977 }
3978