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