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