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>
64 #ifdef HAVE_SYS_AUXV_H
75 #include "path-util.h"
76 #include "exit-status.h"
80 #include "device-nodes.h"
87 char **saved_argv = NULL;
89 static volatile unsigned cached_columns = 0;
90 static volatile unsigned cached_lines = 0;
92 size_t page_size(void) {
93 static thread_local size_t pgsz = 0;
96 if (_likely_(pgsz > 0))
99 r = sysconf(_SC_PAGESIZE);
106 bool streq_ptr(const char *a, const char *b) {
108 /* Like streq(), but tries to make sense of NULL pointers */
119 char* endswith(const char *s, const char *postfix) {
126 pl = strlen(postfix);
129 return (char*) s + sl;
134 if (memcmp(s + sl - pl, postfix, pl) != 0)
137 return (char*) s + sl - pl;
140 bool first_word(const char *s, const char *word) {
155 if (memcmp(s, word, wl) != 0)
159 strchr(WHITESPACE, s[wl]);
162 int close_nointr(int fd) {
168 /* Just ignore EINTR; a retry loop is the wrong
169 * thing to do on Linux.
171 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
172 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
173 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
174 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
176 if (_unlikely_(r < 0 && errno == EINTR))
184 void close_nointr_nofail(int fd) {
187 /* like close_nointr() but cannot fail, and guarantees errno
190 assert_se(close_nointr(fd) == 0);
193 void close_many(const int fds[], unsigned n_fd) {
196 assert(fds || n_fd <= 0);
198 for (i = 0; i < n_fd; i++)
199 close_nointr_nofail(fds[i]);
202 int unlink_noerrno(const char *path) {
213 int parse_boolean(const char *v) {
216 if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
218 else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
224 int parse_pid(const char *s, pid_t* ret_pid) {
225 unsigned long ul = 0;
232 r = safe_atolu(s, &ul);
238 if ((unsigned long) pid != ul)
248 int parse_uid(const char *s, uid_t* ret_uid) {
249 unsigned long ul = 0;
256 r = safe_atolu(s, &ul);
262 if ((unsigned long) uid != ul)
269 int safe_atou(const char *s, unsigned *ret_u) {
277 l = strtoul(s, &x, 0);
279 if (!x || x == s || *x || errno)
280 return errno > 0 ? -errno : -EINVAL;
282 if ((unsigned long) (unsigned) l != l)
285 *ret_u = (unsigned) l;
289 int safe_atoi(const char *s, int *ret_i) {
297 l = strtol(s, &x, 0);
299 if (!x || x == s || *x || errno)
300 return errno > 0 ? -errno : -EINVAL;
302 if ((long) (int) l != l)
309 int safe_atollu(const char *s, long long unsigned *ret_llu) {
311 unsigned long long l;
317 l = strtoull(s, &x, 0);
319 if (!x || x == s || *x || errno)
320 return errno ? -errno : -EINVAL;
326 int safe_atolli(const char *s, long long int *ret_lli) {
334 l = strtoll(s, &x, 0);
336 if (!x || x == s || *x || errno)
337 return errno ? -errno : -EINVAL;
343 int safe_atod(const char *s, double *ret_d) {
350 RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
355 if (!x || x == s || *x || errno)
356 return errno ? -errno : -EINVAL;
362 static size_t strcspn_escaped(const char *s, const char *reject) {
363 bool escaped = false;
366 for (n=0; s[n]; n++) {
369 else if (s[n] == '\\')
371 else if (strchr(reject, s[n]))
377 /* Split a string into words. */
378 char *split(const char *c, size_t *l, const char *separator, bool quoted, char **state) {
381 current = *state ? *state : (char*) c;
383 if (!*current || *c == 0)
386 current += strspn(current, separator);
390 if (quoted && strchr("\'\"", *current)) {
391 char quotechar = *(current++);
392 *l = strcspn_escaped(current, (char[]){quotechar, '\0'});
393 *state = current+*l+1;
395 *l = strcspn_escaped(current, separator);
398 *l = strcspn(current, separator);
402 return (char*) current;
405 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
407 _cleanup_free_ char *line = NULL;
419 p = procfs_file_alloca(pid, "stat");
420 r = read_one_line_file(p, &line);
424 /* Let's skip the pid and comm fields. The latter is enclosed
425 * in () but does not escape any () in its value, so let's
426 * skip over it manually */
428 p = strrchr(line, ')');
440 if ((long unsigned) (pid_t) ppid != ppid)
443 *_ppid = (pid_t) ppid;
448 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
450 _cleanup_free_ char *line = NULL;
456 p = procfs_file_alloca(pid, "stat");
457 r = read_one_line_file(p, &line);
461 /* Let's skip the pid and comm fields. The latter is enclosed
462 * in () but does not escape any () in its value, so let's
463 * skip over it manually */
465 p = strrchr(line, ')');
487 "%*d " /* priority */
489 "%*d " /* num_threads */
490 "%*d " /* itrealvalue */
491 "%llu " /* starttime */,
498 int fchmod_umask(int fd, mode_t m) {
503 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
509 char *truncate_nl(char *s) {
512 s[strcspn(s, NEWLINE)] = 0;
516 int get_process_state(pid_t pid) {
520 _cleanup_free_ char *line = NULL;
524 p = procfs_file_alloca(pid, "stat");
525 r = read_one_line_file(p, &line);
529 p = strrchr(line, ')');
535 if (sscanf(p, " %c", &state) != 1)
538 return (unsigned char) state;
541 int get_process_comm(pid_t pid, char **name) {
548 p = procfs_file_alloca(pid, "comm");
550 r = read_one_line_file(p, name);
557 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
558 _cleanup_fclose_ FILE *f = NULL;
566 p = procfs_file_alloca(pid, "cmdline");
572 if (max_length == 0) {
573 size_t len = 0, allocated = 0;
575 while ((c = getc(f)) != EOF) {
577 if (!GREEDY_REALLOC(r, allocated, len+2)) {
582 r[len++] = isprint(c) ? c : ' ';
592 r = new(char, max_length);
598 while ((c = getc(f)) != EOF) {
620 size_t n = MIN(left-1, 3U);
627 /* Kernel threads have no argv[] */
628 if (r == NULL || r[0] == 0) {
629 _cleanup_free_ char *t = NULL;
637 h = get_process_comm(pid, &t);
641 r = strjoin("[", t, "]", NULL);
650 int is_kernel_thread(pid_t pid) {
662 p = procfs_file_alloca(pid, "cmdline");
667 count = fread(&c, 1, 1, f);
671 /* Kernel threads have an empty cmdline */
674 return eof ? 1 : -errno;
679 int get_process_capeff(pid_t pid, char **capeff) {
685 p = procfs_file_alloca(pid, "status");
687 return get_status_field(p, "\nCapEff:", capeff);
690 int get_process_exe(pid_t pid, char **name) {
698 p = procfs_file_alloca(pid, "exe");
700 r = readlink_malloc(p, name);
702 return r == -ENOENT ? -ESRCH : r;
704 d = endswith(*name, " (deleted)");
711 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
712 _cleanup_fclose_ FILE *f = NULL;
722 p = procfs_file_alloca(pid, "status");
727 FOREACH_LINE(line, f, return -errno) {
732 if (startswith(l, field)) {
734 l += strspn(l, WHITESPACE);
736 l[strcspn(l, WHITESPACE)] = 0;
738 return parse_uid(l, uid);
745 int get_process_uid(pid_t pid, uid_t *uid) {
746 return get_process_id(pid, "Uid:", uid);
749 int get_process_gid(pid_t pid, gid_t *gid) {
750 assert_cc(sizeof(uid_t) == sizeof(gid_t));
751 return get_process_id(pid, "Gid:", gid);
754 char *strnappend(const char *s, const char *suffix, size_t b) {
762 return strndup(suffix, b);
771 if (b > ((size_t) -1) - a)
774 r = new(char, a+b+1);
779 memcpy(r+a, suffix, b);
785 char *strappend(const char *s, const char *suffix) {
786 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
789 int readlink_malloc(const char *p, char **ret) {
804 n = readlink(p, c, l-1);
811 if ((size_t) n < l-1) {
822 int readlink_and_make_absolute(const char *p, char **r) {
823 _cleanup_free_ char *target = NULL;
830 j = readlink_malloc(p, &target);
834 k = file_in_same_dir(p, target);
842 int readlink_and_canonicalize(const char *p, char **r) {
849 j = readlink_and_make_absolute(p, &t);
853 s = canonicalize_file_name(t);
860 path_kill_slashes(*r);
865 int reset_all_signal_handlers(void) {
868 for (sig = 1; sig < _NSIG; sig++) {
869 struct sigaction sa = {
870 .sa_handler = SIG_DFL,
871 .sa_flags = SA_RESTART,
874 if (sig == SIGKILL || sig == SIGSTOP)
877 /* On Linux the first two RT signals are reserved by
878 * glibc, and sigaction() will return EINVAL for them. */
879 if ((sigaction(sig, &sa, NULL) < 0))
887 char *strstrip(char *s) {
890 /* Drops trailing whitespace. Modifies the string in
891 * place. Returns pointer to first non-space character */
893 s += strspn(s, WHITESPACE);
895 for (e = strchr(s, 0); e > s; e --)
896 if (!strchr(WHITESPACE, e[-1]))
904 char *delete_chars(char *s, const char *bad) {
907 /* Drops all whitespace, regardless where in the string */
909 for (f = s, t = s; *f; f++) {
921 bool in_charset(const char *s, const char* charset) {
928 if (!strchr(charset, *i))
934 char *file_in_same_dir(const char *path, const char *filename) {
941 /* This removes the last component of path and appends
942 * filename, unless the latter is absolute anyway or the
945 if (path_is_absolute(filename))
946 return strdup(filename);
948 if (!(e = strrchr(path, '/')))
949 return strdup(filename);
951 k = strlen(filename);
952 if (!(r = new(char, e-path+1+k+1)))
955 memcpy(r, path, e-path+1);
956 memcpy(r+(e-path)+1, filename, k+1);
961 int rmdir_parents(const char *path, const char *stop) {
970 /* Skip trailing slashes */
971 while (l > 0 && path[l-1] == '/')
977 /* Skip last component */
978 while (l > 0 && path[l-1] != '/')
981 /* Skip trailing slashes */
982 while (l > 0 && path[l-1] == '/')
988 if (!(t = strndup(path, l)))
991 if (path_startswith(stop, t)) {
1000 if (errno != ENOENT)
1007 char hexchar(int x) {
1008 static const char table[16] = "0123456789abcdef";
1010 return table[x & 15];
1013 int unhexchar(char c) {
1015 if (c >= '0' && c <= '9')
1018 if (c >= 'a' && c <= 'f')
1019 return c - 'a' + 10;
1021 if (c >= 'A' && c <= 'F')
1022 return c - 'A' + 10;
1027 char *hexmem(const void *p, size_t l) {
1031 z = r = malloc(l * 2 + 1);
1035 for (x = p; x < (const uint8_t*) p + l; x++) {
1036 *(z++) = hexchar(*x >> 4);
1037 *(z++) = hexchar(*x & 15);
1044 void *unhexmem(const char *p, size_t l) {
1050 z = r = malloc((l + 1) / 2 + 1);
1054 for (x = p; x < p + l; x += 2) {
1057 a = unhexchar(x[0]);
1059 b = unhexchar(x[1]);
1063 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1070 char octchar(int x) {
1071 return '0' + (x & 7);
1074 int unoctchar(char c) {
1076 if (c >= '0' && c <= '7')
1082 char decchar(int x) {
1083 return '0' + (x % 10);
1086 int undecchar(char c) {
1088 if (c >= '0' && c <= '9')
1094 char *cescape(const char *s) {
1100 /* Does C style string escaping. */
1102 r = new(char, strlen(s)*4 + 1);
1106 for (f = s, t = r; *f; f++)
1152 /* For special chars we prefer octal over
1153 * hexadecimal encoding, simply because glib's
1154 * g_strescape() does the same */
1155 if ((*f < ' ') || (*f >= 127)) {
1157 *(t++) = octchar((unsigned char) *f >> 6);
1158 *(t++) = octchar((unsigned char) *f >> 3);
1159 *(t++) = octchar((unsigned char) *f);
1170 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1177 /* Undoes C style string escaping, and optionally prefixes it. */
1179 pl = prefix ? strlen(prefix) : 0;
1181 r = new(char, pl+length+1);
1186 memcpy(r, prefix, pl);
1188 for (f = s, t = r + pl; f < s + length; f++) {
1231 /* This is an extension of the XDG syntax files */
1236 /* hexadecimal encoding */
1239 a = unhexchar(f[1]);
1240 b = unhexchar(f[2]);
1242 if (a < 0 || b < 0) {
1243 /* Invalid escape code, let's take it literal then */
1247 *(t++) = (char) ((a << 4) | b);
1262 /* octal encoding */
1265 a = unoctchar(f[0]);
1266 b = unoctchar(f[1]);
1267 c = unoctchar(f[2]);
1269 if (a < 0 || b < 0 || c < 0) {
1270 /* Invalid escape code, let's take it literal then */
1274 *(t++) = (char) ((a << 6) | (b << 3) | c);
1282 /* premature end of string.*/
1287 /* Invalid escape code, let's take it literal then */
1299 char *cunescape_length(const char *s, size_t length) {
1300 return cunescape_length_with_prefix(s, length, NULL);
1303 char *cunescape(const char *s) {
1306 return cunescape_length(s, strlen(s));
1309 char *xescape(const char *s, const char *bad) {
1313 /* Escapes all chars in bad, in addition to \ and all special
1314 * chars, in \xFF style escaping. May be reversed with
1317 r = new(char, strlen(s) * 4 + 1);
1321 for (f = s, t = r; *f; f++) {
1323 if ((*f < ' ') || (*f >= 127) ||
1324 (*f == '\\') || strchr(bad, *f)) {
1327 *(t++) = hexchar(*f >> 4);
1328 *(t++) = hexchar(*f);
1338 char *ascii_strlower(char *t) {
1343 for (p = t; *p; p++)
1344 if (*p >= 'A' && *p <= 'Z')
1345 *p = *p - 'A' + 'a';
1350 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1354 filename[0] == '.' ||
1355 streq(filename, "lost+found") ||
1356 streq(filename, "aquota.user") ||
1357 streq(filename, "aquota.group") ||
1358 endswith(filename, ".rpmnew") ||
1359 endswith(filename, ".rpmsave") ||
1360 endswith(filename, ".rpmorig") ||
1361 endswith(filename, ".dpkg-old") ||
1362 endswith(filename, ".dpkg-new") ||
1363 endswith(filename, ".swp");
1366 bool ignore_file(const char *filename) {
1369 if (endswith(filename, "~"))
1372 return ignore_file_allow_backup(filename);
1375 int fd_nonblock(int fd, bool nonblock) {
1380 if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1384 flags |= O_NONBLOCK;
1386 flags &= ~O_NONBLOCK;
1388 if (fcntl(fd, F_SETFL, flags) < 0)
1394 int fd_cloexec(int fd, bool cloexec) {
1399 if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1403 flags |= FD_CLOEXEC;
1405 flags &= ~FD_CLOEXEC;
1407 if (fcntl(fd, F_SETFD, flags) < 0)
1413 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1416 assert(n_fdset == 0 || fdset);
1418 for (i = 0; i < n_fdset; i++)
1425 int close_all_fds(const int except[], unsigned n_except) {
1430 assert(n_except == 0 || except);
1432 d = opendir("/proc/self/fd");
1437 /* When /proc isn't available (for example in chroots)
1438 * the fallback is brute forcing through the fd
1441 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1442 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1444 if (fd_in_set(fd, except, n_except))
1447 if (close_nointr(fd) < 0)
1448 if (errno != EBADF && r == 0)
1455 while ((de = readdir(d))) {
1458 if (ignore_file(de->d_name))
1461 if (safe_atoi(de->d_name, &fd) < 0)
1462 /* Let's better ignore this, just in case */
1471 if (fd_in_set(fd, except, n_except))
1474 if (close_nointr(fd) < 0) {
1475 /* Valgrind has its own FD and doesn't want to have it closed */
1476 if (errno != EBADF && r == 0)
1485 bool chars_intersect(const char *a, const char *b) {
1488 /* Returns true if any of the chars in a are in b. */
1489 for (p = a; *p; p++)
1496 bool fstype_is_network(const char *fstype) {
1497 static const char table[] =
1507 return nulstr_contains(table, fstype);
1511 _cleanup_close_ int fd;
1513 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1519 TIOCL_GETKMSGREDIRECT,
1523 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1526 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1529 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1535 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1536 struct termios old_termios, new_termios;
1538 char line[LINE_MAX];
1543 if (tcgetattr(fileno(f), &old_termios) >= 0) {
1544 new_termios = old_termios;
1546 new_termios.c_lflag &= ~ICANON;
1547 new_termios.c_cc[VMIN] = 1;
1548 new_termios.c_cc[VTIME] = 0;
1550 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1553 if (t != (usec_t) -1) {
1554 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1555 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1560 k = fread(&c, 1, 1, f);
1562 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1568 *need_nl = c != '\n';
1575 if (t != (usec_t) -1)
1576 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1579 if (!fgets(line, sizeof(line), f))
1584 if (strlen(line) != 1)
1594 int ask(char *ret, const char *replies, const char *text, ...) {
1604 bool need_nl = true;
1607 fputs(ANSI_HIGHLIGHT_ON, stdout);
1614 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1618 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1621 if (r == -EBADMSG) {
1622 puts("Bad input, please try again.");
1633 if (strchr(replies, c)) {
1638 puts("Read unexpected character, please try again.");
1642 int reset_terminal_fd(int fd, bool switch_to_text) {
1643 struct termios termios;
1646 /* Set terminal to some sane defaults */
1650 /* We leave locked terminal attributes untouched, so that
1651 * Plymouth may set whatever it wants to set, and we don't
1652 * interfere with that. */
1654 /* Disable exclusive mode, just in case */
1655 ioctl(fd, TIOCNXCL);
1657 /* Switch to text mode */
1659 ioctl(fd, KDSETMODE, KD_TEXT);
1661 /* Enable console unicode mode */
1662 ioctl(fd, KDSKBMODE, K_UNICODE);
1664 if (tcgetattr(fd, &termios) < 0) {
1669 /* We only reset the stuff that matters to the software. How
1670 * hardware is set up we don't touch assuming that somebody
1671 * else will do that for us */
1673 termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1674 termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1675 termios.c_oflag |= ONLCR;
1676 termios.c_cflag |= CREAD;
1677 termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1679 termios.c_cc[VINTR] = 03; /* ^C */
1680 termios.c_cc[VQUIT] = 034; /* ^\ */
1681 termios.c_cc[VERASE] = 0177;
1682 termios.c_cc[VKILL] = 025; /* ^X */
1683 termios.c_cc[VEOF] = 04; /* ^D */
1684 termios.c_cc[VSTART] = 021; /* ^Q */
1685 termios.c_cc[VSTOP] = 023; /* ^S */
1686 termios.c_cc[VSUSP] = 032; /* ^Z */
1687 termios.c_cc[VLNEXT] = 026; /* ^V */
1688 termios.c_cc[VWERASE] = 027; /* ^W */
1689 termios.c_cc[VREPRINT] = 022; /* ^R */
1690 termios.c_cc[VEOL] = 0;
1691 termios.c_cc[VEOL2] = 0;
1693 termios.c_cc[VTIME] = 0;
1694 termios.c_cc[VMIN] = 1;
1696 if (tcsetattr(fd, TCSANOW, &termios) < 0)
1700 /* Just in case, flush all crap out */
1701 tcflush(fd, TCIOFLUSH);
1706 int reset_terminal(const char *name) {
1709 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1713 r = reset_terminal_fd(fd, true);
1714 close_nointr_nofail(fd);
1719 int open_terminal(const char *name, int mode) {
1724 * If a TTY is in the process of being closed opening it might
1725 * cause EIO. This is horribly awful, but unlikely to be
1726 * changed in the kernel. Hence we work around this problem by
1727 * retrying a couple of times.
1729 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1732 assert(!(mode & O_CREAT));
1735 fd = open(name, mode, 0);
1742 /* Max 1s in total */
1746 usleep(50 * USEC_PER_MSEC);
1755 close_nointr_nofail(fd);
1760 close_nointr_nofail(fd);
1767 int flush_fd(int fd) {
1768 struct pollfd pollfd = {
1778 r = poll(&pollfd, 1, 0);
1788 l = read(fd, buf, sizeof(buf));
1794 if (errno == EAGAIN)
1803 int acquire_terminal(
1807 bool ignore_tiocstty_eperm,
1810 int fd = -1, notify = -1, r = 0, wd = -1;
1815 /* We use inotify to be notified when the tty is closed. We
1816 * create the watch before checking if we can actually acquire
1817 * it, so that we don't lose any event.
1819 * Note: strictly speaking this actually watches for the
1820 * device being closed, it does *not* really watch whether a
1821 * tty loses its controlling process. However, unless some
1822 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1823 * its tty otherwise this will not become a problem. As long
1824 * as the administrator makes sure not configure any service
1825 * on the same tty as an untrusted user this should not be a
1826 * problem. (Which he probably should not do anyway.) */
1828 if (timeout != (usec_t) -1)
1829 ts = now(CLOCK_MONOTONIC);
1831 if (!fail && !force) {
1832 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1838 wd = inotify_add_watch(notify, name, IN_CLOSE);
1846 struct sigaction sa_old, sa_new = {
1847 .sa_handler = SIG_IGN,
1848 .sa_flags = SA_RESTART,
1852 r = flush_fd(notify);
1857 /* We pass here O_NOCTTY only so that we can check the return
1858 * value TIOCSCTTY and have a reliable way to figure out if we
1859 * successfully became the controlling process of the tty */
1860 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1864 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1865 * if we already own the tty. */
1866 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1868 /* First, try to get the tty */
1869 if (ioctl(fd, TIOCSCTTY, force) < 0)
1872 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1874 /* Sometimes it makes sense to ignore TIOCSCTTY
1875 * returning EPERM, i.e. when very likely we already
1876 * are have this controlling terminal. */
1877 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1880 if (r < 0 && (force || fail || r != -EPERM)) {
1889 assert(notify >= 0);
1892 uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1894 struct inotify_event *e;
1896 if (timeout != (usec_t) -1) {
1899 n = now(CLOCK_MONOTONIC);
1900 if (ts + timeout < n) {
1905 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1915 l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1918 if (errno == EINTR || errno == EAGAIN)
1925 e = (struct inotify_event*) inotify_buffer;
1930 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
1935 step = sizeof(struct inotify_event) + e->len;
1936 assert(step <= (size_t) l);
1938 e = (struct inotify_event*) ((uint8_t*) e + step);
1945 /* We close the tty fd here since if the old session
1946 * ended our handle will be dead. It's important that
1947 * we do this after sleeping, so that we don't enter
1948 * an endless loop. */
1949 close_nointr_nofail(fd);
1953 close_nointr_nofail(notify);
1955 r = reset_terminal_fd(fd, true);
1957 log_warning("Failed to reset terminal: %s", strerror(-r));
1963 close_nointr_nofail(fd);
1966 close_nointr_nofail(notify);
1971 int release_terminal(void) {
1973 struct sigaction sa_old, sa_new = {
1974 .sa_handler = SIG_IGN,
1975 .sa_flags = SA_RESTART,
1977 _cleanup_close_ int fd;
1979 fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
1983 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1984 * by our own TIOCNOTTY */
1985 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1987 if (ioctl(fd, TIOCNOTTY) < 0)
1990 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1995 int sigaction_many(const struct sigaction *sa, ...) {
2000 while ((sig = va_arg(ap, int)) > 0)
2001 if (sigaction(sig, sa, NULL) < 0)
2008 int ignore_signals(int sig, ...) {
2009 struct sigaction sa = {
2010 .sa_handler = SIG_IGN,
2011 .sa_flags = SA_RESTART,
2017 if (sigaction(sig, &sa, NULL) < 0)
2021 while ((sig = va_arg(ap, int)) > 0)
2022 if (sigaction(sig, &sa, NULL) < 0)
2029 int default_signals(int sig, ...) {
2030 struct sigaction sa = {
2031 .sa_handler = SIG_DFL,
2032 .sa_flags = SA_RESTART,
2037 if (sigaction(sig, &sa, NULL) < 0)
2041 while ((sig = va_arg(ap, int)) > 0)
2042 if (sigaction(sig, &sa, NULL) < 0)
2049 int close_pipe(int p[]) {
2055 a = close_nointr(p[0]);
2060 b = close_nointr(p[1]);
2064 return a < 0 ? a : b;
2067 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2074 while (nbytes > 0) {
2077 k = read(fd, p, nbytes);
2078 if (k < 0 && errno == EINTR)
2081 if (k < 0 && errno == EAGAIN && do_poll) {
2083 /* We knowingly ignore any return value here,
2084 * and expect that any error/EOF is reported
2087 fd_wait_for_event(fd, POLLIN, (usec_t) -1);
2092 return n > 0 ? n : (k < 0 ? -errno : 0);
2102 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2103 const uint8_t *p = buf;
2109 while (nbytes > 0) {
2112 k = write(fd, p, nbytes);
2113 if (k < 0 && errno == EINTR)
2116 if (k < 0 && errno == EAGAIN && do_poll) {
2118 /* We knowingly ignore any return value here,
2119 * and expect that any error/EOF is reported
2122 fd_wait_for_event(fd, POLLOUT, (usec_t) -1);
2127 return n > 0 ? n : (k < 0 ? -errno : 0);
2137 int parse_bytes(const char *t, off_t *bytes) {
2138 static const struct {
2140 unsigned long long factor;
2144 { "M", 1024ULL*1024ULL },
2145 { "G", 1024ULL*1024ULL*1024ULL },
2146 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2147 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2148 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2153 unsigned long long r = 0;
2165 l = strtoll(p, &e, 10);
2176 e += strspn(e, WHITESPACE);
2178 for (i = 0; i < ELEMENTSOF(table); i++)
2179 if (startswith(e, table[i].suffix)) {
2180 unsigned long long tmp;
2181 if ((unsigned long long) l > ULLONG_MAX / table[i].factor)
2183 tmp = l * table[i].factor;
2184 if (tmp > ULLONG_MAX - r)
2188 if ((unsigned long long) (off_t) r != r)
2191 p = e + strlen(table[i].suffix);
2195 if (i >= ELEMENTSOF(table))
2205 int make_stdio(int fd) {
2210 r = dup3(fd, STDIN_FILENO, 0);
2211 s = dup3(fd, STDOUT_FILENO, 0);
2212 t = dup3(fd, STDERR_FILENO, 0);
2215 close_nointr_nofail(fd);
2217 if (r < 0 || s < 0 || t < 0)
2220 /* We rely here that the new fd has O_CLOEXEC not set */
2225 int make_null_stdio(void) {
2228 null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2232 return make_stdio(null_fd);
2235 bool is_device_path(const char *path) {
2237 /* Returns true on paths that refer to a device, either in
2238 * sysfs or in /dev */
2241 path_startswith(path, "/dev/") ||
2242 path_startswith(path, "/sys/");
2245 int dir_is_empty(const char *path) {
2246 _cleanup_closedir_ DIR *d;
2257 if (!de && errno != 0)
2263 if (!ignore_file(de->d_name))
2268 char* dirname_malloc(const char *path) {
2269 char *d, *dir, *dir2;
2286 int dev_urandom(void *p, size_t n) {
2287 _cleanup_close_ int fd;
2290 fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2292 return errno == ENOENT ? -ENOSYS : -errno;
2294 k = loop_read(fd, p, n, true);
2297 if ((size_t) k != n)
2303 void random_bytes(void *p, size_t n) {
2304 static bool srand_called = false;
2308 r = dev_urandom(p, n);
2312 /* If some idiot made /dev/urandom unavailable to us, he'll
2313 * get a PRNG instead. */
2315 if (!srand_called) {
2318 #ifdef HAVE_SYS_AUXV_H
2319 /* The kernel provides us with a bit of entropy in
2320 * auxv, so let's try to make use of that to seed the
2321 * pseudo-random generator. It's better than
2326 auxv = (void*) getauxval(AT_RANDOM);
2328 x ^= *(unsigned*) auxv;
2331 x ^= (unsigned) now(CLOCK_REALTIME);
2332 x ^= (unsigned) gettid();
2335 srand_called = true;
2338 for (q = p; q < (uint8_t*) p + n; q ++)
2342 void rename_process(const char name[8]) {
2345 /* This is a like a poor man's setproctitle(). It changes the
2346 * comm field, argv[0], and also the glibc's internally used
2347 * name of the process. For the first one a limit of 16 chars
2348 * applies, to the second one usually one of 10 (i.e. length
2349 * of "/sbin/init"), to the third one one of 7 (i.e. length of
2350 * "systemd"). If you pass a longer string it will be
2353 prctl(PR_SET_NAME, name);
2355 if (program_invocation_name)
2356 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2358 if (saved_argc > 0) {
2362 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2364 for (i = 1; i < saved_argc; i++) {
2368 memzero(saved_argv[i], strlen(saved_argv[i]));
2373 void sigset_add_many(sigset_t *ss, ...) {
2380 while ((sig = va_arg(ap, int)) > 0)
2381 assert_se(sigaddset(ss, sig) == 0);
2385 char* gethostname_malloc(void) {
2388 assert_se(uname(&u) >= 0);
2390 if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2391 return strdup(u.nodename);
2393 return strdup(u.sysname);
2396 bool hostname_is_set(void) {
2399 assert_se(uname(&u) >= 0);
2401 return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2404 static char *lookup_uid(uid_t uid) {
2407 _cleanup_free_ char *buf = NULL;
2408 struct passwd pwbuf, *pw = NULL;
2410 /* Shortcut things to avoid NSS lookups */
2412 return strdup("root");
2414 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2418 buf = malloc(bufsize);
2422 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2423 return strdup(pw->pw_name);
2425 if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
2431 char* getlogname_malloc(void) {
2435 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2440 return lookup_uid(uid);
2443 char *getusername_malloc(void) {
2450 return lookup_uid(getuid());
2453 int getttyname_malloc(int fd, char **r) {
2454 char path[PATH_MAX], *c;
2459 k = ttyname_r(fd, path, sizeof(path));
2465 c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2473 int getttyname_harder(int fd, char **r) {
2477 k = getttyname_malloc(fd, &s);
2481 if (streq(s, "tty")) {
2483 return get_ctty(0, NULL, r);
2490 int get_ctty_devnr(pid_t pid, dev_t *d) {
2492 _cleanup_free_ char *line = NULL;
2494 unsigned long ttynr;
2498 p = procfs_file_alloca(pid, "stat");
2499 r = read_one_line_file(p, &line);
2503 p = strrchr(line, ')');
2513 "%*d " /* session */
2518 if (major(ttynr) == 0 && minor(ttynr) == 0)
2527 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2529 char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *s, *b, *p;
2534 k = get_ctty_devnr(pid, &devnr);
2538 snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2540 k = readlink_malloc(fn, &s);
2546 /* This is an ugly hack */
2547 if (major(devnr) == 136) {
2548 if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
2558 /* Probably something like the ptys which have no
2559 * symlink in /dev/char. Let's return something
2560 * vaguely useful. */
2573 if (startswith(s, "/dev/"))
2575 else if (startswith(s, "../"))
2593 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2599 /* This returns the first error we run into, but nevertheless
2600 * tries to go on. This closes the passed fd. */
2604 close_nointr_nofail(fd);
2606 return errno == ENOENT ? 0 : -errno;
2611 bool is_dir, keep_around;
2617 if (!de && errno != 0) {
2626 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2629 if (de->d_type == DT_UNKNOWN ||
2631 (de->d_type == DT_DIR && root_dev)) {
2632 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2633 if (ret == 0 && errno != ENOENT)
2638 is_dir = S_ISDIR(st.st_mode);
2641 (st.st_uid == 0 || st.st_uid == getuid()) &&
2642 (st.st_mode & S_ISVTX);
2644 is_dir = de->d_type == DT_DIR;
2645 keep_around = false;
2651 /* if root_dev is set, remove subdirectories only, if device is same as dir */
2652 if (root_dev && st.st_dev != root_dev->st_dev)
2655 subdir_fd = openat(fd, de->d_name,
2656 O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2657 if (subdir_fd < 0) {
2658 if (ret == 0 && errno != ENOENT)
2663 r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2664 if (r < 0 && ret == 0)
2668 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2669 if (ret == 0 && errno != ENOENT)
2673 } else if (!only_dirs && !keep_around) {
2675 if (unlinkat(fd, de->d_name, 0) < 0) {
2676 if (ret == 0 && errno != ENOENT)
2687 _pure_ static int is_temporary_fs(struct statfs *s) {
2690 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2691 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2694 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2699 if (fstatfs(fd, &s) < 0) {
2700 close_nointr_nofail(fd);
2704 /* We refuse to clean disk file systems with this call. This
2705 * is extra paranoia just to be sure we never ever remove
2707 if (!is_temporary_fs(&s)) {
2708 log_error("Attempted to remove disk file system, and we can't allow that.");
2709 close_nointr_nofail(fd);
2713 return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2716 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2722 /* We refuse to clean the root file system with this
2723 * call. This is extra paranoia to never cause a really
2724 * seriously broken system. */
2725 if (path_equal(path, "/")) {
2726 log_error("Attempted to remove entire root file system, and we can't allow that.");
2730 fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2733 if (errno != ENOTDIR)
2737 if (statfs(path, &s) < 0)
2740 if (!is_temporary_fs(&s)) {
2741 log_error("Attempted to remove disk file system, and we can't allow that.");
2746 if (delete_root && !only_dirs)
2747 if (unlink(path) < 0 && errno != ENOENT)
2754 if (fstatfs(fd, &s) < 0) {
2755 close_nointr_nofail(fd);
2759 if (!is_temporary_fs(&s)) {
2760 log_error("Attempted to remove disk file system, and we can't allow that.");
2761 close_nointr_nofail(fd);
2766 r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2769 if (honour_sticky && file_is_priv_sticky(path) > 0)
2772 if (rmdir(path) < 0 && errno != ENOENT) {
2781 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2782 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2785 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2786 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2789 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2792 /* Under the assumption that we are running privileged we
2793 * first change the access mode and only then hand out
2794 * ownership to avoid a window where access is too open. */
2796 if (mode != (mode_t) -1)
2797 if (chmod(path, mode) < 0)
2800 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2801 if (chown(path, uid, gid) < 0)
2807 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2810 /* Under the assumption that we are running privileged we
2811 * first change the access mode and only then hand out
2812 * ownership to avoid a window where access is too open. */
2814 if (mode != (mode_t) -1)
2815 if (fchmod(fd, mode) < 0)
2818 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2819 if (fchown(fd, uid, gid) < 0)
2825 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2829 /* Allocates the cpuset in the right size */
2832 if (!(r = CPU_ALLOC(n)))
2835 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2836 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2846 if (errno != EINVAL)
2853 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2854 static const char status_indent[] = " "; /* "[" STATUS "] " */
2855 _cleanup_free_ char *s = NULL;
2856 _cleanup_close_ int fd = -1;
2857 struct iovec iovec[6] = {};
2859 static bool prev_ephemeral;
2863 /* This is independent of logging, as status messages are
2864 * optional and go exclusively to the console. */
2866 if (vasprintf(&s, format, ap) < 0)
2869 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2882 sl = status ? sizeof(status_indent)-1 : 0;
2888 e = ellipsize(s, emax, 75);
2896 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2897 prev_ephemeral = ephemeral;
2900 if (!isempty(status)) {
2901 IOVEC_SET_STRING(iovec[n++], "[");
2902 IOVEC_SET_STRING(iovec[n++], status);
2903 IOVEC_SET_STRING(iovec[n++], "] ");
2905 IOVEC_SET_STRING(iovec[n++], status_indent);
2908 IOVEC_SET_STRING(iovec[n++], s);
2910 IOVEC_SET_STRING(iovec[n++], "\n");
2912 if (writev(fd, iovec, n) < 0)
2918 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2924 va_start(ap, format);
2925 r = status_vprintf(status, ellipse, ephemeral, format, ap);
2931 char *replace_env(const char *format, char **env) {
2938 const char *e, *word = format;
2943 for (e = format; *e; e ++) {
2954 if (!(k = strnappend(r, word, e-word-1)))
2963 } else if (*e == '$') {
2964 if (!(k = strnappend(r, word, e-word)))
2980 t = strempty(strv_env_get_n(env, word+2, e-word-2));
2982 k = strappend(r, t);
2996 if (!(k = strnappend(r, word, e-word)))
3007 char **replace_env_argv(char **argv, char **env) {
3009 unsigned k = 0, l = 0;
3011 l = strv_length(argv);
3013 if (!(r = new(char*, l+1)))
3016 STRV_FOREACH(i, argv) {
3018 /* If $FOO appears as single word, replace it by the split up variable */
3019 if ((*i)[0] == '$' && (*i)[1] != '{') {
3024 e = strv_env_get(env, *i+1);
3027 if (!(m = strv_split_quoted(e))) {
3038 if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3047 memcpy(r + k, m, q * sizeof(char*));
3055 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3056 if (!(r[k++] = replace_env(*i, env))) {
3066 int fd_columns(int fd) {
3067 struct winsize ws = {};
3069 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3078 unsigned columns(void) {
3082 if (_likely_(cached_columns > 0))
3083 return cached_columns;
3086 e = getenv("COLUMNS");
3091 c = fd_columns(STDOUT_FILENO);
3100 int fd_lines(int fd) {
3101 struct winsize ws = {};
3103 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3112 unsigned lines(void) {
3116 if (_likely_(cached_lines > 0))
3117 return cached_lines;
3120 e = getenv("LINES");
3125 l = fd_lines(STDOUT_FILENO);
3131 return cached_lines;
3134 /* intended to be used as a SIGWINCH sighandler */
3135 void columns_lines_cache_reset(int signum) {
3141 static int cached_on_tty = -1;
3143 if (_unlikely_(cached_on_tty < 0))
3144 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3146 return cached_on_tty;
3149 int running_in_chroot(void) {
3150 struct stat a = {}, b = {};
3152 /* Only works as root */
3153 if (stat("/proc/1/root", &a) < 0)
3156 if (stat("/", &b) < 0)
3160 a.st_dev != b.st_dev ||
3161 a.st_ino != b.st_ino;
3164 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3169 assert(percent <= 100);
3170 assert(new_length >= 3);
3172 if (old_length <= 3 || old_length <= new_length)
3173 return strndup(s, old_length);
3175 r = new0(char, new_length+1);
3179 x = (new_length * percent) / 100;
3181 if (x > new_length - 3)
3189 s + old_length - (new_length - x - 3),
3190 new_length - x - 3);
3195 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3199 unsigned k, len, len2;
3202 assert(percent <= 100);
3203 assert(new_length >= 3);
3205 /* if no multibyte characters use ascii_ellipsize_mem for speed */
3206 if (ascii_is_valid(s))
3207 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3209 if (old_length <= 3 || old_length <= new_length)
3210 return strndup(s, old_length);
3212 x = (new_length * percent) / 100;
3214 if (x > new_length - 3)
3218 for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3221 c = utf8_encoded_to_unichar(i);
3224 k += unichar_iswide(c) ? 2 : 1;
3227 if (k > x) /* last character was wide and went over quota */
3230 for (j = s + old_length; k < new_length && j > i; ) {
3233 j = utf8_prev_char(j);
3234 c = utf8_encoded_to_unichar(j);
3237 k += unichar_iswide(c) ? 2 : 1;
3241 /* we don't actually need to ellipsize */
3243 return memdup(s, old_length + 1);
3245 /* make space for ellipsis */
3246 j = utf8_next_char(j);
3249 len2 = s + old_length - j;
3250 e = new(char, len + 3 + len2 + 1);
3255 printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3256 old_length, new_length, x, len, len2, k);
3260 e[len] = 0xe2; /* tri-dot ellipsis: … */
3264 memcpy(e + len + 3, j, len2 + 1);
3269 char *ellipsize(const char *s, size_t length, unsigned percent) {
3270 return ellipsize_mem(s, strlen(s), length, percent);
3273 int touch(const char *path) {
3278 /* This just opens the file for writing, ensuring it
3279 * exists. It doesn't call utimensat() the way /usr/bin/touch
3282 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3286 close_nointr_nofail(fd);
3290 char *unquote(const char *s, const char* quotes) {
3294 /* This is rather stupid, simply removes the heading and
3295 * trailing quotes if there is one. Doesn't care about
3296 * escaping or anything. We should make this smarter one
3303 if (strchr(quotes, s[0]) && s[l-1] == s[0])
3304 return strndup(s+1, l-2);
3309 char *normalize_env_assignment(const char *s) {
3310 _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3313 eq = strchr(s, '=');
3325 memmove(r, t, strlen(t) + 1);
3329 name = strndup(s, eq - s);
3337 value = unquote(strstrip(p), QUOTES);
3341 if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3347 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3358 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3370 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3377 r = wait_for_terminate(pid, &status);
3379 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3383 if (status.si_code == CLD_EXITED) {
3384 if (status.si_status != 0) {
3385 log_warning("%s failed with error code %i.", name, status.si_status);
3386 return status.si_status;
3389 log_debug("%s succeeded.", name);
3392 } else if (status.si_code == CLD_KILLED ||
3393 status.si_code == CLD_DUMPED) {
3395 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3399 log_warning("%s failed due to unknown reason.", name);
3403 noreturn void freeze(void) {
3405 /* Make sure nobody waits for us on a socket anymore */
3406 close_all_fds(NULL, 0);
3414 bool null_or_empty(struct stat *st) {
3417 if (S_ISREG(st->st_mode) && st->st_size <= 0)
3420 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3426 int null_or_empty_path(const char *fn) {
3431 if (stat(fn, &st) < 0)
3434 return null_or_empty(&st);
3437 DIR *xopendirat(int fd, const char *name, int flags) {
3441 assert(!(flags & O_CREAT));
3443 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3449 close_nointr_nofail(nfd);
3456 int signal_from_string_try_harder(const char *s) {
3460 signo = signal_from_string(s);
3462 if (startswith(s, "SIG"))
3463 return signal_from_string(s+3);
3468 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3469 _cleanup_free_ char *t = NULL, *u = NULL;
3473 u = unquote(tagvalue, "\"\'");
3477 enc_len = strlen(u) * 4 + 1;
3478 t = new(char, enc_len);
3482 if (encode_devnode_name(u, t, enc_len) < 0)
3485 if (asprintf(&dn, "/dev/disk/by-%s/%s", by, t) < 0)
3491 char *fstab_node_to_udev_node(const char *p) {
3494 if (startswith(p, "LABEL="))
3495 return tag_to_udev_node(p+6, "label");
3497 if (startswith(p, "UUID="))
3498 return tag_to_udev_node(p+5, "uuid");
3500 if (startswith(p, "PARTUUID="))
3501 return tag_to_udev_node(p+9, "partuuid");
3503 if (startswith(p, "PARTLABEL="))
3504 return tag_to_udev_node(p+10, "partlabel");
3509 bool tty_is_vc(const char *tty) {
3512 if (startswith(tty, "/dev/"))
3515 return vtnr_from_tty(tty) >= 0;
3518 bool tty_is_console(const char *tty) {
3521 if (startswith(tty, "/dev/"))
3524 return streq(tty, "console");
3527 int vtnr_from_tty(const char *tty) {
3532 if (startswith(tty, "/dev/"))
3535 if (!startswith(tty, "tty") )
3538 if (tty[3] < '0' || tty[3] > '9')
3541 r = safe_atoi(tty+3, &i);
3545 if (i < 0 || i > 63)
3551 char *resolve_dev_console(char **active) {
3554 /* Resolve where /dev/console is pointing to, if /sys is actually ours
3555 * (i.e. not read-only-mounted which is a sign for container setups) */
3557 if (path_is_read_only_fs("/sys") > 0)
3560 if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3563 /* If multiple log outputs are configured the last one is what
3564 * /dev/console points to */
3565 tty = strrchr(*active, ' ');
3571 if (streq(tty, "tty0")) {
3574 /* Get the active VC (e.g. tty1) */
3575 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3577 tty = *active = tmp;
3584 bool tty_is_vc_resolve(const char *tty) {
3585 _cleanup_free_ char *active = NULL;
3589 if (startswith(tty, "/dev/"))
3592 if (streq(tty, "console")) {
3593 tty = resolve_dev_console(&active);
3598 return tty_is_vc(tty);
3601 const char *default_term_for_tty(const char *tty) {
3604 return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3607 bool dirent_is_file(const struct dirent *de) {
3610 if (ignore_file(de->d_name))
3613 if (de->d_type != DT_REG &&
3614 de->d_type != DT_LNK &&
3615 de->d_type != DT_UNKNOWN)
3621 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3624 if (de->d_type != DT_REG &&
3625 de->d_type != DT_LNK &&
3626 de->d_type != DT_UNKNOWN)
3629 if (ignore_file_allow_backup(de->d_name))
3632 return endswith(de->d_name, suffix);
3635 void execute_directory(const char *directory, DIR *d, char *argv[]) {
3638 Hashmap *pids = NULL;
3642 /* Executes all binaries in a directory in parallel and
3643 * waits for them to finish. */
3646 if (!(_d = opendir(directory))) {
3648 if (errno == ENOENT)
3651 log_error("Failed to enumerate directory %s: %m", directory);
3658 if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
3659 log_error("Failed to allocate set.");
3663 while ((de = readdir(d))) {
3668 if (!dirent_is_file(de))
3671 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3676 if ((pid = fork()) < 0) {
3677 log_error("Failed to fork: %m");
3695 log_error("Failed to execute %s: %m", path);
3696 _exit(EXIT_FAILURE);
3699 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
3701 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
3702 log_error("Failed to add PID to set: %s", strerror(-k));
3707 while (!hashmap_isempty(pids)) {
3708 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
3712 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
3717 log_error("waitid() failed: %m");
3721 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
3722 if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
3723 if (si.si_code == CLD_EXITED)
3724 log_error("%s exited with exit status %i.", path, si.si_status);
3726 log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
3728 log_debug("%s exited successfully.", path);
3739 hashmap_free_free(pids);
3742 int kill_and_sigcont(pid_t pid, int sig) {
3745 r = kill(pid, sig) < 0 ? -errno : 0;
3753 bool nulstr_contains(const char*nulstr, const char *needle) {
3759 NULSTR_FOREACH(i, nulstr)
3760 if (streq(i, needle))
3766 bool plymouth_running(void) {
3767 return access("/run/plymouth/pid", F_OK) >= 0;
3770 char* strshorten(char *s, size_t l) {
3779 static bool hostname_valid_char(char c) {
3781 (c >= 'a' && c <= 'z') ||
3782 (c >= 'A' && c <= 'Z') ||
3783 (c >= '0' && c <= '9') ||
3789 bool hostname_is_valid(const char *s) {
3796 for (p = s, dot = true; *p; p++) {
3803 if (!hostname_valid_char(*p))
3813 if (p-s > HOST_NAME_MAX)
3819 char* hostname_cleanup(char *s, bool lowercase) {
3823 for (p = s, d = s, dot = true; *p; p++) {
3830 } else if (hostname_valid_char(*p)) {
3831 *(d++) = lowercase ? tolower(*p) : *p;
3842 strshorten(s, HOST_NAME_MAX);
3847 int pipe_eof(int fd) {
3848 struct pollfd pollfd = {
3850 .events = POLLIN|POLLHUP,
3855 r = poll(&pollfd, 1, 0);
3862 return pollfd.revents & POLLHUP;
3865 int fd_wait_for_event(int fd, int event, usec_t t) {
3867 struct pollfd pollfd = {
3875 r = ppoll(&pollfd, 1, t == (usec_t) -1 ? NULL : timespec_store(&ts, t), NULL);
3882 return pollfd.revents;
3885 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3896 t = new(char, strlen(path) + 1 + 6 + 1);
3900 fn = basename(path);
3904 stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
3906 fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
3912 f = fdopen(fd, "we");
3925 int terminal_vhangup_fd(int fd) {
3928 if (ioctl(fd, TIOCVHANGUP) < 0)
3934 int terminal_vhangup(const char *name) {
3937 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
3941 r = terminal_vhangup_fd(fd);
3942 close_nointr_nofail(fd);
3947 int vt_disallocate(const char *name) {
3951 /* Deallocate the VT if possible. If not possible
3952 * (i.e. because it is the active one), at least clear it
3953 * entirely (including the scrollback buffer) */
3955 if (!startswith(name, "/dev/"))
3958 if (!tty_is_vc(name)) {
3959 /* So this is not a VT. I guess we cannot deallocate
3960 * it then. But let's at least clear the screen */
3962 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
3967 "\033[r" /* clear scrolling region */
3968 "\033[H" /* move home */
3969 "\033[2J", /* clear screen */
3971 close_nointr_nofail(fd);
3976 if (!startswith(name, "/dev/tty"))
3979 r = safe_atou(name+8, &u);
3986 /* Try to deallocate */
3987 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
3991 r = ioctl(fd, VT_DISALLOCATE, u);
3992 close_nointr_nofail(fd);
4000 /* Couldn't deallocate, so let's clear it fully with
4002 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4007 "\033[r" /* clear scrolling region */
4008 "\033[H" /* move home */
4009 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4011 close_nointr_nofail(fd);
4016 int copy_file(const char *from, const char *to, int flags) {
4017 _cleanup_close_ int fdf = -1;
4023 fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4027 fdt = open(to, flags|O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
4035 n = read(fdf, buf, sizeof(buf));
4049 k = loop_write(fdt, buf, n, false);
4051 r = k < 0 ? k : (errno ? -errno : -EIO);
4060 r = close_nointr(fdt);
4070 int symlink_atomic(const char *from, const char *to) {
4072 _cleanup_free_ char *t;
4082 t = new(char, strlen(to) + 1 + 16 + 1);
4090 x = stpcpy(t+k+1, fn);
4093 for (i = 0; i < 16; i++) {
4094 *(x++) = hexchar(u & 0xF);
4100 if (symlink(from, t) < 0)
4103 if (rename(t, to) < 0) {
4112 bool display_is_local(const char *display) {
4116 display[0] == ':' &&
4117 display[1] >= '0' &&
4121 int socket_from_display(const char *display, char **path) {
4128 if (!display_is_local(display))
4131 k = strspn(display+1, "0123456789");
4133 f = new(char, sizeof("/tmp/.X11-unix/X") + k);
4137 c = stpcpy(f, "/tmp/.X11-unix/X");
4138 memcpy(c, display+1, k);
4147 const char **username,
4148 uid_t *uid, gid_t *gid,
4150 const char **shell) {
4158 /* We enforce some special rules for uid=0: in order to avoid
4159 * NSS lookups for root we hardcode its data. */
4161 if (streq(*username, "root") || streq(*username, "0")) {
4179 if (parse_uid(*username, &u) >= 0) {
4183 /* If there are multiple users with the same id, make
4184 * sure to leave $USER to the configured value instead
4185 * of the first occurrence in the database. However if
4186 * the uid was configured by a numeric uid, then let's
4187 * pick the real username from /etc/passwd. */
4189 *username = p->pw_name;
4192 p = getpwnam(*username);
4196 return errno > 0 ? -errno : -ESRCH;
4208 *shell = p->pw_shell;
4213 char* uid_to_name(uid_t uid) {
4218 return strdup("root");
4222 return strdup(p->pw_name);
4224 if (asprintf(&r, "%lu", (unsigned long) uid) < 0)
4230 char* gid_to_name(gid_t gid) {
4235 return strdup("root");
4239 return strdup(p->gr_name);
4241 if (asprintf(&r, "%lu", (unsigned long) gid) < 0)
4247 int get_group_creds(const char **groupname, gid_t *gid) {
4253 /* We enforce some special rules for gid=0: in order to avoid
4254 * NSS lookups for root we hardcode its data. */
4256 if (streq(*groupname, "root") || streq(*groupname, "0")) {
4257 *groupname = "root";
4265 if (parse_gid(*groupname, &id) >= 0) {
4270 *groupname = g->gr_name;
4273 g = getgrnam(*groupname);
4277 return errno > 0 ? -errno : -ESRCH;
4285 int in_gid(gid_t gid) {
4287 int ngroups_max, r, i;
4289 if (getgid() == gid)
4292 if (getegid() == gid)
4295 ngroups_max = sysconf(_SC_NGROUPS_MAX);
4296 assert(ngroups_max > 0);
4298 gids = alloca(sizeof(gid_t) * ngroups_max);
4300 r = getgroups(ngroups_max, gids);
4304 for (i = 0; i < r; i++)
4311 int in_group(const char *name) {
4315 r = get_group_creds(&name, &gid);
4322 int glob_exists(const char *path) {
4323 _cleanup_globfree_ glob_t g = {};
4329 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4331 if (k == GLOB_NOMATCH)
4333 else if (k == GLOB_NOSPACE)
4336 return !strv_isempty(g.gl_pathv);
4338 return errno ? -errno : -EIO;
4341 int glob_extend(char ***strv, const char *path) {
4342 _cleanup_globfree_ glob_t g = {};
4347 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4349 if (k == GLOB_NOMATCH)
4351 else if (k == GLOB_NOSPACE)
4353 else if (k != 0 || strv_isempty(g.gl_pathv))
4354 return errno ? -errno : -EIO;
4356 STRV_FOREACH(p, g.gl_pathv) {
4357 k = strv_extend(strv, *p);
4365 int dirent_ensure_type(DIR *d, struct dirent *de) {
4371 if (de->d_type != DT_UNKNOWN)
4374 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4378 S_ISREG(st.st_mode) ? DT_REG :
4379 S_ISDIR(st.st_mode) ? DT_DIR :
4380 S_ISLNK(st.st_mode) ? DT_LNK :
4381 S_ISFIFO(st.st_mode) ? DT_FIFO :
4382 S_ISSOCK(st.st_mode) ? DT_SOCK :
4383 S_ISCHR(st.st_mode) ? DT_CHR :
4384 S_ISBLK(st.st_mode) ? DT_BLK :
4390 int in_search_path(const char *path, char **search) {
4392 _cleanup_free_ char *parent = NULL;
4395 r = path_get_parent(path, &parent);
4399 STRV_FOREACH(i, search)
4400 if (path_equal(parent, *i))
4406 int get_files_in_directory(const char *path, char ***list) {
4407 _cleanup_closedir_ DIR *d = NULL;
4408 size_t bufsize = 0, n = 0;
4409 _cleanup_strv_free_ char **l = NULL;
4413 /* Returns all files in a directory in *list, and the number
4414 * of files as return value. If list is NULL returns only the
4426 if (!de && errno != 0)
4431 dirent_ensure_type(d, de);
4433 if (!dirent_is_file(de))
4437 /* one extra slot is needed for the terminating NULL */
4438 if (!GREEDY_REALLOC(l, bufsize, n + 2))
4441 l[n] = strdup(de->d_name);
4452 l = NULL; /* avoid freeing */
4458 char *strjoin(const char *x, ...) {
4472 t = va_arg(ap, const char *);
4477 if (n > ((size_t) -1) - l) {
4501 t = va_arg(ap, const char *);
4515 bool is_main_thread(void) {
4516 static thread_local int cached = 0;
4518 if (_unlikely_(cached == 0))
4519 cached = getpid() == gettid() ? 1 : -1;
4524 int block_get_whole_disk(dev_t d, dev_t *ret) {
4531 /* If it has a queue this is good enough for us */
4532 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4535 r = access(p, F_OK);
4543 /* If it is a partition find the originating device */
4544 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4547 r = access(p, F_OK);
4553 /* Get parent dev_t */
4554 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4557 r = read_one_line_file(p, &s);
4563 r = sscanf(s, "%u:%u", &m, &n);
4569 /* Only return this if it is really good enough for us. */
4570 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4573 r = access(p, F_OK);
4577 *ret = makedev(m, n);
4584 int file_is_priv_sticky(const char *p) {
4589 if (lstat(p, &st) < 0)
4593 (st.st_uid == 0 || st.st_uid == getuid()) &&
4594 (st.st_mode & S_ISVTX);
4597 static const char *const ioprio_class_table[] = {
4598 [IOPRIO_CLASS_NONE] = "none",
4599 [IOPRIO_CLASS_RT] = "realtime",
4600 [IOPRIO_CLASS_BE] = "best-effort",
4601 [IOPRIO_CLASS_IDLE] = "idle"
4604 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4606 static const char *const sigchld_code_table[] = {
4607 [CLD_EXITED] = "exited",
4608 [CLD_KILLED] = "killed",
4609 [CLD_DUMPED] = "dumped",
4610 [CLD_TRAPPED] = "trapped",
4611 [CLD_STOPPED] = "stopped",
4612 [CLD_CONTINUED] = "continued",
4615 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4617 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4618 [LOG_FAC(LOG_KERN)] = "kern",
4619 [LOG_FAC(LOG_USER)] = "user",
4620 [LOG_FAC(LOG_MAIL)] = "mail",
4621 [LOG_FAC(LOG_DAEMON)] = "daemon",
4622 [LOG_FAC(LOG_AUTH)] = "auth",
4623 [LOG_FAC(LOG_SYSLOG)] = "syslog",
4624 [LOG_FAC(LOG_LPR)] = "lpr",
4625 [LOG_FAC(LOG_NEWS)] = "news",
4626 [LOG_FAC(LOG_UUCP)] = "uucp",
4627 [LOG_FAC(LOG_CRON)] = "cron",
4628 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4629 [LOG_FAC(LOG_FTP)] = "ftp",
4630 [LOG_FAC(LOG_LOCAL0)] = "local0",
4631 [LOG_FAC(LOG_LOCAL1)] = "local1",
4632 [LOG_FAC(LOG_LOCAL2)] = "local2",
4633 [LOG_FAC(LOG_LOCAL3)] = "local3",
4634 [LOG_FAC(LOG_LOCAL4)] = "local4",
4635 [LOG_FAC(LOG_LOCAL5)] = "local5",
4636 [LOG_FAC(LOG_LOCAL6)] = "local6",
4637 [LOG_FAC(LOG_LOCAL7)] = "local7"
4640 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4642 static const char *const log_level_table[] = {
4643 [LOG_EMERG] = "emerg",
4644 [LOG_ALERT] = "alert",
4645 [LOG_CRIT] = "crit",
4647 [LOG_WARNING] = "warning",
4648 [LOG_NOTICE] = "notice",
4649 [LOG_INFO] = "info",
4650 [LOG_DEBUG] = "debug"
4653 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
4655 static const char* const sched_policy_table[] = {
4656 [SCHED_OTHER] = "other",
4657 [SCHED_BATCH] = "batch",
4658 [SCHED_IDLE] = "idle",
4659 [SCHED_FIFO] = "fifo",
4663 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
4665 static const char* const rlimit_table[] = {
4666 [RLIMIT_CPU] = "LimitCPU",
4667 [RLIMIT_FSIZE] = "LimitFSIZE",
4668 [RLIMIT_DATA] = "LimitDATA",
4669 [RLIMIT_STACK] = "LimitSTACK",
4670 [RLIMIT_CORE] = "LimitCORE",
4671 [RLIMIT_RSS] = "LimitRSS",
4672 [RLIMIT_NOFILE] = "LimitNOFILE",
4673 [RLIMIT_AS] = "LimitAS",
4674 [RLIMIT_NPROC] = "LimitNPROC",
4675 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
4676 [RLIMIT_LOCKS] = "LimitLOCKS",
4677 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
4678 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
4679 [RLIMIT_NICE] = "LimitNICE",
4680 [RLIMIT_RTPRIO] = "LimitRTPRIO",
4681 [RLIMIT_RTTIME] = "LimitRTTIME"
4684 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
4686 static const char* const ip_tos_table[] = {
4687 [IPTOS_LOWDELAY] = "low-delay",
4688 [IPTOS_THROUGHPUT] = "throughput",
4689 [IPTOS_RELIABILITY] = "reliability",
4690 [IPTOS_LOWCOST] = "low-cost",
4693 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
4695 static const char *const __signal_table[] = {
4712 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
4723 [SIGVTALRM] = "VTALRM",
4725 [SIGWINCH] = "WINCH",
4731 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
4733 const char *signal_to_string(int signo) {
4734 static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
4737 name = __signal_to_string(signo);
4741 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
4742 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
4744 snprintf(buf, sizeof(buf), "%d", signo);
4749 int signal_from_string(const char *s) {
4754 signo = __signal_from_string(s);
4758 if (startswith(s, "RTMIN+")) {
4762 if (safe_atou(s, &u) >= 0) {
4763 signo = (int) u + offset;
4764 if (signo > 0 && signo < _NSIG)
4770 bool kexec_loaded(void) {
4771 bool loaded = false;
4774 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
4782 int strdup_or_null(const char *a, char **b) {
4800 int prot_from_flags(int flags) {
4802 switch (flags & O_ACCMODE) {
4811 return PROT_READ|PROT_WRITE;
4818 char *format_bytes(char *buf, size_t l, off_t t) {
4821 static const struct {
4825 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4826 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4827 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
4828 { "G", 1024ULL*1024ULL*1024ULL },
4829 { "M", 1024ULL*1024ULL },
4833 for (i = 0; i < ELEMENTSOF(table); i++) {
4835 if (t >= table[i].factor) {
4838 (unsigned long long) (t / table[i].factor),
4839 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
4846 snprintf(buf, l, "%lluB", (unsigned long long) t);
4854 void* memdup(const void *p, size_t l) {
4867 int fd_inc_sndbuf(int fd, size_t n) {
4869 socklen_t l = sizeof(value);
4871 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
4872 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4875 /* If we have the privileges we will ignore the kernel limit. */
4878 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
4879 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
4885 int fd_inc_rcvbuf(int fd, size_t n) {
4887 socklen_t l = sizeof(value);
4889 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
4890 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4893 /* If we have the privileges we will ignore the kernel limit. */
4896 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
4897 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
4902 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
4903 pid_t parent_pid, agent_pid;
4905 bool stdout_is_tty, stderr_is_tty;
4913 parent_pid = getpid();
4915 /* Spawns a temporary TTY agent, making sure it goes away when
4922 if (agent_pid != 0) {
4929 * Make sure the agent goes away when the parent dies */
4930 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
4931 _exit(EXIT_FAILURE);
4933 /* Check whether our parent died before we were able
4934 * to set the death signal */
4935 if (getppid() != parent_pid)
4936 _exit(EXIT_SUCCESS);
4938 /* Don't leak fds to the agent */
4939 close_all_fds(except, n_except);
4941 stdout_is_tty = isatty(STDOUT_FILENO);
4942 stderr_is_tty = isatty(STDERR_FILENO);
4944 if (!stdout_is_tty || !stderr_is_tty) {
4945 /* Detach from stdout/stderr. and reopen
4946 * /dev/tty for them. This is important to
4947 * ensure that when systemctl is started via
4948 * popen() or a similar call that expects to
4949 * read EOF we actually do generate EOF and
4950 * not delay this indefinitely by because we
4951 * keep an unused copy of stdin around. */
4952 fd = open("/dev/tty", O_WRONLY);
4954 log_error("Failed to open /dev/tty: %m");
4955 _exit(EXIT_FAILURE);
4959 dup2(fd, STDOUT_FILENO);
4962 dup2(fd, STDERR_FILENO);
4968 /* Count arguments */
4970 for (n = 0; va_arg(ap, char*); n++)
4975 l = alloca(sizeof(char *) * (n + 1));
4977 /* Fill in arguments */
4979 for (i = 0; i <= n; i++)
4980 l[i] = va_arg(ap, char*);
4984 _exit(EXIT_FAILURE);
4987 int setrlimit_closest(int resource, const struct rlimit *rlim) {
4988 struct rlimit highest, fixed;
4992 if (setrlimit(resource, rlim) >= 0)
4998 /* So we failed to set the desired setrlimit, then let's try
4999 * to get as close as we can */
5000 assert_se(getrlimit(resource, &highest) == 0);
5002 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5003 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5005 if (setrlimit(resource, &fixed) < 0)
5011 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5012 _cleanup_fclose_ FILE *f = NULL;
5023 path = procfs_file_alloca(pid, "environ");
5025 f = fopen(path, "re");
5033 char line[LINE_MAX];
5036 for (i = 0; i < sizeof(line)-1; i++) {
5040 if (_unlikely_(c == EOF)) {
5050 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5051 value = strdup(line + l + 1);
5065 bool is_valid_documentation_url(const char *url) {
5068 if (startswith(url, "http://") && url[7])
5071 if (startswith(url, "https://") && url[8])
5074 if (startswith(url, "file:") && url[5])
5077 if (startswith(url, "info:") && url[5])
5080 if (startswith(url, "man:") && url[4])
5086 bool in_initrd(void) {
5087 static int saved = -1;
5093 /* We make two checks here:
5095 * 1. the flag file /etc/initrd-release must exist
5096 * 2. the root file system must be a memory file system
5098 * The second check is extra paranoia, since misdetecting an
5099 * initrd can have bad bad consequences due the initrd
5100 * emptying when transititioning to the main systemd.
5103 saved = access("/etc/initrd-release", F_OK) >= 0 &&
5104 statfs("/", &s) >= 0 &&
5105 is_temporary_fs(&s);
5110 void warn_melody(void) {
5111 _cleanup_close_ int fd = -1;
5113 fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5117 /* Yeah, this is synchronous. Kinda sucks. But well... */
5119 ioctl(fd, KIOCSOUND, (int)(1193180/440));
5120 usleep(125*USEC_PER_MSEC);
5122 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5123 usleep(125*USEC_PER_MSEC);
5125 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5126 usleep(125*USEC_PER_MSEC);
5128 ioctl(fd, KIOCSOUND, 0);
5131 int make_console_stdio(void) {
5134 /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5136 fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5138 log_error("Failed to acquire terminal: %s", strerror(-fd));
5144 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5151 int get_home_dir(char **_h) {
5159 /* Take the user specified one */
5170 /* Hardcode home directory for root to avoid NSS */
5173 h = strdup("/root");
5181 /* Check the database... */
5185 return errno > 0 ? -errno : -ESRCH;
5187 if (!path_is_absolute(p->pw_dir))
5190 h = strdup(p->pw_dir);
5198 int get_shell(char **_s) {
5206 /* Take the user specified one */
5207 e = getenv("SHELL");
5217 /* Hardcode home directory for root to avoid NSS */
5220 s = strdup("/bin/sh");
5228 /* Check the database... */
5232 return errno > 0 ? -errno : -ESRCH;
5234 if (!path_is_absolute(p->pw_shell))
5237 s = strdup(p->pw_shell);
5245 bool filename_is_safe(const char *p) {
5259 if (strlen(p) > FILENAME_MAX)
5265 bool string_is_safe(const char *p) {
5270 for (t = p; *t; t++) {
5271 if (*t > 0 && *t < ' ')
5274 if (strchr("\\\"\'", *t))
5282 * Check if a string contains control characters.
5283 * Spaces and tabs are not considered control characters.
5285 bool string_has_cc(const char *p) {
5290 for (t = p; *t; t++)
5291 if (*t > 0 && *t < ' ' && *t != '\t')
5297 bool path_is_safe(const char *p) {
5302 if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5305 if (strlen(p) > PATH_MAX)
5308 /* The following two checks are not really dangerous, but hey, they still are confusing */
5309 if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5312 if (strstr(p, "//"))
5318 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5319 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5320 int (*compar) (const void *, const void *, void *), void *arg) {
5329 p = (void *)(((const char *) base) + (idx * size));
5330 comparison = compar(key, p, arg);
5333 else if (comparison > 0)
5341 bool is_locale_utf8(void) {
5343 static int cached_answer = -1;
5345 if (cached_answer >= 0)
5348 if (!setlocale(LC_ALL, "")) {
5349 cached_answer = true;
5353 set = nl_langinfo(CODESET);
5355 cached_answer = true;
5359 if (streq(set, "UTF-8")) {
5360 cached_answer = true;
5364 /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5365 * unset and everything can do to UTF-8 nowadays. */
5366 set = setlocale(LC_CTYPE, NULL);
5368 cached_answer = true;
5372 /* Check result, but ignore the result if C was set
5376 !getenv("LC_ALL") &&
5377 !getenv("LC_CTYPE") &&
5381 return (bool) cached_answer;
5384 const char *draw_special_char(DrawSpecialChar ch) {
5385 static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5387 [DRAW_TREE_VERT] = "\342\224\202 ", /* │ */
5388 [DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
5389 [DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
5390 [DRAW_TREE_SPACE] = " ", /* */
5391 [DRAW_TRIANGULAR_BULLET] = "\342\200\243 ", /* ‣ */
5392 [DRAW_BLACK_CIRCLE] = "\342\227\217 ", /* ● */
5394 /* ASCII fallback */ {
5395 [DRAW_TREE_VERT] = "| ",
5396 [DRAW_TREE_BRANCH] = "|-",
5397 [DRAW_TREE_RIGHT] = "`-",
5398 [DRAW_TREE_SPACE] = " ",
5399 [DRAW_TRIANGULAR_BULLET] = "> ",
5400 [DRAW_BLACK_CIRCLE] = "* ",
5404 return draw_table[!is_locale_utf8()][ch];
5407 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5410 size_t l, old_len, new_len;
5416 old_len = strlen(old_string);
5417 new_len = strlen(new_string);
5430 if (!startswith(f, old_string)) {
5436 nl = l - old_len + new_len;
5437 a = realloc(r, nl + 1);
5445 t = stpcpy(t, new_string);
5457 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5458 const char *i, *begin = NULL;
5463 } state = STATE_OTHER;
5465 size_t osz = 0, isz;
5471 /* Strips ANSI color and replaces TABs by 8 spaces */
5473 isz = _isz ? *_isz : strlen(*ibuf);
5475 f = open_memstream(&obuf, &osz);
5479 for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5484 if (i >= *ibuf + isz) /* EOT */
5486 else if (*i == '\x1B')
5487 state = STATE_ESCAPE;
5488 else if (*i == '\t')
5495 if (i >= *ibuf + isz) { /* EOT */
5498 } else if (*i == '[') {
5499 state = STATE_BRACKET;
5504 state = STATE_OTHER;
5511 if (i >= *ibuf + isz || /* EOT */
5512 (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5515 state = STATE_OTHER;
5517 } else if (*i == 'm')
5518 state = STATE_OTHER;
5540 int on_ac_power(void) {
5541 bool found_offline = false, found_online = false;
5542 _cleanup_closedir_ DIR *d = NULL;
5544 d = opendir("/sys/class/power_supply");
5550 _cleanup_close_ int fd = -1, device = -1;
5556 if (!de && errno != 0)
5562 if (ignore_file(de->d_name))
5565 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5567 if (errno == ENOENT || errno == ENOTDIR)
5573 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5575 if (errno == ENOENT)
5581 n = read(fd, contents, sizeof(contents));
5585 if (n != 6 || memcmp(contents, "Mains\n", 6))
5588 close_nointr_nofail(fd);
5589 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5591 if (errno == ENOENT)
5597 n = read(fd, contents, sizeof(contents));
5601 if (n != 2 || contents[1] != '\n')
5604 if (contents[0] == '1') {
5605 found_online = true;
5607 } else if (contents[0] == '0')
5608 found_offline = true;
5613 return found_online || !found_offline;
5616 static int search_and_fopen_internal(const char *path, const char *mode, char **search, FILE **_f) {
5623 if (!path_strv_canonicalize_absolute_uniq(search, NULL))
5626 STRV_FOREACH(i, search) {
5627 _cleanup_free_ char *p = NULL;
5630 p = strjoin(*i, "/", path, NULL);
5640 if (errno != ENOENT)
5647 int search_and_fopen(const char *path, const char *mode, const char **search, FILE **_f) {
5648 _cleanup_strv_free_ char **copy = NULL;
5654 if (path_is_absolute(path)) {
5657 f = fopen(path, mode);
5666 copy = strv_copy((char**) search);
5670 return search_and_fopen_internal(path, mode, copy, _f);
5673 int search_and_fopen_nulstr(const char *path, const char *mode, const char *search, FILE **_f) {
5674 _cleanup_strv_free_ char **s = NULL;
5676 if (path_is_absolute(path)) {
5679 f = fopen(path, mode);
5688 s = strv_split_nulstr(search);
5692 return search_and_fopen_internal(path, mode, s, _f);
5695 char *strextend(char **x, ...) {
5702 l = f = *x ? strlen(*x) : 0;
5709 t = va_arg(ap, const char *);
5714 if (n > ((size_t) -1) - l) {
5723 r = realloc(*x, l+1);
5733 t = va_arg(ap, const char *);
5747 char *strrep(const char *s, unsigned n) {
5755 p = r = malloc(l * n + 1);
5759 for (i = 0; i < n; i++)
5766 void* greedy_realloc(void **p, size_t *allocated, size_t need) {
5773 if (*allocated >= need)
5776 a = MAX(64u, need * 2);
5778 /* check for overflows */
5791 void* greedy_realloc0(void **p, size_t *allocated, size_t need) {
5800 q = greedy_realloc(p, allocated, need);
5804 if (*allocated > prev)
5805 memzero(&q[prev], *allocated - prev);
5810 bool id128_is_valid(const char *s) {
5816 /* Simple formatted 128bit hex string */
5818 for (i = 0; i < l; i++) {
5821 if (!(c >= '0' && c <= '9') &&
5822 !(c >= 'a' && c <= 'z') &&
5823 !(c >= 'A' && c <= 'Z'))
5827 } else if (l == 36) {
5829 /* Formatted UUID */
5831 for (i = 0; i < l; i++) {
5834 if ((i == 8 || i == 13 || i == 18 || i == 23)) {
5838 if (!(c >= '0' && c <= '9') &&
5839 !(c >= 'a' && c <= 'z') &&
5840 !(c >= 'A' && c <= 'Z'))
5851 int split_pair(const char *s, const char *sep, char **l, char **r) {
5866 a = strndup(s, x - s);
5870 b = strdup(x + strlen(sep));
5882 int shall_restore_state(void) {
5883 _cleanup_free_ char *line;
5888 r = proc_cmdline(&line);
5891 if (r == 0) /* Container ... */
5894 FOREACH_WORD_QUOTED(w, l, line, state)
5895 if (l == 23 && strneq(w, "systemd.restore_state=0", 23))
5901 int proc_cmdline(char **ret) {
5904 if (detect_container(NULL) > 0) {
5908 r = read_full_file("/proc/1/cmdline", &buf, &sz);
5912 for (p = buf; p + 1 < buf + sz; p++)
5921 r = read_one_line_file("/proc/cmdline", ret);
5928 int parse_proc_cmdline(int (*parse_word)(const char *word)) {
5929 _cleanup_free_ char *line = NULL;
5934 r = proc_cmdline(&line);
5936 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
5940 FOREACH_WORD_QUOTED(w, l, line, state) {
5941 _cleanup_free_ char *word;
5943 word = strndup(w, l);
5947 r = parse_word(word);
5949 log_error("Failed on cmdline argument %s: %s", word, strerror(-r));
5957 int container_get_leader(const char *machine, pid_t *pid) {
5958 _cleanup_free_ char *s = NULL, *class = NULL;
5966 p = strappenda("/run/systemd/machines/", machine);
5967 r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
5975 if (!streq_ptr(class, "container"))
5978 r = parse_pid(s, &leader);
5988 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *root_fd) {
5989 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1;
5990 const char *pidns, *mntns, *root;
5998 mntns = procfs_file_alloca(pid, "ns/mnt");
5999 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6003 pidns = procfs_file_alloca(pid, "ns/pid");
6004 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6008 root = procfs_file_alloca(pid, "root");
6009 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6013 *pidns_fd = pidnsfd;
6014 *mntns_fd = mntnsfd;
6022 int namespace_enter(int pidns_fd, int mntns_fd, int root_fd) {
6023 assert(pidns_fd >= 0);
6024 assert(mntns_fd >= 0);
6025 assert(root_fd >= 0);
6027 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6030 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6033 if (fchdir(root_fd) < 0)
6036 if (chroot(".") < 0)
6039 if (setresgid(0, 0, 0) < 0)
6042 if (setresuid(0, 0, 0) < 0)
6048 bool pid_is_unwaited(pid_t pid) {
6049 /* Checks whether a PID is still valid at all, including a zombie */
6054 if (kill(pid, 0) >= 0)
6057 return errno != ESRCH;
6060 bool pid_is_alive(pid_t pid) {
6063 /* Checks whether a PID is still valid and not a zombie */
6068 r = get_process_state(pid);
6069 if (r == -ENOENT || r == 'Z')
6075 int getpeercred(int fd, struct ucred *ucred) {
6076 socklen_t n = sizeof(struct ucred);
6083 r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6087 if (n != sizeof(struct ucred))
6090 /* Check if the data is actually useful and not suppressed due
6091 * to namespacing issues */
6099 int getpeersec(int fd, char **ret) {
6111 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6115 if (errno != ERANGE)
6122 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6138 /* This is much like like mkostemp() but is subject to umask(). */
6139 int mkostemp_safe(char *pattern, int flags) {
6140 _cleanup_umask_ mode_t u;
6147 fd = mkostemp(pattern, flags);
6154 int open_tmpfile(const char *path, int flags) {
6161 /* Try O_TMPFILE first, if it is supported */
6162 fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6167 /* Fall back to unguessable name + unlinking */
6168 p = strappenda(path, "/systemd-tmp-XXXXXX");
6170 fd = mkostemp_safe(p, flags);
6178 int fd_warn_permissions(const char *path, int fd) {
6181 if (fstat(fd, &st) < 0)
6184 if (st.st_mode & 0111)
6185 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6187 if (st.st_mode & 0002)
6188 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6190 if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6191 log_warning("Configuration file %s is marked world-inaccessible. This has no effect as configuration data is accessible via APIs without restrictions. Proceeding anyway.", path);