src/shared/util.c

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