1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
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.
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.
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/>.
31 #include <sys/resource.h>
32 #include <linux/sched.h>
33 #include <sys/types.h>
37 #include <sys/ioctl.h>
39 #include <linux/tiocl.h>
42 #include <sys/inotify.h>
45 #include <sys/prctl.h>
46 #include <sys/utsname.h>
48 #include <netinet/ip.h>
57 #include <linux/magic.h>
61 #include <sys/personality.h>
65 #ifdef HAVE_SYS_AUXV_H
77 #include "path-util.h"
78 #include "exit-status.h"
82 #include "device-nodes.h"
89 char **saved_argv = NULL;
91 static volatile unsigned cached_columns = 0;
92 static volatile unsigned cached_lines = 0;
94 size_t page_size(void) {
95 static thread_local size_t pgsz = 0;
98 if (_likely_(pgsz > 0))
101 r = sysconf(_SC_PAGESIZE);
108 bool streq_ptr(const char *a, const char *b) {
110 /* Like streq(), but tries to make sense of NULL pointers */
121 char* endswith(const char *s, const char *postfix) {
128 pl = strlen(postfix);
131 return (char*) s + sl;
136 if (memcmp(s + sl - pl, postfix, pl) != 0)
139 return (char*) s + sl - pl;
142 bool first_word(const char *s, const char *word) {
157 if (memcmp(s, word, wl) != 0)
161 strchr(WHITESPACE, s[wl]);
164 int close_nointr(int fd) {
171 else if (errno == EINTR)
173 * Just ignore EINTR; a retry loop is the wrong
174 * thing to do on Linux.
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
186 int safe_close(int fd) {
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:
193 * fd = safe_close(fd);
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... */
204 assert_se(close_nointr(fd) != -EBADF);
210 void close_many(const int fds[], unsigned n_fd) {
213 assert(fds || n_fd <= 0);
215 for (i = 0; i < n_fd; i++)
219 int unlink_noerrno(const char *path) {
230 int parse_boolean(const char *v) {
233 if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
235 else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
241 int parse_pid(const char *s, pid_t* ret_pid) {
242 unsigned long ul = 0;
249 r = safe_atolu(s, &ul);
255 if ((unsigned long) pid != ul)
265 int parse_uid(const char *s, uid_t* ret_uid) {
266 unsigned long ul = 0;
273 r = safe_atolu(s, &ul);
279 if ((unsigned long) uid != ul)
286 int safe_atou(const char *s, unsigned *ret_u) {
294 l = strtoul(s, &x, 0);
296 if (!x || x == s || *x || errno)
297 return errno > 0 ? -errno : -EINVAL;
299 if ((unsigned long) (unsigned) l != l)
302 *ret_u = (unsigned) l;
306 int safe_atoi(const char *s, int *ret_i) {
314 l = strtol(s, &x, 0);
316 if (!x || x == s || *x || errno)
317 return errno > 0 ? -errno : -EINVAL;
319 if ((long) (int) l != l)
326 int safe_atollu(const char *s, long long unsigned *ret_llu) {
328 unsigned long long l;
334 l = strtoull(s, &x, 0);
336 if (!x || x == s || *x || errno)
337 return errno ? -errno : -EINVAL;
343 int safe_atolli(const char *s, long long int *ret_lli) {
351 l = strtoll(s, &x, 0);
353 if (!x || x == s || *x || errno)
354 return errno ? -errno : -EINVAL;
360 int safe_atod(const char *s, double *ret_d) {
367 RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
372 if (!x || x == s || *x || errno)
373 return errno ? -errno : -EINVAL;
379 static size_t strcspn_escaped(const char *s, const char *reject) {
380 bool escaped = false;
383 for (n=0; s[n]; n++) {
386 else if (s[n] == '\\')
388 else if (strchr(reject, s[n]))
394 /* Split a string into words. */
395 char *split(const char *c, size_t *l, const char *separator, bool quoted, char **state) {
398 current = *state ? *state : (char*) c;
400 if (!*current || *c == 0)
403 current += strspn(current, separator);
407 if (quoted && strchr("\'\"", *current)) {
408 char quotechar = *(current++);
409 *l = strcspn_escaped(current, (char[]){quotechar, '\0'});
410 *state = current+*l+1;
412 *l = strcspn_escaped(current, separator);
415 *l = strcspn(current, separator);
419 return (char*) current;
422 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
424 _cleanup_free_ char *line = NULL;
436 p = procfs_file_alloca(pid, "stat");
437 r = read_one_line_file(p, &line);
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 */
445 p = strrchr(line, ')');
457 if ((long unsigned) (pid_t) ppid != ppid)
460 *_ppid = (pid_t) ppid;
465 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
467 _cleanup_free_ char *line = NULL;
473 p = procfs_file_alloca(pid, "stat");
474 r = read_one_line_file(p, &line);
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 */
482 p = strrchr(line, ')');
504 "%*d " /* priority */
506 "%*d " /* num_threads */
507 "%*d " /* itrealvalue */
508 "%llu " /* starttime */,
515 int fchmod_umask(int fd, mode_t m) {
520 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
526 char *truncate_nl(char *s) {
529 s[strcspn(s, NEWLINE)] = 0;
533 int get_process_state(pid_t pid) {
537 _cleanup_free_ char *line = NULL;
541 p = procfs_file_alloca(pid, "stat");
542 r = read_one_line_file(p, &line);
546 p = strrchr(line, ')');
552 if (sscanf(p, " %c", &state) != 1)
555 return (unsigned char) state;
558 int get_process_comm(pid_t pid, char **name) {
565 p = procfs_file_alloca(pid, "comm");
567 r = read_one_line_file(p, name);
574 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
575 _cleanup_fclose_ FILE *f = NULL;
583 p = procfs_file_alloca(pid, "cmdline");
589 if (max_length == 0) {
590 size_t len = 0, allocated = 0;
592 while ((c = getc(f)) != EOF) {
594 if (!GREEDY_REALLOC(r, allocated, len+2)) {
599 r[len++] = isprint(c) ? c : ' ';
609 r = new(char, max_length);
615 while ((c = getc(f)) != EOF) {
637 size_t n = MIN(left-1, 3U);
644 /* Kernel threads have no argv[] */
645 if (r == NULL || r[0] == 0) {
646 _cleanup_free_ char *t = NULL;
654 h = get_process_comm(pid, &t);
658 r = strjoin("[", t, "]", NULL);
667 int is_kernel_thread(pid_t pid) {
679 p = procfs_file_alloca(pid, "cmdline");
684 count = fread(&c, 1, 1, f);
688 /* Kernel threads have an empty cmdline */
691 return eof ? 1 : -errno;
696 int get_process_capeff(pid_t pid, char **capeff) {
702 p = procfs_file_alloca(pid, "status");
704 return get_status_field(p, "\nCapEff:", capeff);
707 int get_process_exe(pid_t pid, char **name) {
715 p = procfs_file_alloca(pid, "exe");
717 r = readlink_malloc(p, name);
719 return r == -ENOENT ? -ESRCH : r;
721 d = endswith(*name, " (deleted)");
728 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
729 _cleanup_fclose_ FILE *f = NULL;
739 p = procfs_file_alloca(pid, "status");
744 FOREACH_LINE(line, f, return -errno) {
749 if (startswith(l, field)) {
751 l += strspn(l, WHITESPACE);
753 l[strcspn(l, WHITESPACE)] = 0;
755 return parse_uid(l, uid);
762 int get_process_uid(pid_t pid, uid_t *uid) {
763 return get_process_id(pid, "Uid:", uid);
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);
771 char *strnappend(const char *s, const char *suffix, size_t b) {
779 return strndup(suffix, b);
788 if (b > ((size_t) -1) - a)
791 r = new(char, a+b+1);
796 memcpy(r+a, suffix, b);
802 char *strappend(const char *s, const char *suffix) {
803 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
806 int readlink_malloc(const char *p, char **ret) {
821 n = readlink(p, c, l-1);
828 if ((size_t) n < l-1) {
839 int readlink_and_make_absolute(const char *p, char **r) {
840 _cleanup_free_ char *target = NULL;
847 j = readlink_malloc(p, &target);
851 k = file_in_same_dir(p, target);
859 int readlink_and_canonicalize(const char *p, char **r) {
866 j = readlink_and_make_absolute(p, &t);
870 s = canonicalize_file_name(t);
877 path_kill_slashes(*r);
882 int reset_all_signal_handlers(void) {
885 for (sig = 1; sig < _NSIG; sig++) {
886 struct sigaction sa = {
887 .sa_handler = SIG_DFL,
888 .sa_flags = SA_RESTART,
891 if (sig == SIGKILL || sig == SIGSTOP)
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))
904 char *strstrip(char *s) {
907 /* Drops trailing whitespace. Modifies the string in
908 * place. Returns pointer to first non-space character */
910 s += strspn(s, WHITESPACE);
912 for (e = strchr(s, 0); e > s; e --)
913 if (!strchr(WHITESPACE, e[-1]))
921 char *delete_chars(char *s, const char *bad) {
924 /* Drops all whitespace, regardless where in the string */
926 for (f = s, t = s; *f; f++) {
938 char *file_in_same_dir(const char *path, const char *filename) {
945 /* This removes the last component of path and appends
946 * filename, unless the latter is absolute anyway or the
949 if (path_is_absolute(filename))
950 return strdup(filename);
952 if (!(e = strrchr(path, '/')))
953 return strdup(filename);
955 k = strlen(filename);
956 if (!(r = new(char, e-path+1+k+1)))
959 memcpy(r, path, e-path+1);
960 memcpy(r+(e-path)+1, filename, k+1);
965 int rmdir_parents(const char *path, const char *stop) {
974 /* Skip trailing slashes */
975 while (l > 0 && path[l-1] == '/')
981 /* Skip last component */
982 while (l > 0 && path[l-1] != '/')
985 /* Skip trailing slashes */
986 while (l > 0 && path[l-1] == '/')
992 if (!(t = strndup(path, l)))
995 if (path_startswith(stop, t)) {
1004 if (errno != ENOENT)
1011 char hexchar(int x) {
1012 static const char table[16] = "0123456789abcdef";
1014 return table[x & 15];
1017 int unhexchar(char c) {
1019 if (c >= '0' && c <= '9')
1022 if (c >= 'a' && c <= 'f')
1023 return c - 'a' + 10;
1025 if (c >= 'A' && c <= 'F')
1026 return c - 'A' + 10;
1031 char *hexmem(const void *p, size_t l) {
1035 z = r = malloc(l * 2 + 1);
1039 for (x = p; x < (const uint8_t*) p + l; x++) {
1040 *(z++) = hexchar(*x >> 4);
1041 *(z++) = hexchar(*x & 15);
1048 void *unhexmem(const char *p, size_t l) {
1054 z = r = malloc((l + 1) / 2 + 1);
1058 for (x = p; x < p + l; x += 2) {
1061 a = unhexchar(x[0]);
1063 b = unhexchar(x[1]);
1067 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1074 char octchar(int x) {
1075 return '0' + (x & 7);
1078 int unoctchar(char c) {
1080 if (c >= '0' && c <= '7')
1086 char decchar(int x) {
1087 return '0' + (x % 10);
1090 int undecchar(char c) {
1092 if (c >= '0' && c <= '9')
1098 char *cescape(const char *s) {
1104 /* Does C style string escaping. */
1106 r = new(char, strlen(s)*4 + 1);
1110 for (f = s, t = r; *f; f++)
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)) {
1161 *(t++) = octchar((unsigned char) *f >> 6);
1162 *(t++) = octchar((unsigned char) *f >> 3);
1163 *(t++) = octchar((unsigned char) *f);
1174 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1181 /* Undoes C style string escaping, and optionally prefixes it. */
1183 pl = prefix ? strlen(prefix) : 0;
1185 r = new(char, pl+length+1);
1190 memcpy(r, prefix, pl);
1192 for (f = s, t = r + pl; f < s + length; f++) {
1235 /* This is an extension of the XDG syntax files */
1240 /* hexadecimal encoding */
1243 a = unhexchar(f[1]);
1244 b = unhexchar(f[2]);
1246 if (a < 0 || b < 0) {
1247 /* Invalid escape code, let's take it literal then */
1251 *(t++) = (char) ((a << 4) | b);
1266 /* octal encoding */
1269 a = unoctchar(f[0]);
1270 b = unoctchar(f[1]);
1271 c = unoctchar(f[2]);
1273 if (a < 0 || b < 0 || c < 0) {
1274 /* Invalid escape code, let's take it literal then */
1278 *(t++) = (char) ((a << 6) | (b << 3) | c);
1286 /* premature end of string.*/
1291 /* Invalid escape code, let's take it literal then */
1303 char *cunescape_length(const char *s, size_t length) {
1304 return cunescape_length_with_prefix(s, length, NULL);
1307 char *cunescape(const char *s) {
1310 return cunescape_length(s, strlen(s));
1313 char *xescape(const char *s, const char *bad) {
1317 /* Escapes all chars in bad, in addition to \ and all special
1318 * chars, in \xFF style escaping. May be reversed with
1321 r = new(char, strlen(s) * 4 + 1);
1325 for (f = s, t = r; *f; f++) {
1327 if ((*f < ' ') || (*f >= 127) ||
1328 (*f == '\\') || strchr(bad, *f)) {
1331 *(t++) = hexchar(*f >> 4);
1332 *(t++) = hexchar(*f);
1342 char *ascii_strlower(char *t) {
1347 for (p = t; *p; p++)
1348 if (*p >= 'A' && *p <= 'Z')
1349 *p = *p - 'A' + 'a';
1354 _pure_ static bool ignore_file_allow_backup(const char *filename) {
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");
1370 bool ignore_file(const char *filename) {
1373 if (endswith(filename, "~"))
1376 return ignore_file_allow_backup(filename);
1379 int fd_nonblock(int fd, bool nonblock) {
1384 if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1388 flags |= O_NONBLOCK;
1390 flags &= ~O_NONBLOCK;
1392 if (fcntl(fd, F_SETFL, flags) < 0)
1398 int fd_cloexec(int fd, bool cloexec) {
1403 if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1407 flags |= FD_CLOEXEC;
1409 flags &= ~FD_CLOEXEC;
1411 if (fcntl(fd, F_SETFD, flags) < 0)
1417 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1420 assert(n_fdset == 0 || fdset);
1422 for (i = 0; i < n_fdset; i++)
1429 int close_all_fds(const int except[], unsigned n_except) {
1434 assert(n_except == 0 || except);
1436 d = opendir("/proc/self/fd");
1441 /* When /proc isn't available (for example in chroots)
1442 * the fallback is brute forcing through the fd
1445 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1446 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1448 if (fd_in_set(fd, except, n_except))
1451 if (close_nointr(fd) < 0)
1452 if (errno != EBADF && r == 0)
1459 while ((de = readdir(d))) {
1462 if (ignore_file(de->d_name))
1465 if (safe_atoi(de->d_name, &fd) < 0)
1466 /* Let's better ignore this, just in case */
1475 if (fd_in_set(fd, except, n_except))
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)
1489 bool chars_intersect(const char *a, const char *b) {
1492 /* Returns true if any of the chars in a are in b. */
1493 for (p = a; *p; p++)
1500 bool fstype_is_network(const char *fstype) {
1501 static const char table[] =
1514 x = startswith(fstype, "fuse.");
1518 return nulstr_contains(table, fstype);
1522 _cleanup_close_ int fd;
1524 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1530 TIOCL_GETKMSGREDIRECT,
1534 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1537 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1540 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1546 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1547 struct termios old_termios, new_termios;
1549 char line[LINE_MAX];
1554 if (tcgetattr(fileno(f), &old_termios) >= 0) {
1555 new_termios = old_termios;
1557 new_termios.c_lflag &= ~ICANON;
1558 new_termios.c_cc[VMIN] = 1;
1559 new_termios.c_cc[VTIME] = 0;
1561 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1564 if (t != (usec_t) -1) {
1565 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1566 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1571 k = fread(&c, 1, 1, f);
1573 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1579 *need_nl = c != '\n';
1586 if (t != (usec_t) -1)
1587 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1590 if (!fgets(line, sizeof(line), f))
1595 if (strlen(line) != 1)
1605 int ask(char *ret, const char *replies, const char *text, ...) {
1615 bool need_nl = true;
1618 fputs(ANSI_HIGHLIGHT_ON, stdout);
1625 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1629 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1632 if (r == -EBADMSG) {
1633 puts("Bad input, please try again.");
1644 if (strchr(replies, c)) {
1649 puts("Read unexpected character, please try again.");
1653 int reset_terminal_fd(int fd, bool switch_to_text) {
1654 struct termios termios;
1657 /* Set terminal to some sane defaults */
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. */
1665 /* Disable exclusive mode, just in case */
1666 ioctl(fd, TIOCNXCL);
1668 /* Switch to text mode */
1670 ioctl(fd, KDSETMODE, KD_TEXT);
1672 /* Enable console unicode mode */
1673 ioctl(fd, KDSKBMODE, K_UNICODE);
1675 if (tcgetattr(fd, &termios) < 0) {
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 */
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;
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;
1704 termios.c_cc[VTIME] = 0;
1705 termios.c_cc[VMIN] = 1;
1707 if (tcsetattr(fd, TCSANOW, &termios) < 0)
1711 /* Just in case, flush all crap out */
1712 tcflush(fd, TCIOFLUSH);
1717 int reset_terminal(const char *name) {
1718 _cleanup_close_ int fd = -1;
1720 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1724 return reset_terminal_fd(fd, true);
1727 int open_terminal(const char *name, int mode) {
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.
1737 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1740 assert(!(mode & O_CREAT));
1743 fd = open(name, mode, 0);
1750 /* Max 1s in total */
1754 usleep(50 * USEC_PER_MSEC);
1775 int flush_fd(int fd) {
1776 struct pollfd pollfd = {
1786 r = poll(&pollfd, 1, 0);
1796 l = read(fd, buf, sizeof(buf));
1802 if (errno == EAGAIN)
1811 int acquire_terminal(
1815 bool ignore_tiocstty_eperm,
1818 int fd = -1, notify = -1, r = 0, wd = -1;
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.
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.) */
1836 if (timeout != (usec_t) -1)
1837 ts = now(CLOCK_MONOTONIC);
1839 if (!fail && !force) {
1840 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1846 wd = inotify_add_watch(notify, name, IN_CLOSE);
1854 struct sigaction sa_old, sa_new = {
1855 .sa_handler = SIG_IGN,
1856 .sa_flags = SA_RESTART,
1860 r = flush_fd(notify);
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);
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);
1876 /* First, try to get the tty */
1877 if (ioctl(fd, TIOCSCTTY, force) < 0)
1880 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
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)
1888 if (r < 0 && (force || fail || r != -EPERM)) {
1897 assert(notify >= 0);
1900 uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1902 struct inotify_event *e;
1904 if (timeout != (usec_t) -1) {
1907 n = now(CLOCK_MONOTONIC);
1908 if (ts + timeout < n) {
1913 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1923 l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1926 if (errno == EINTR || errno == EAGAIN)
1933 e = (struct inotify_event*) inotify_buffer;
1938 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
1943 step = sizeof(struct inotify_event) + e->len;
1944 assert(step <= (size_t) l);
1946 e = (struct inotify_event*) ((uint8_t*) e + step);
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. */
1962 r = reset_terminal_fd(fd, true);
1964 log_warning("Failed to reset terminal: %s", strerror(-r));
1975 int release_terminal(void) {
1977 struct sigaction sa_old, sa_new = {
1978 .sa_handler = SIG_IGN,
1979 .sa_flags = SA_RESTART,
1981 _cleanup_close_ int fd;
1983 fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
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);
1991 if (ioctl(fd, TIOCNOTTY) < 0)
1994 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1999 int sigaction_many(const struct sigaction *sa, ...) {
2004 while ((sig = va_arg(ap, int)) > 0)
2005 if (sigaction(sig, sa, NULL) < 0)
2012 int ignore_signals(int sig, ...) {
2013 struct sigaction sa = {
2014 .sa_handler = SIG_IGN,
2015 .sa_flags = SA_RESTART,
2020 if (sigaction(sig, &sa, NULL) < 0)
2024 while ((sig = va_arg(ap, int)) > 0)
2025 if (sigaction(sig, &sa, NULL) < 0)
2032 int default_signals(int sig, ...) {
2033 struct sigaction sa = {
2034 .sa_handler = SIG_DFL,
2035 .sa_flags = SA_RESTART,
2040 if (sigaction(sig, &sa, NULL) < 0)
2044 while ((sig = va_arg(ap, int)) > 0)
2045 if (sigaction(sig, &sa, NULL) < 0)
2052 void safe_close_pair(int p[]) {
2056 /* Special case pairs which use the same fd in both
2058 p[0] = p[1] = safe_close(p[0]);
2062 p[0] = safe_close(p[0]);
2063 p[1] = safe_close(p[1]);
2066 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2073 while (nbytes > 0) {
2076 k = read(fd, p, nbytes);
2077 if (k < 0 && errno == EINTR)
2080 if (k < 0 && errno == EAGAIN && do_poll) {
2082 /* We knowingly ignore any return value here,
2083 * and expect that any error/EOF is reported
2086 fd_wait_for_event(fd, POLLIN, (usec_t) -1);
2091 return n > 0 ? n : (k < 0 ? -errno : 0);
2101 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2102 const uint8_t *p = buf;
2108 while (nbytes > 0) {
2111 k = write(fd, p, nbytes);
2112 if (k < 0 && errno == EINTR)
2115 if (k < 0 && errno == EAGAIN && do_poll) {
2117 /* We knowingly ignore any return value here,
2118 * and expect that any error/EOF is reported
2121 fd_wait_for_event(fd, POLLOUT, (usec_t) -1);
2126 return n > 0 ? n : (k < 0 ? -errno : 0);
2136 int parse_size(const char *t, off_t base, off_t *size) {
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!
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
2154 unsigned long long factor;
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 },
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 },
2179 const struct table *table;
2181 unsigned long long r = 0;
2182 unsigned n_entries, start_pos = 0;
2185 assert(base == 1000 || base == 1024);
2190 n_entries = ELEMENTSOF(si);
2193 n_entries = ELEMENTSOF(iec);
2199 unsigned long long l2;
2205 l = strtoll(p, &e, 10);
2218 if (*e >= '0' && *e <= '9') {
2221 /* strotoull itself would accept space/+/- */
2222 l2 = strtoull(e, &e2, 10);
2224 if (errno == ERANGE)
2227 /* Ignore failure. E.g. 10.M is valid */
2234 e += strspn(e, WHITESPACE);
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)
2241 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2242 if (tmp > ULLONG_MAX - r)
2246 if ((unsigned long long) (off_t) r != r)
2249 p = e + strlen(table[i].suffix);
2265 int make_stdio(int fd) {
2270 r = dup3(fd, STDIN_FILENO, 0);
2271 s = dup3(fd, STDOUT_FILENO, 0);
2272 t = dup3(fd, STDERR_FILENO, 0);
2277 if (r < 0 || s < 0 || t < 0)
2280 /* We rely here that the new fd has O_CLOEXEC not set */
2285 int make_null_stdio(void) {
2288 null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2292 return make_stdio(null_fd);
2295 bool is_device_path(const char *path) {
2297 /* Returns true on paths that refer to a device, either in
2298 * sysfs or in /dev */
2301 path_startswith(path, "/dev/") ||
2302 path_startswith(path, "/sys/");
2305 int dir_is_empty(const char *path) {
2306 _cleanup_closedir_ DIR *d;
2317 if (!de && errno != 0)
2323 if (!ignore_file(de->d_name))
2328 char* dirname_malloc(const char *path) {
2329 char *d, *dir, *dir2;
2346 int dev_urandom(void *p, size_t n) {
2347 _cleanup_close_ int fd;
2350 fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2352 return errno == ENOENT ? -ENOSYS : -errno;
2354 k = loop_read(fd, p, n, true);
2357 if ((size_t) k != n)
2363 void random_bytes(void *p, size_t n) {
2364 static bool srand_called = false;
2368 r = dev_urandom(p, n);
2372 /* If some idiot made /dev/urandom unavailable to us, he'll
2373 * get a PRNG instead. */
2375 if (!srand_called) {
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
2386 auxv = (void*) getauxval(AT_RANDOM);
2388 x ^= *(unsigned*) auxv;
2391 x ^= (unsigned) now(CLOCK_REALTIME);
2392 x ^= (unsigned) gettid();
2395 srand_called = true;
2398 for (q = p; q < (uint8_t*) p + n; q ++)
2402 void rename_process(const char name[8]) {
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
2413 prctl(PR_SET_NAME, name);
2415 if (program_invocation_name)
2416 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2418 if (saved_argc > 0) {
2422 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2424 for (i = 1; i < saved_argc; i++) {
2428 memzero(saved_argv[i], strlen(saved_argv[i]));
2433 void sigset_add_many(sigset_t *ss, ...) {
2440 while ((sig = va_arg(ap, int)) > 0)
2441 assert_se(sigaddset(ss, sig) == 0);
2445 int sigprocmask_many(int how, ...) {
2450 assert_se(sigemptyset(&ss) == 0);
2453 while ((sig = va_arg(ap, int)) > 0)
2454 assert_se(sigaddset(&ss, sig) == 0);
2457 if (sigprocmask(how, &ss, NULL) < 0)
2463 char* gethostname_malloc(void) {
2466 assert_se(uname(&u) >= 0);
2468 if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2469 return strdup(u.nodename);
2471 return strdup(u.sysname);
2474 bool hostname_is_set(void) {
2477 assert_se(uname(&u) >= 0);
2479 return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2482 static char *lookup_uid(uid_t uid) {
2485 _cleanup_free_ char *buf = NULL;
2486 struct passwd pwbuf, *pw = NULL;
2488 /* Shortcut things to avoid NSS lookups */
2490 return strdup("root");
2492 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2496 buf = malloc(bufsize);
2500 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2501 return strdup(pw->pw_name);
2503 if (asprintf(&name, UID_FMT, uid) < 0)
2509 char* getlogname_malloc(void) {
2513 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2518 return lookup_uid(uid);
2521 char *getusername_malloc(void) {
2528 return lookup_uid(getuid());
2531 int getttyname_malloc(int fd, char **r) {
2532 char path[PATH_MAX], *c;
2537 k = ttyname_r(fd, path, sizeof(path));
2543 c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2551 int getttyname_harder(int fd, char **r) {
2555 k = getttyname_malloc(fd, &s);
2559 if (streq(s, "tty")) {
2561 return get_ctty(0, NULL, r);
2568 int get_ctty_devnr(pid_t pid, dev_t *d) {
2570 _cleanup_free_ char *line = NULL;
2572 unsigned long ttynr;
2576 p = procfs_file_alloca(pid, "stat");
2577 r = read_one_line_file(p, &line);
2581 p = strrchr(line, ')');
2591 "%*d " /* session */
2596 if (major(ttynr) == 0 && minor(ttynr) == 0)
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;
2614 k = get_ctty_devnr(pid, &devnr);
2618 snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2620 k = readlink_malloc(fn, &s);
2626 /* This is an ugly hack */
2627 if (major(devnr) == 136) {
2628 asprintf(&b, "pts/%u", minor(devnr));
2632 /* Probably something like the ptys which have no
2633 * symlink in /dev/char. Let's return something
2634 * vaguely useful. */
2640 if (startswith(s, "/dev/"))
2642 else if (startswith(s, "../"))
2660 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2666 /* This returns the first error we run into, but nevertheless
2667 * tries to go on. This closes the passed fd. */
2673 return errno == ENOENT ? 0 : -errno;
2678 bool is_dir, keep_around;
2684 if (!de && errno != 0) {
2693 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2696 if (de->d_type == DT_UNKNOWN ||
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)
2705 is_dir = S_ISDIR(st.st_mode);
2708 (st.st_uid == 0 || st.st_uid == getuid()) &&
2709 (st.st_mode & S_ISVTX);
2711 is_dir = de->d_type == DT_DIR;
2712 keep_around = false;
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)
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)
2730 r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2731 if (r < 0 && ret == 0)
2735 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2736 if (ret == 0 && errno != ENOENT)
2740 } else if (!only_dirs && !keep_around) {
2742 if (unlinkat(fd, de->d_name, 0) < 0) {
2743 if (ret == 0 && errno != ENOENT)
2754 _pure_ static int is_temporary_fs(struct statfs *s) {
2757 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2758 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2761 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2766 if (fstatfs(fd, &s) < 0) {
2771 /* We refuse to clean disk file systems with this call. This
2772 * is extra paranoia just to be sure we never ever remove
2774 if (!is_temporary_fs(&s)) {
2775 log_error("Attempted to remove disk file system, and we can't allow that.");
2780 return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2783 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
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.");
2797 fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2800 if (errno != ENOTDIR)
2804 if (statfs(path, &s) < 0)
2807 if (!is_temporary_fs(&s)) {
2808 log_error("Attempted to remove disk file system, and we can't allow that.");
2813 if (delete_root && !only_dirs)
2814 if (unlink(path) < 0 && errno != ENOENT)
2821 if (fstatfs(fd, &s) < 0) {
2826 if (!is_temporary_fs(&s)) {
2827 log_error("Attempted to remove disk file system, and we can't allow that.");
2833 r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2836 if (honour_sticky && file_is_priv_sticky(path) > 0)
2839 if (rmdir(path) < 0 && errno != ENOENT) {
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);
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);
2856 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
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. */
2863 if (mode != (mode_t) -1)
2864 if (chmod(path, mode) < 0)
2867 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2868 if (chown(path, uid, gid) < 0)
2874 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
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. */
2881 if (mode != (mode_t) -1)
2882 if (fchmod(fd, mode) < 0)
2885 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2886 if (fchown(fd, uid, gid) < 0)
2892 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2896 /* Allocates the cpuset in the right size */
2899 if (!(r = CPU_ALLOC(n)))
2902 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2903 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2913 if (errno != EINVAL)
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] = {};
2926 static bool prev_ephemeral;
2930 /* This is independent of logging, as status messages are
2931 * optional and go exclusively to the console. */
2933 if (vasprintf(&s, format, ap) < 0)
2936 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2949 sl = status ? sizeof(status_indent)-1 : 0;
2955 e = ellipsize(s, emax, 75);
2963 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2964 prev_ephemeral = ephemeral;
2967 if (!isempty(status)) {
2968 IOVEC_SET_STRING(iovec[n++], "[");
2969 IOVEC_SET_STRING(iovec[n++], status);
2970 IOVEC_SET_STRING(iovec[n++], "] ");
2972 IOVEC_SET_STRING(iovec[n++], status_indent);
2975 IOVEC_SET_STRING(iovec[n++], s);
2977 IOVEC_SET_STRING(iovec[n++], "\n");
2979 if (writev(fd, iovec, n) < 0)
2985 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2991 va_start(ap, format);
2992 r = status_vprintf(status, ellipse, ephemeral, format, ap);
2998 char *replace_env(const char *format, char **env) {
3005 const char *e, *word = format;
3010 for (e = format; *e; e ++) {
3021 if (!(k = strnappend(r, word, e-word-1)))
3030 } else if (*e == '$') {
3031 if (!(k = strnappend(r, word, e-word)))
3047 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3049 k = strappend(r, t);
3063 if (!(k = strnappend(r, word, e-word)))
3074 char **replace_env_argv(char **argv, char **env) {
3076 unsigned k = 0, l = 0;
3078 l = strv_length(argv);
3080 if (!(r = new(char*, l+1)))
3083 STRV_FOREACH(i, argv) {
3085 /* If $FOO appears as single word, replace it by the split up variable */
3086 if ((*i)[0] == '$' && (*i)[1] != '{') {
3091 e = strv_env_get(env, *i+1);
3094 if (!(m = strv_split_quoted(e))) {
3105 if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3114 memcpy(r + k, m, q * sizeof(char*));
3122 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3123 if (!(r[k++] = replace_env(*i, env))) {
3133 int fd_columns(int fd) {
3134 struct winsize ws = {};
3136 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3145 unsigned columns(void) {
3149 if (_likely_(cached_columns > 0))
3150 return cached_columns;
3153 e = getenv("COLUMNS");
3158 c = fd_columns(STDOUT_FILENO);
3167 int fd_lines(int fd) {
3168 struct winsize ws = {};
3170 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3179 unsigned lines(void) {
3183 if (_likely_(cached_lines > 0))
3184 return cached_lines;
3187 e = getenv("LINES");
3192 l = fd_lines(STDOUT_FILENO);
3198 return cached_lines;
3201 /* intended to be used as a SIGWINCH sighandler */
3202 void columns_lines_cache_reset(int signum) {
3208 static int cached_on_tty = -1;
3210 if (_unlikely_(cached_on_tty < 0))
3211 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3213 return cached_on_tty;
3216 int files_same(const char *filea, const char *fileb) {
3219 if (stat(filea, &a) < 0)
3222 if (stat(fileb, &b) < 0)
3225 return a.st_dev == b.st_dev &&
3226 a.st_ino == b.st_ino;
3229 int running_in_chroot(void) {
3232 ret = files_same("/proc/1/root", "/");
3239 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3244 assert(percent <= 100);
3245 assert(new_length >= 3);
3247 if (old_length <= 3 || old_length <= new_length)
3248 return strndup(s, old_length);
3250 r = new0(char, new_length+1);
3254 x = (new_length * percent) / 100;
3256 if (x > new_length - 3)
3264 s + old_length - (new_length - x - 3),
3265 new_length - x - 3);
3270 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3274 unsigned k, len, len2;
3277 assert(percent <= 100);
3278 assert(new_length >= 3);
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);
3284 if (old_length <= 3 || old_length <= new_length)
3285 return strndup(s, old_length);
3287 x = (new_length * percent) / 100;
3289 if (x > new_length - 3)
3293 for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3296 c = utf8_encoded_to_unichar(i);
3299 k += unichar_iswide(c) ? 2 : 1;
3302 if (k > x) /* last character was wide and went over quota */
3305 for (j = s + old_length; k < new_length && j > i; ) {
3308 j = utf8_prev_char(j);
3309 c = utf8_encoded_to_unichar(j);
3312 k += unichar_iswide(c) ? 2 : 1;
3316 /* we don't actually need to ellipsize */
3318 return memdup(s, old_length + 1);
3320 /* make space for ellipsis */
3321 j = utf8_next_char(j);
3324 len2 = s + old_length - j;
3325 e = new(char, len + 3 + len2 + 1);
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);
3335 e[len] = 0xe2; /* tri-dot ellipsis: … */
3339 memcpy(e + len + 3, j, len2 + 1);
3344 char *ellipsize(const char *s, size_t length, unsigned percent) {
3345 return ellipsize_mem(s, strlen(s), length, percent);
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;
3355 mkdir_parents(path, 0755);
3357 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3362 r = fchmod(fd, mode);
3367 if (uid != (uid_t) -1 || gid != (gid_t) -1) {
3368 r = fchown(fd, uid, gid);
3373 if (stamp != (usec_t) -1) {
3374 struct timespec ts[2];
3376 timespec_store(&ts[0], stamp);
3378 r = futimens(fd, ts);
3380 r = futimens(fd, NULL);
3387 int touch(const char *path) {
3388 return touch_file(path, false, (usec_t) -1, (uid_t) -1, (gid_t) -1, 0);
3391 char *unquote(const char *s, const char* quotes) {
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