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