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
76 #include "path-util.h"
77 #include "exit-status.h"
81 #include "device-nodes.h"
88 char **saved_argv = NULL;
90 static volatile unsigned cached_columns = 0;
91 static volatile unsigned cached_lines = 0;
93 size_t page_size(void) {
94 static thread_local size_t pgsz = 0;
97 if (_likely_(pgsz > 0))
100 r = sysconf(_SC_PAGESIZE);
107 bool streq_ptr(const char *a, const char *b) {
109 /* Like streq(), but tries to make sense of NULL pointers */
120 char* endswith(const char *s, const char *postfix) {
127 pl = strlen(postfix);
130 return (char*) s + sl;
135 if (memcmp(s + sl - pl, postfix, pl) != 0)
138 return (char*) s + sl - pl;
141 bool first_word(const char *s, const char *word) {
156 if (memcmp(s, word, wl) != 0)
160 strchr(WHITESPACE, s[wl]);
163 int close_nointr(int fd) {
170 else if (errno == EINTR)
172 * Just ignore EINTR; a retry loop is the wrong
173 * thing to do on Linux.
175 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
176 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
177 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
178 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
185 int safe_close(int fd) {
188 * Like close_nointr() but cannot fail. Guarantees errno is
189 * unchanged. Is a NOP with negative fds passed, and returns
190 * -1, so that it can be used in this syntax:
192 * fd = safe_close(fd);
198 /* The kernel might return pretty much any error code
199 * via close(), but the fd will be closed anyway. The
200 * only condition we want to check for here is whether
201 * the fd was invalid at all... */
203 assert_se(close_nointr(fd) != -EBADF);
209 void close_many(const int fds[], unsigned n_fd) {
212 assert(fds || n_fd <= 0);
214 for (i = 0; i < n_fd; i++)
218 int unlink_noerrno(const char *path) {
229 int parse_boolean(const char *v) {
232 if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
234 else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
240 int parse_pid(const char *s, pid_t* ret_pid) {
241 unsigned long ul = 0;
248 r = safe_atolu(s, &ul);
254 if ((unsigned long) pid != ul)
264 int parse_uid(const char *s, uid_t* ret_uid) {
265 unsigned long ul = 0;
272 r = safe_atolu(s, &ul);
278 if ((unsigned long) uid != ul)
285 int safe_atou(const char *s, unsigned *ret_u) {
293 l = strtoul(s, &x, 0);
295 if (!x || x == s || *x || errno)
296 return errno > 0 ? -errno : -EINVAL;
298 if ((unsigned long) (unsigned) l != l)
301 *ret_u = (unsigned) l;
305 int safe_atoi(const char *s, int *ret_i) {
313 l = strtol(s, &x, 0);
315 if (!x || x == s || *x || errno)
316 return errno > 0 ? -errno : -EINVAL;
318 if ((long) (int) l != l)
325 int safe_atollu(const char *s, long long unsigned *ret_llu) {
327 unsigned long long l;
333 l = strtoull(s, &x, 0);
335 if (!x || x == s || *x || errno)
336 return errno ? -errno : -EINVAL;
342 int safe_atolli(const char *s, long long int *ret_lli) {
350 l = strtoll(s, &x, 0);
352 if (!x || x == s || *x || errno)
353 return errno ? -errno : -EINVAL;
359 int safe_atod(const char *s, double *ret_d) {
366 RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
371 if (!x || x == s || *x || errno)
372 return errno ? -errno : -EINVAL;
378 static size_t strcspn_escaped(const char *s, const char *reject) {
379 bool escaped = false;
382 for (n=0; s[n]; n++) {
385 else if (s[n] == '\\')
387 else if (strchr(reject, s[n]))
393 /* Split a string into words. */
394 char *split(const char *c, size_t *l, const char *separator, bool quoted, char **state) {
397 current = *state ? *state : (char*) c;
399 if (!*current || *c == 0)
402 current += strspn(current, separator);
406 if (quoted && strchr("\'\"", *current)) {
407 char quotechar = *(current++);
408 *l = strcspn_escaped(current, (char[]){quotechar, '\0'});
409 *state = current+*l+1;
411 *l = strcspn_escaped(current, separator);
414 *l = strcspn(current, separator);
418 return (char*) current;
421 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
423 _cleanup_free_ char *line = NULL;
435 p = procfs_file_alloca(pid, "stat");
436 r = read_one_line_file(p, &line);
440 /* Let's skip the pid and comm fields. The latter is enclosed
441 * in () but does not escape any () in its value, so let's
442 * skip over it manually */
444 p = strrchr(line, ')');
456 if ((long unsigned) (pid_t) ppid != ppid)
459 *_ppid = (pid_t) ppid;
464 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
466 _cleanup_free_ char *line = NULL;
472 p = procfs_file_alloca(pid, "stat");
473 r = read_one_line_file(p, &line);
477 /* Let's skip the pid and comm fields. The latter is enclosed
478 * in () but does not escape any () in its value, so let's
479 * skip over it manually */
481 p = strrchr(line, ')');
503 "%*d " /* priority */
505 "%*d " /* num_threads */
506 "%*d " /* itrealvalue */
507 "%llu " /* starttime */,
514 int fchmod_umask(int fd, mode_t m) {
519 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
525 char *truncate_nl(char *s) {
528 s[strcspn(s, NEWLINE)] = 0;
532 int get_process_state(pid_t pid) {
536 _cleanup_free_ char *line = NULL;
540 p = procfs_file_alloca(pid, "stat");
541 r = read_one_line_file(p, &line);
545 p = strrchr(line, ')');
551 if (sscanf(p, " %c", &state) != 1)
554 return (unsigned char) state;
557 int get_process_comm(pid_t pid, char **name) {
564 p = procfs_file_alloca(pid, "comm");
566 r = read_one_line_file(p, name);
573 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
574 _cleanup_fclose_ FILE *f = NULL;
582 p = procfs_file_alloca(pid, "cmdline");
588 if (max_length == 0) {
589 size_t len = 0, allocated = 0;
591 while ((c = getc(f)) != EOF) {
593 if (!GREEDY_REALLOC(r, allocated, len+2)) {
598 r[len++] = isprint(c) ? c : ' ';
608 r = new(char, max_length);
614 while ((c = getc(f)) != EOF) {
636 size_t n = MIN(left-1, 3U);
643 /* Kernel threads have no argv[] */
644 if (r == NULL || r[0] == 0) {
645 _cleanup_free_ char *t = NULL;
653 h = get_process_comm(pid, &t);
657 r = strjoin("[", t, "]", NULL);
666 int is_kernel_thread(pid_t pid) {
678 p = procfs_file_alloca(pid, "cmdline");
683 count = fread(&c, 1, 1, f);
687 /* Kernel threads have an empty cmdline */
690 return eof ? 1 : -errno;
695 int get_process_capeff(pid_t pid, char **capeff) {
701 p = procfs_file_alloca(pid, "status");
703 return get_status_field(p, "\nCapEff:", capeff);
706 int get_process_exe(pid_t pid, char **name) {
714 p = procfs_file_alloca(pid, "exe");
716 r = readlink_malloc(p, name);
718 return r == -ENOENT ? -ESRCH : r;
720 d = endswith(*name, " (deleted)");
727 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
728 _cleanup_fclose_ FILE *f = NULL;
738 p = procfs_file_alloca(pid, "status");
743 FOREACH_LINE(line, f, return -errno) {
748 if (startswith(l, field)) {
750 l += strspn(l, WHITESPACE);
752 l[strcspn(l, WHITESPACE)] = 0;
754 return parse_uid(l, uid);
761 int get_process_uid(pid_t pid, uid_t *uid) {
762 return get_process_id(pid, "Uid:", uid);
765 int get_process_gid(pid_t pid, gid_t *gid) {
766 assert_cc(sizeof(uid_t) == sizeof(gid_t));
767 return get_process_id(pid, "Gid:", gid);
770 char *strnappend(const char *s, const char *suffix, size_t b) {
778 return strndup(suffix, b);
787 if (b > ((size_t) -1) - a)
790 r = new(char, a+b+1);
795 memcpy(r+a, suffix, b);
801 char *strappend(const char *s, const char *suffix) {
802 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
805 int readlink_malloc(const char *p, char **ret) {
820 n = readlink(p, c, l-1);
827 if ((size_t) n < l-1) {
838 int readlink_and_make_absolute(const char *p, char **r) {
839 _cleanup_free_ char *target = NULL;
846 j = readlink_malloc(p, &target);
850 k = file_in_same_dir(p, target);
858 int readlink_and_canonicalize(const char *p, char **r) {
865 j = readlink_and_make_absolute(p, &t);
869 s = canonicalize_file_name(t);
876 path_kill_slashes(*r);
881 int reset_all_signal_handlers(void) {
884 for (sig = 1; sig < _NSIG; sig++) {
885 struct sigaction sa = {
886 .sa_handler = SIG_DFL,
887 .sa_flags = SA_RESTART,
890 if (sig == SIGKILL || sig == SIGSTOP)
893 /* On Linux the first two RT signals are reserved by
894 * glibc, and sigaction() will return EINVAL for them. */
895 if ((sigaction(sig, &sa, NULL) < 0))
903 char *strstrip(char *s) {
906 /* Drops trailing whitespace. Modifies the string in
907 * place. Returns pointer to first non-space character */
909 s += strspn(s, WHITESPACE);
911 for (e = strchr(s, 0); e > s; e --)
912 if (!strchr(WHITESPACE, e[-1]))
920 char *delete_chars(char *s, const char *bad) {
923 /* Drops all whitespace, regardless where in the string */
925 for (f = s, t = s; *f; f++) {
937 char *file_in_same_dir(const char *path, const char *filename) {
944 /* This removes the last component of path and appends
945 * filename, unless the latter is absolute anyway or the
948 if (path_is_absolute(filename))
949 return strdup(filename);
951 if (!(e = strrchr(path, '/')))
952 return strdup(filename);
954 k = strlen(filename);
955 if (!(r = new(char, e-path+1+k+1)))
958 memcpy(r, path, e-path+1);
959 memcpy(r+(e-path)+1, filename, k+1);
964 int rmdir_parents(const char *path, const char *stop) {
973 /* Skip trailing slashes */
974 while (l > 0 && path[l-1] == '/')
980 /* Skip last component */
981 while (l > 0 && path[l-1] != '/')
984 /* Skip trailing slashes */
985 while (l > 0 && path[l-1] == '/')
991 if (!(t = strndup(path, l)))
994 if (path_startswith(stop, t)) {
1003 if (errno != ENOENT)
1010 char hexchar(int x) {
1011 static const char table[16] = "0123456789abcdef";
1013 return table[x & 15];
1016 int unhexchar(char c) {
1018 if (c >= '0' && c <= '9')
1021 if (c >= 'a' && c <= 'f')
1022 return c - 'a' + 10;
1024 if (c >= 'A' && c <= 'F')
1025 return c - 'A' + 10;
1030 char *hexmem(const void *p, size_t l) {
1034 z = r = malloc(l * 2 + 1);
1038 for (x = p; x < (const uint8_t*) p + l; x++) {
1039 *(z++) = hexchar(*x >> 4);
1040 *(z++) = hexchar(*x & 15);
1047 void *unhexmem(const char *p, size_t l) {
1053 z = r = malloc((l + 1) / 2 + 1);
1057 for (x = p; x < p + l; x += 2) {
1060 a = unhexchar(x[0]);
1062 b = unhexchar(x[1]);
1066 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1073 char octchar(int x) {
1074 return '0' + (x & 7);
1077 int unoctchar(char c) {
1079 if (c >= '0' && c <= '7')
1085 char decchar(int x) {
1086 return '0' + (x % 10);
1089 int undecchar(char c) {
1091 if (c >= '0' && c <= '9')
1097 char *cescape(const char *s) {
1103 /* Does C style string escaping. */
1105 r = new(char, strlen(s)*4 + 1);
1109 for (f = s, t = r; *f; f++)
1155 /* For special chars we prefer octal over
1156 * hexadecimal encoding, simply because glib's
1157 * g_strescape() does the same */
1158 if ((*f < ' ') || (*f >= 127)) {
1160 *(t++) = octchar((unsigned char) *f >> 6);
1161 *(t++) = octchar((unsigned char) *f >> 3);
1162 *(t++) = octchar((unsigned char) *f);
1173 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1180 /* Undoes C style string escaping, and optionally prefixes it. */
1182 pl = prefix ? strlen(prefix) : 0;
1184 r = new(char, pl+length+1);
1189 memcpy(r, prefix, pl);
1191 for (f = s, t = r + pl; f < s + length; f++) {
1234 /* This is an extension of the XDG syntax files */
1239 /* hexadecimal encoding */
1242 a = unhexchar(f[1]);
1243 b = unhexchar(f[2]);
1245 if (a < 0 || b < 0) {
1246 /* Invalid escape code, let's take it literal then */
1250 *(t++) = (char) ((a << 4) | b);
1265 /* octal encoding */
1268 a = unoctchar(f[0]);
1269 b = unoctchar(f[1]);
1270 c = unoctchar(f[2]);
1272 if (a < 0 || b < 0 || c < 0) {
1273 /* Invalid escape code, let's take it literal then */
1277 *(t++) = (char) ((a << 6) | (b << 3) | c);
1285 /* premature end of string.*/
1290 /* Invalid escape code, let's take it literal then */
1302 char *cunescape_length(const char *s, size_t length) {
1303 return cunescape_length_with_prefix(s, length, NULL);
1306 char *cunescape(const char *s) {
1309 return cunescape_length(s, strlen(s));
1312 char *xescape(const char *s, const char *bad) {
1316 /* Escapes all chars in bad, in addition to \ and all special
1317 * chars, in \xFF style escaping. May be reversed with
1320 r = new(char, strlen(s) * 4 + 1);
1324 for (f = s, t = r; *f; f++) {
1326 if ((*f < ' ') || (*f >= 127) ||
1327 (*f == '\\') || strchr(bad, *f)) {
1330 *(t++) = hexchar(*f >> 4);
1331 *(t++) = hexchar(*f);
1341 char *ascii_strlower(char *t) {
1346 for (p = t; *p; p++)
1347 if (*p >= 'A' && *p <= 'Z')
1348 *p = *p - 'A' + 'a';
1353 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1357 filename[0] == '.' ||
1358 streq(filename, "lost+found") ||
1359 streq(filename, "aquota.user") ||
1360 streq(filename, "aquota.group") ||
1361 endswith(filename, ".rpmnew") ||
1362 endswith(filename, ".rpmsave") ||
1363 endswith(filename, ".rpmorig") ||
1364 endswith(filename, ".dpkg-old") ||
1365 endswith(filename, ".dpkg-new") ||
1366 endswith(filename, ".swp");
1369 bool ignore_file(const char *filename) {
1372 if (endswith(filename, "~"))
1375 return ignore_file_allow_backup(filename);
1378 int fd_nonblock(int fd, bool nonblock) {
1383 if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1387 flags |= O_NONBLOCK;
1389 flags &= ~O_NONBLOCK;
1391 if (fcntl(fd, F_SETFL, flags) < 0)
1397 int fd_cloexec(int fd, bool cloexec) {
1402 if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1406 flags |= FD_CLOEXEC;
1408 flags &= ~FD_CLOEXEC;
1410 if (fcntl(fd, F_SETFD, flags) < 0)
1416 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1419 assert(n_fdset == 0 || fdset);
1421 for (i = 0; i < n_fdset; i++)
1428 int close_all_fds(const int except[], unsigned n_except) {
1433 assert(n_except == 0 || except);
1435 d = opendir("/proc/self/fd");
1440 /* When /proc isn't available (for example in chroots)
1441 * the fallback is brute forcing through the fd
1444 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1445 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1447 if (fd_in_set(fd, except, n_except))
1450 if (close_nointr(fd) < 0)
1451 if (errno != EBADF && r == 0)
1458 while ((de = readdir(d))) {
1461 if (ignore_file(de->d_name))
1464 if (safe_atoi(de->d_name, &fd) < 0)
1465 /* Let's better ignore this, just in case */
1474 if (fd_in_set(fd, except, n_except))
1477 if (close_nointr(fd) < 0) {
1478 /* Valgrind has its own FD and doesn't want to have it closed */
1479 if (errno != EBADF && r == 0)
1488 bool chars_intersect(const char *a, const char *b) {
1491 /* Returns true if any of the chars in a are in b. */
1492 for (p = a; *p; p++)
1499 bool fstype_is_network(const char *fstype) {
1500 static const char table[] =
1513 x = startswith(fstype, "fuse.");
1517 return nulstr_contains(table, fstype);
1521 _cleanup_close_ int fd;
1523 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1529 TIOCL_GETKMSGREDIRECT,
1533 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1536 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1539 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1545 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1546 struct termios old_termios, new_termios;
1548 char line[LINE_MAX];
1553 if (tcgetattr(fileno(f), &old_termios) >= 0) {
1554 new_termios = old_termios;
1556 new_termios.c_lflag &= ~ICANON;
1557 new_termios.c_cc[VMIN] = 1;
1558 new_termios.c_cc[VTIME] = 0;
1560 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1563 if (t != (usec_t) -1) {
1564 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1565 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1570 k = fread(&c, 1, 1, f);
1572 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1578 *need_nl = c != '\n';
1585 if (t != (usec_t) -1)
1586 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1589 if (!fgets(line, sizeof(line), f))
1594 if (strlen(line) != 1)
1604 int ask(char *ret, const char *replies, const char *text, ...) {
1614 bool need_nl = true;
1617 fputs(ANSI_HIGHLIGHT_ON, stdout);
1624 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1628 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1631 if (r == -EBADMSG) {
1632 puts("Bad input, please try again.");
1643 if (strchr(replies, c)) {
1648 puts("Read unexpected character, please try again.");
1652 int reset_terminal_fd(int fd, bool switch_to_text) {
1653 struct termios termios;
1656 /* Set terminal to some sane defaults */
1660 /* We leave locked terminal attributes untouched, so that
1661 * Plymouth may set whatever it wants to set, and we don't
1662 * interfere with that. */
1664 /* Disable exclusive mode, just in case */
1665 ioctl(fd, TIOCNXCL);
1667 /* Switch to text mode */
1669 ioctl(fd, KDSETMODE, KD_TEXT);
1671 /* Enable console unicode mode */
1672 ioctl(fd, KDSKBMODE, K_UNICODE);
1674 if (tcgetattr(fd, &termios) < 0) {
1679 /* We only reset the stuff that matters to the software. How
1680 * hardware is set up we don't touch assuming that somebody
1681 * else will do that for us */
1683 termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1684 termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1685 termios.c_oflag |= ONLCR;
1686 termios.c_cflag |= CREAD;
1687 termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1689 termios.c_cc[VINTR] = 03; /* ^C */
1690 termios.c_cc[VQUIT] = 034; /* ^\ */
1691 termios.c_cc[VERASE] = 0177;
1692 termios.c_cc[VKILL] = 025; /* ^X */
1693 termios.c_cc[VEOF] = 04; /* ^D */
1694 termios.c_cc[VSTART] = 021; /* ^Q */
1695 termios.c_cc[VSTOP] = 023; /* ^S */
1696 termios.c_cc[VSUSP] = 032; /* ^Z */
1697 termios.c_cc[VLNEXT] = 026; /* ^V */
1698 termios.c_cc[VWERASE] = 027; /* ^W */
1699 termios.c_cc[VREPRINT] = 022; /* ^R */
1700 termios.c_cc[VEOL] = 0;
1701 termios.c_cc[VEOL2] = 0;
1703 termios.c_cc[VTIME] = 0;
1704 termios.c_cc[VMIN] = 1;
1706 if (tcsetattr(fd, TCSANOW, &termios) < 0)
1710 /* Just in case, flush all crap out */
1711 tcflush(fd, TCIOFLUSH);
1716 int reset_terminal(const char *name) {
1717 _cleanup_close_ int fd = -1;
1719 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1723 return reset_terminal_fd(fd, true);
1726 int open_terminal(const char *name, int mode) {
1731 * If a TTY is in the process of being closed opening it might
1732 * cause EIO. This is horribly awful, but unlikely to be
1733 * changed in the kernel. Hence we work around this problem by
1734 * retrying a couple of times.
1736 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1739 assert(!(mode & O_CREAT));
1742 fd = open(name, mode, 0);
1749 /* Max 1s in total */
1753 usleep(50 * USEC_PER_MSEC);
1774 int flush_fd(int fd) {
1775 struct pollfd pollfd = {
1785 r = poll(&pollfd, 1, 0);
1795 l = read(fd, buf, sizeof(buf));
1801 if (errno == EAGAIN)
1810 int acquire_terminal(
1814 bool ignore_tiocstty_eperm,
1817 int fd = -1, notify = -1, r = 0, wd = -1;
1822 /* We use inotify to be notified when the tty is closed. We
1823 * create the watch before checking if we can actually acquire
1824 * it, so that we don't lose any event.
1826 * Note: strictly speaking this actually watches for the
1827 * device being closed, it does *not* really watch whether a
1828 * tty loses its controlling process. However, unless some
1829 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1830 * its tty otherwise this will not become a problem. As long
1831 * as the administrator makes sure not configure any service
1832 * on the same tty as an untrusted user this should not be a
1833 * problem. (Which he probably should not do anyway.) */
1835 if (timeout != (usec_t) -1)
1836 ts = now(CLOCK_MONOTONIC);
1838 if (!fail && !force) {
1839 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1845 wd = inotify_add_watch(notify, name, IN_CLOSE);
1853 struct sigaction sa_old, sa_new = {
1854 .sa_handler = SIG_IGN,
1855 .sa_flags = SA_RESTART,
1859 r = flush_fd(notify);
1864 /* We pass here O_NOCTTY only so that we can check the return
1865 * value TIOCSCTTY and have a reliable way to figure out if we
1866 * successfully became the controlling process of the tty */
1867 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1871 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1872 * if we already own the tty. */
1873 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1875 /* First, try to get the tty */
1876 if (ioctl(fd, TIOCSCTTY, force) < 0)
1879 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1881 /* Sometimes it makes sense to ignore TIOCSCTTY
1882 * returning EPERM, i.e. when very likely we already
1883 * are have this controlling terminal. */
1884 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1887 if (r < 0 && (force || fail || r != -EPERM)) {
1896 assert(notify >= 0);
1899 uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1901 struct inotify_event *e;
1903 if (timeout != (usec_t) -1) {
1906 n = now(CLOCK_MONOTONIC);
1907 if (ts + timeout < n) {
1912 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1922 l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1925 if (errno == EINTR || errno == EAGAIN)
1932 e = (struct inotify_event*) inotify_buffer;
1937 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
1942 step = sizeof(struct inotify_event) + e->len;
1943 assert(step <= (size_t) l);
1945 e = (struct inotify_event*) ((uint8_t*) e + step);
1952 /* We close the tty fd here since if the old session
1953 * ended our handle will be dead. It's important that
1954 * we do this after sleeping, so that we don't enter
1955 * an endless loop. */
1961 r = reset_terminal_fd(fd, true);
1963 log_warning("Failed to reset terminal: %s", strerror(-r));
1974 int release_terminal(void) {
1976 struct sigaction sa_old, sa_new = {
1977 .sa_handler = SIG_IGN,
1978 .sa_flags = SA_RESTART,
1980 _cleanup_close_ int fd;
1982 fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
1986 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1987 * by our own TIOCNOTTY */
1988 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1990 if (ioctl(fd, TIOCNOTTY) < 0)
1993 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1998 int sigaction_many(const struct sigaction *sa, ...) {
2003 while ((sig = va_arg(ap, int)) > 0)
2004 if (sigaction(sig, sa, NULL) < 0)
2011 int ignore_signals(int sig, ...) {
2012 struct sigaction sa = {
2013 .sa_handler = SIG_IGN,
2014 .sa_flags = SA_RESTART,
2019 if (sigaction(sig, &sa, NULL) < 0)
2023 while ((sig = va_arg(ap, int)) > 0)
2024 if (sigaction(sig, &sa, NULL) < 0)
2031 int default_signals(int sig, ...) {
2032 struct sigaction sa = {
2033 .sa_handler = SIG_DFL,
2034 .sa_flags = SA_RESTART,
2039 if (sigaction(sig, &sa, NULL) < 0)
2043 while ((sig = va_arg(ap, int)) > 0)
2044 if (sigaction(sig, &sa, NULL) < 0)
2051 void safe_close_pair(int p[]) {
2055 /* Special case pairs which use the same fd in both
2057 p[0] = p[1] = safe_close(p[0]);
2061 p[0] = safe_close(p[0]);
2062 p[1] = safe_close(p[1]);
2065 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2072 while (nbytes > 0) {
2075 k = read(fd, p, nbytes);
2076 if (k < 0 && errno == EINTR)
2079 if (k < 0 && errno == EAGAIN && do_poll) {
2081 /* We knowingly ignore any return value here,
2082 * and expect that any error/EOF is reported
2085 fd_wait_for_event(fd, POLLIN, (usec_t) -1);
2090 return n > 0 ? n : (k < 0 ? -errno : 0);
2100 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2101 const uint8_t *p = buf;
2107 while (nbytes > 0) {
2110 k = write(fd, p, nbytes);
2111 if (k < 0 && errno == EINTR)
2114 if (k < 0 && errno == EAGAIN && do_poll) {
2116 /* We knowingly ignore any return value here,
2117 * and expect that any error/EOF is reported
2120 fd_wait_for_event(fd, POLLOUT, (usec_t) -1);
2125 return n > 0 ? n : (k < 0 ? -errno : 0);
2135 int parse_size(const char *t, off_t base, off_t *size) {
2137 /* Soo, sometimes we want to parse IEC binary suffxies, and
2138 * sometimes SI decimal suffixes. This function can parse
2139 * both. Which one is the right way depends on the
2140 * context. Wikipedia suggests that SI is customary for
2141 * hardrware metrics and network speeds, while IEC is
2142 * customary for most data sizes used by software and volatile
2143 * (RAM) memory. Hence be careful which one you pick!
2145 * In either case we use just K, M, G as suffix, and not Ki,
2146 * Mi, Gi or so (as IEC would suggest). That's because that's
2147 * frickin' ugly. But this means you really need to make sure
2148 * to document which base you are parsing when you use this
2153 unsigned long long factor;
2156 static const struct table iec[] = {
2157 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2158 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2159 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2160 { "G", 1024ULL*1024ULL*1024ULL },
2161 { "M", 1024ULL*1024ULL },
2167 static const struct table si[] = {
2168 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2169 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2170 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2171 { "G", 1000ULL*1000ULL*1000ULL },
2172 { "M", 1000ULL*1000ULL },
2178 const struct table *table;
2180 unsigned long long r = 0;
2181 unsigned n_entries, start_pos = 0;
2184 assert(base == 1000 || base == 1024);
2189 n_entries = ELEMENTSOF(si);
2192 n_entries = ELEMENTSOF(iec);
2198 unsigned long long l2;
2204 l = strtoll(p, &e, 10);
2217 if (*e >= '0' && *e <= '9') {
2220 /* strotoull itself would accept space/+/- */
2221 l2 = strtoull(e, &e2, 10);
2223 if (errno == ERANGE)
2226 /* Ignore failure. E.g. 10.M is valid */
2233 e += strspn(e, WHITESPACE);
2235 for (i = start_pos; i < n_entries; i++)
2236 if (startswith(e, table[i].suffix)) {
2237 unsigned long long tmp;
2238 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2240 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2241 if (tmp > ULLONG_MAX - r)
2245 if ((unsigned long long) (off_t) r != r)
2248 p = e + strlen(table[i].suffix);
2264 int make_stdio(int fd) {
2269 r = dup3(fd, STDIN_FILENO, 0);
2270 s = dup3(fd, STDOUT_FILENO, 0);
2271 t = dup3(fd, STDERR_FILENO, 0);
2276 if (r < 0 || s < 0 || t < 0)
2279 /* We rely here that the new fd has O_CLOEXEC not set */
2284 int make_null_stdio(void) {
2287 null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2291 return make_stdio(null_fd);
2294 bool is_device_path(const char *path) {
2296 /* Returns true on paths that refer to a device, either in
2297 * sysfs or in /dev */
2300 path_startswith(path, "/dev/") ||
2301 path_startswith(path, "/sys/");
2304 int dir_is_empty(const char *path) {
2305 _cleanup_closedir_ DIR *d;
2316 if (!de && errno != 0)
2322 if (!ignore_file(de->d_name))
2327 char* dirname_malloc(const char *path) {
2328 char *d, *dir, *dir2;
2345 int dev_urandom(void *p, size_t n) {
2346 _cleanup_close_ int fd;
2349 fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2351 return errno == ENOENT ? -ENOSYS : -errno;
2353 k = loop_read(fd, p, n, true);
2356 if ((size_t) k != n)
2362 void random_bytes(void *p, size_t n) {
2363 static bool srand_called = false;
2367 r = dev_urandom(p, n);
2371 /* If some idiot made /dev/urandom unavailable to us, he'll
2372 * get a PRNG instead. */
2374 if (!srand_called) {
2377 #ifdef HAVE_SYS_AUXV_H
2378 /* The kernel provides us with a bit of entropy in
2379 * auxv, so let's try to make use of that to seed the
2380 * pseudo-random generator. It's better than
2385 auxv = (void*) getauxval(AT_RANDOM);
2387 x ^= *(unsigned*) auxv;
2390 x ^= (unsigned) now(CLOCK_REALTIME);
2391 x ^= (unsigned) gettid();
2394 srand_called = true;
2397 for (q = p; q < (uint8_t*) p + n; q ++)
2401 void rename_process(const char name[8]) {
2404 /* This is a like a poor man's setproctitle(). It changes the
2405 * comm field, argv[0], and also the glibc's internally used
2406 * name of the process. For the first one a limit of 16 chars
2407 * applies, to the second one usually one of 10 (i.e. length
2408 * of "/sbin/init"), to the third one one of 7 (i.e. length of
2409 * "systemd"). If you pass a longer string it will be
2412 prctl(PR_SET_NAME, name);
2414 if (program_invocation_name)
2415 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2417 if (saved_argc > 0) {
2421 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2423 for (i = 1; i < saved_argc; i++) {
2427 memzero(saved_argv[i], strlen(saved_argv[i]));
2432 void sigset_add_many(sigset_t *ss, ...) {
2439 while ((sig = va_arg(ap, int)) > 0)
2440 assert_se(sigaddset(ss, sig) == 0);
2444 int sigprocmask_many(int how, ...) {
2449 assert_se(sigemptyset(&ss) == 0);
2452 while ((sig = va_arg(ap, int)) > 0)
2453 assert_se(sigaddset(&ss, sig) == 0);
2456 if (sigprocmask(how, &ss, NULL) < 0)
2462 char* gethostname_malloc(void) {
2465 assert_se(uname(&u) >= 0);
2467 if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2468 return strdup(u.nodename);
2470 return strdup(u.sysname);
2473 bool hostname_is_set(void) {
2476 assert_se(uname(&u) >= 0);
2478 return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2481 static char *lookup_uid(uid_t uid) {
2484 _cleanup_free_ char *buf = NULL;
2485 struct passwd pwbuf, *pw = NULL;
2487 /* Shortcut things to avoid NSS lookups */
2489 return strdup("root");
2491 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2495 buf = malloc(bufsize);
2499 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2500 return strdup(pw->pw_name);
2502 if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
2508 char* getlogname_malloc(void) {
2512 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2517 return lookup_uid(uid);
2520 char *getusername_malloc(void) {
2527 return lookup_uid(getuid());
2530 int getttyname_malloc(int fd, char **r) {
2531 char path[PATH_MAX], *c;
2536 k = ttyname_r(fd, path, sizeof(path));
2542 c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2550 int getttyname_harder(int fd, char **r) {
2554 k = getttyname_malloc(fd, &s);
2558 if (streq(s, "tty")) {
2560 return get_ctty(0, NULL, r);
2567 int get_ctty_devnr(pid_t pid, dev_t *d) {
2569 _cleanup_free_ char *line = NULL;
2571 unsigned long ttynr;
2575 p = procfs_file_alloca(pid, "stat");
2576 r = read_one_line_file(p, &line);
2580 p = strrchr(line, ')');
2590 "%*d " /* session */
2595 if (major(ttynr) == 0 && minor(ttynr) == 0)
2604 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2605 char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2606 _cleanup_free_ char *s = NULL;
2613 k = get_ctty_devnr(pid, &devnr);
2617 snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2619 k = readlink_malloc(fn, &s);
2625 /* This is an ugly hack */
2626 if (major(devnr) == 136) {
2627 asprintf(&b, "pts/%lu", (unsigned long) minor(devnr));
2631 /* Probably something like the ptys which have no
2632 * symlink in /dev/char. Let's return something
2633 * vaguely useful. */
2639 if (startswith(s, "/dev/"))
2641 else if (startswith(s, "../"))
2659 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2665 /* This returns the first error we run into, but nevertheless
2666 * tries to go on. This closes the passed fd. */
2672 return errno == ENOENT ? 0 : -errno;
2677 bool is_dir, keep_around;
2683 if (!de && errno != 0) {
2692 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2695 if (de->d_type == DT_UNKNOWN ||
2697 (de->d_type == DT_DIR && root_dev)) {
2698 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2699 if (ret == 0 && errno != ENOENT)
2704 is_dir = S_ISDIR(st.st_mode);
2707 (st.st_uid == 0 || st.st_uid == getuid()) &&
2708 (st.st_mode & S_ISVTX);
2710 is_dir = de->d_type == DT_DIR;
2711 keep_around = false;
2717 /* if root_dev is set, remove subdirectories only, if device is same as dir */
2718 if (root_dev && st.st_dev != root_dev->st_dev)
2721 subdir_fd = openat(fd, de->d_name,
2722 O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2723 if (subdir_fd < 0) {
2724 if (ret == 0 && errno != ENOENT)
2729 r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2730 if (r < 0 && ret == 0)
2734 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2735 if (ret == 0 && errno != ENOENT)
2739 } else if (!only_dirs && !keep_around) {
2741 if (unlinkat(fd, de->d_name, 0) < 0) {
2742 if (ret == 0 && errno != ENOENT)
2753 _pure_ static int is_temporary_fs(struct statfs *s) {
2756 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2757 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2760 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2765 if (fstatfs(fd, &s) < 0) {
2770 /* We refuse to clean disk file systems with this call. This
2771 * is extra paranoia just to be sure we never ever remove
2773 if (!is_temporary_fs(&s)) {
2774 log_error("Attempted to remove disk file system, and we can't allow that.");
2779 return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2782 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2788 /* We refuse to clean the root file system with this
2789 * call. This is extra paranoia to never cause a really
2790 * seriously broken system. */
2791 if (path_equal(path, "/")) {
2792 log_error("Attempted to remove entire root file system, and we can't allow that.");
2796 fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2799 if (errno != ENOTDIR)
2803 if (statfs(path, &s) < 0)
2806 if (!is_temporary_fs(&s)) {
2807 log_error("Attempted to remove disk file system, and we can't allow that.");
2812 if (delete_root && !only_dirs)
2813 if (unlink(path) < 0 && errno != ENOENT)
2820 if (fstatfs(fd, &s) < 0) {
2825 if (!is_temporary_fs(&s)) {
2826 log_error("Attempted to remove disk file system, and we can't allow that.");
2832 r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2835 if (honour_sticky && file_is_priv_sticky(path) > 0)
2838 if (rmdir(path) < 0 && errno != ENOENT) {
2847 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2848 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2851 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2852 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2855 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2858 /* Under the assumption that we are running privileged we
2859 * first change the access mode and only then hand out
2860 * ownership to avoid a window where access is too open. */
2862 if (mode != (mode_t) -1)
2863 if (chmod(path, mode) < 0)
2866 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2867 if (chown(path, uid, gid) < 0)
2873 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2876 /* Under the assumption that we are running privileged we
2877 * first change the access mode and only then hand out
2878 * ownership to avoid a window where access is too open. */
2880 if (mode != (mode_t) -1)
2881 if (fchmod(fd, mode) < 0)
2884 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2885 if (fchown(fd, uid, gid) < 0)
2891 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2895 /* Allocates the cpuset in the right size */
2898 if (!(r = CPU_ALLOC(n)))
2901 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2902 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2912 if (errno != EINVAL)
2919 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2920 static const char status_indent[] = " "; /* "[" STATUS "] " */
2921 _cleanup_free_ char *s = NULL;
2922 _cleanup_close_ int fd = -1;
2923 struct iovec iovec[6] = {};
2925 static bool prev_ephemeral;
2929 /* This is independent of logging, as status messages are
2930 * optional and go exclusively to the console. */
2932 if (vasprintf(&s, format, ap) < 0)
2935 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2948 sl = status ? sizeof(status_indent)-1 : 0;
2954 e = ellipsize(s, emax, 75);
2962 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2963 prev_ephemeral = ephemeral;
2966 if (!isempty(status)) {
2967 IOVEC_SET_STRING(iovec[n++], "[");
2968 IOVEC_SET_STRING(iovec[n++], status);
2969 IOVEC_SET_STRING(iovec[n++], "] ");
2971 IOVEC_SET_STRING(iovec[n++], status_indent);
2974 IOVEC_SET_STRING(iovec[n++], s);
2976 IOVEC_SET_STRING(iovec[n++], "\n");
2978 if (writev(fd, iovec, n) < 0)
2984 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2990 va_start(ap, format);
2991 r = status_vprintf(status, ellipse, ephemeral, format, ap);
2997 char *replace_env(const char *format, char **env) {
3004 const char *e, *word = format;
3009 for (e = format; *e; e ++) {
3020 if (!(k = strnappend(r, word, e-word-1)))
3029 } else if (*e == '$') {
3030 if (!(k = strnappend(r, word, e-word)))
3046 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3048 k = strappend(r, t);
3062 if (!(k = strnappend(r, word, e-word)))
3073 char **replace_env_argv(char **argv, char **env) {
3075 unsigned k = 0, l = 0;
3077 l = strv_length(argv);
3079 if (!(r = new(char*, l+1)))
3082 STRV_FOREACH(i, argv) {
3084 /* If $FOO appears as single word, replace it by the split up variable */
3085 if ((*i)[0] == '$' && (*i)[1] != '{') {
3090 e = strv_env_get(env, *i+1);
3093 if (!(m = strv_split_quoted(e))) {
3104 if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3113 memcpy(r + k, m, q * sizeof(char*));
3121 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3122 if (!(r[k++] = replace_env(*i, env))) {
3132 int fd_columns(int fd) {
3133 struct winsize ws = {};
3135 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3144 unsigned columns(void) {
3148 if (_likely_(cached_columns > 0))
3149 return cached_columns;
3152 e = getenv("COLUMNS");
3157 c = fd_columns(STDOUT_FILENO);
3166 int fd_lines(int fd) {
3167 struct winsize ws = {};
3169 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3178 unsigned lines(void) {
3182 if (_likely_(cached_lines > 0))
3183 return cached_lines;
3186 e = getenv("LINES");
3191 l = fd_lines(STDOUT_FILENO);
3197 return cached_lines;
3200 /* intended to be used as a SIGWINCH sighandler */
3201 void columns_lines_cache_reset(int signum) {
3207 static int cached_on_tty = -1;
3209 if (_unlikely_(cached_on_tty < 0))
3210 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3212 return cached_on_tty;
3215 int files_same(const char *filea, const char *fileb) {
3218 if (stat(filea, &a) < 0)
3221 if (stat(fileb, &b) < 0)
3224 return a.st_dev == b.st_dev &&
3225 a.st_ino == b.st_ino;
3228 int running_in_chroot(void) {
3231 ret = files_same("/proc/1/root", "/");
3238 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3243 assert(percent <= 100);
3244 assert(new_length >= 3);
3246 if (old_length <= 3 || old_length <= new_length)
3247 return strndup(s, old_length);
3249 r = new0(char, new_length+1);
3253 x = (new_length * percent) / 100;
3255 if (x > new_length - 3)
3263 s + old_length - (new_length - x - 3),
3264 new_length - x - 3);
3269 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3273 unsigned k, len, len2;
3276 assert(percent <= 100);
3277 assert(new_length >= 3);
3279 /* if no multibyte characters use ascii_ellipsize_mem for speed */
3280 if (ascii_is_valid(s))
3281 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3283 if (old_length <= 3 || old_length <= new_length)
3284 return strndup(s, old_length);
3286 x = (new_length * percent) / 100;
3288 if (x > new_length - 3)
3292 for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3295 c = utf8_encoded_to_unichar(i);
3298 k += unichar_iswide(c) ? 2 : 1;
3301 if (k > x) /* last character was wide and went over quota */
3304 for (j = s + old_length; k < new_length && j > i; ) {
3307 j = utf8_prev_char(j);
3308 c = utf8_encoded_to_unichar(j);
3311 k += unichar_iswide(c) ? 2 : 1;
3315 /* we don't actually need to ellipsize */
3317 return memdup(s, old_length + 1);
3319 /* make space for ellipsis */
3320 j = utf8_next_char(j);
3323 len2 = s + old_length - j;
3324 e = new(char, len + 3 + len2 + 1);
3329 printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3330 old_length, new_length, x, len, len2, k);
3334 e[len] = 0xe2; /* tri-dot ellipsis: … */
3338 memcpy(e + len + 3, j, len2 + 1);
3343 char *ellipsize(const char *s, size_t length, unsigned percent) {
3344 return ellipsize_mem(s, strlen(s), length, percent);
3347 int touch(const char *path) {
3348 _cleanup_close_ int fd;
3352 /* This just opens the file for writing, ensuring it
3353 * exists. It doesn't call utimensat() the way /usr/bin/touch
3356 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3363 char *unquote(const char *s, const char* quotes) {
3367 /* This is rather stupid, simply removes the heading and
3368 * trailing quotes if there is one. Doesn't care about
3369 * escaping or anything. We should make this smarter one
3376 if (strchr(quotes, s[0]) && s[l-1] == s[0])
3377 return strndup(s+1, l-2);
3382 char *normalize_env_assignment(const char *s) {
3383 _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3386 eq = strchr(s, '=');
3398 memmove(r, t, strlen(t) + 1);
3402 name = strndup(s, eq - s);
3410 value = unquote(strstrip(p), QUOTES);
3414 if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3420 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3431 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3443 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3450 r = wait_for_terminate(pid, &status);
3452 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3456 if (status.si_code == CLD_EXITED) {
3457 if (status.si_status != 0) {
3458 log_warning("%s failed with error code %i.", name, status.si_status);
3459 return status.si_status;
3462 log_debug("%s succeeded.", name);
3465 } else if (status.si_code == CLD_KILLED ||
3466 status.si_code == CLD_DUMPED) {
3468 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3472 log_warning("%s failed due to unknown reason.", name);
3476 noreturn void freeze(void) {
3478 /* Make sure nobody waits for us on a socket anymore */
3479 close_all_fds(NULL, 0);
3487 bool null_or_empty(struct stat *st) {
3490 if (S_ISREG(st->st_mode) && st->st_size <= 0)
3493 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3499 int null_or_empty_path(const char *fn) {
3504 if (stat(fn, &st) < 0)
3507 return null_or_empty(&st);
3510 DIR *xopendirat(int fd, const char *name, int flags) {
3514 assert(!(flags & O_CREAT));
3516 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3529 int signal_from_string_try_harder(const char *s) {
3533 signo = signal_from_string(s);
3535 if (startswith(s, "SIG"))
3536 return signal_from_string(s+3);
3541 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3542 _cleanup_free_ char *t = NULL, *u = NULL;
3545 u = unquote(tagvalue, "\"\'");
3549 enc_len = strlen(u) * 4 + 1;
3550 t = new(char, enc_len);
3554 if (encode_devnode_name(u, t, enc_len) < 0)
3557 return strjoin("/dev/disk/by-", by, "/", t, NULL);
3560 char *fstab_node_to_udev_node(const char *p) {
3563 if (startswith(p, "LABEL="))
3564 return tag_to_udev_node(p+6, "label");
3566 if (startswith(p, "UUID="))
3567 return tag_to_udev_node(p+5, "uuid");
3569 if (startswith(p, "PARTUUID="))
3570 return tag_to_udev_node(p+9, "partuuid");
3572 if (startswith(p, "PARTLABEL="))
3573 return tag_to_udev_node(p+10, "partlabel");
3578 bool tty_is_vc(const char *tty) {
3581 if (startswith(tty, "/dev/"))
3584 return vtnr_from_tty(tty) >= 0;
3587 bool tty_is_console(const char *tty) {
3590 if (startswith(tty, "/dev/"))
3593 return streq(tty, "console");
3596 int vtnr_from_tty(const char *tty) {
3601 if (startswith(tty, "/dev/"))
3604 if (!startswith(tty, "tty") )
3607 if (tty[3] < '0' || tty[3] > '9')
3610 r = safe_atoi(tty+3, &i);
3614 if (i < 0 || i > 63)
3620 char *resolve_dev_console(char **active) {
3623 /* Resolve where /dev/console is pointing to, if /sys is actually ours
3624 * (i.e. not read-only-mounted which is a sign for container setups) */
3626 if (path_is_read_only_fs("/sys") > 0)
3629 if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3632 /* If multiple log outputs are configured the last one is what
3633 * /dev/console points to */
3634 tty = strrchr(*active, ' ');
3640 if (streq(tty, "tty0")) {
3643 /* Get the active VC (e.g. tty1) */
3644 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3646 tty = *active = tmp;
3653 bool tty_is_vc_resolve(const char *tty) {
3654 _cleanup_free_ char *active = NULL;
3658 if (startswith(tty, "/dev/"))
3661 if (streq(tty, "console")) {
3662 tty = resolve_dev_console(&active);
3667 return tty_is_vc(tty);
3670 const char *default_term_for_tty(const char *tty) {
3673 return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3676 bool dirent_is_file(const struct dirent *de) {
3679 if (ignore_file(de->d_name))
3682 if (de->d_type != DT_REG &&
3683 de->d_type != DT_LNK &&
3684 de->d_type != DT_UNKNOWN)
3690 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3693 if (de->d_type != DT_REG &&
3694 de->d_type != DT_LNK &&
3695 de->d_type != DT_UNKNOWN)
3698 if (ignore_file_allow_backup(de->d_name))
3701 return endswith(de->d_name, suffix);
3704 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
3710 /* Executes all binaries in a directory in parallel and waits
3711 * for them to finish. Optionally a timeout is applied. */
3713 executor_pid = fork();
3714 if (executor_pid < 0) {
3715 log_error("Failed to fork: %m");
3718 } else if (executor_pid == 0) {
3719 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
3720 _cleanup_closedir_ DIR *_d = NULL;
3724 /* We fork this all off from a child process so that
3725 * we can somewhat cleanly make use of SIGALRM to set
3728 reset_all_signal_handlers();
3730 assert_se(sigemptyset(&ss) == 0);
3731 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
3733 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3736 d = _d = opendir(directory);
3738 if (errno == ENOENT)
3739 _exit(EXIT_SUCCESS);
3741 log_error("Failed to enumerate directory %s: %m", directory);
3742 _exit(EXIT_FAILURE);
3746 pids = hashmap_new(NULL, NULL);
3749 _exit(EXIT_FAILURE);
3752 FOREACH_DIRENT(de, d, break) {
3753 _cleanup_free_ char *path = NULL;
3756 if (!dirent_is_file(de))
3759 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3761 _exit(EXIT_FAILURE);
3766 log_error("Failed to fork: %m");
3768 } else if (pid == 0) {
3771 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3781 log_error("Failed to execute %s: %m", path);
3782 _exit(EXIT_FAILURE);
3786 log_debug("Spawned %s as " PID_FMT ".", path, pid);
3788 r = hashmap_put(pids, UINT_TO_PTR(pid), path);
3791 _exit(EXIT_FAILURE);
3797 /* Abort execution of this process after the
3798 * timout. We simply rely on SIGALRM as default action
3799 * terminating the process, and turn on alarm(). */
3801 if (timeout != (usec_t) -1)
3802 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
3804 while (!hashmap_isempty(pids)) {
3805 _cleanup_free_ char *path = NULL;
3808 pid = PTR_TO_UINT(hashmap_first_key(pids));
3811 path = hashmap_remove(pids, UINT_TO_PTR(pid));
3814 wait_for_terminate_and_warn(path, pid);
3817 _exit(EXIT_SUCCESS);
3820 wait_for_terminate_and_warn(directory, executor_pid);
3823 int kill_and_sigcont(pid_t pid, int sig) {
3826 r = kill(pid, sig) < 0 ? -errno : 0;
3834 bool nulstr_contains(const char*nulstr, const char *needle) {
3840 NULSTR_FOREACH(i, nulstr)
3841 if (streq(i, needle))
3847 bool plymouth_running(void) {
3848 return access("/run/plymouth/pid", F_OK) >= 0;
3851 char* strshorten(char *s, size_t l) {
3860 static bool hostname_valid_char(char c) {
3862 (c >= 'a' && c <= 'z') ||
3863 (c >= 'A' && c <= 'Z') ||
3864 (c >= '0' && c <= '9') ||
3870 bool hostname_is_valid(const char *s) {
3877 for (p = s, dot = true; *p; p++) {
3884 if (!hostname_valid_char(*p))
3894 if (p-s > HOST_NAME_MAX)
3900 char* hostname_cleanup(char *s, bool lowercase) {
3904 for (p = s, d = s, dot = true; *p; p++) {
3911 } else if (hostname_valid_char(*p)) {
3912 *(d++) = lowercase ? tolower(*p) : *p;
3923 strshorten(s, HOST_NAME_MAX);
3928 int pipe_eof(int fd) {
3929 struct pollfd pollfd = {
3931 .events = POLLIN|POLLHUP,
3936 r = poll(&pollfd, 1, 0);
3943 return pollfd.revents & POLLHUP;
3946 int fd_wait_for_event(int fd, int event, usec_t t) {
3948 struct pollfd pollfd = {
3956 r = ppoll(&pollfd, 1, t == (usec_t) -1 ? NULL : timespec_store(&ts, t), NULL);
3963 return pollfd.revents;
3966 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3977 t = new(char, strlen(path) + 1 + 6 + 1);
3981 fn = basename(path);
3985 stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
3987 fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
3993 f = fdopen(fd, "we");
4006 int terminal_vhangup_fd(int fd) {
4009 if (ioctl(fd, TIOCVHANGUP) < 0)
4015 int terminal_vhangup(const char *name) {
4016 _cleanup_close_ int fd;
4018 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4022 return terminal_vhangup_fd(fd);
4025 int vt_disallocate(const char *name) {
4029 /* Deallocate the VT if possible. If not possible
4030 * (i.e. because it is the active one), at least clear it
4031 * entirely (including the scrollback buffer) */
4033 if (!startswith(name, "/dev/"))
4036 if (!tty_is_vc(name)) {
4037 /* So this is not a VT. I guess we cannot deallocate
4038 * it then. But let's at least clear the screen */
4040 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4045 "\033[r" /* clear scrolling region */
4046 "\033[H" /* move home */
4047 "\033[2J", /* clear screen */
4054 if (!startswith(name, "/dev/tty"))
4057 r = safe_atou(name+8, &u);
4064 /* Try to deallocate */
4065 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4069 r = ioctl(fd, VT_DISALLOCATE, u);
4078 /* Couldn't deallocate, so let's clear it fully with
4080 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4085 "\033[r" /* clear scrolling region */
4086 "\033[H" /* move home */
4087 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4094 int copy_file(const char *from, const char *to, int flags) {
4095 _cleanup_close_ int fdf = -1;
4101 fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4105 fdt = open(to, flags|O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
4113 n = read(fdf, buf, sizeof(buf));
4127 k = loop_write(fdt, buf, n, false);
4129 r = k < 0 ? k : (errno ? -errno : -EIO);
4138 r = close_nointr(fdt);
4148 int symlink_atomic(const char *from, const char *to) {
4150 _cleanup_free_ char *t;
4160 t = new(char, strlen(to) + 1 + 16 + 1);
4168 x = stpcpy(t+k+1, fn);
4171 for (i = 0; i < 16; i++) {
4172 *(x++) = hexchar(u & 0xF);
4178 if (symlink(from, t) < 0)
4181 if (rename(t, to) < 0) {
4190 bool display_is_local(const char *display) {
4194 display[0] == ':' &&
4195 display[1] >= '0' &&
4199 int socket_from_display(const char *display, char **path) {
4206 if (!display_is_local(display))
4209 k = strspn(display+1, "0123456789");
4211 f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4215 c = stpcpy(f, "/tmp/.X11-unix/X");
4216 memcpy(c, display+1, k);
4225 const char **username,
4226 uid_t *uid, gid_t *gid,
4228 const char **shell) {
4236 /* We enforce some special rules for uid=0: in order to avoid
4237 * NSS lookups for root we hardcode its data. */
4239 if (streq(*username, "root") || streq(*username, "0")) {
4257 if (parse_uid(*username, &u) >= 0) {
4261 /* If there are multiple users with the same id, make
4262 * sure to leave $USER to the configured value instead
4263 * of the first occurrence in the database. However if
4264 * the uid was configured by a numeric uid, then let's
4265 * pick the real username from /etc/passwd. */
4267 *username = p->pw_name;
4270 p = getpwnam(*username);
4274 return errno > 0 ? -errno : -ESRCH;
4286 *shell = p->pw_shell;
4291 char* uid_to_name(uid_t uid) {
4296 return strdup("root");
4300 return strdup(p->pw_name);
4302 if (asprintf(&r, "%lu", (unsigned long) uid) < 0)
4308 char* gid_to_name(gid_t gid) {
4313 return strdup("root");
4317 return strdup(p->gr_name);
4319 if (asprintf(&r, "%lu", (unsigned long) gid) < 0)
4325 int get_group_creds(const char **groupname, gid_t *gid) {
4331 /* We enforce some special rules for gid=0: in order to avoid
4332 * NSS lookups for root we hardcode its data. */
4334 if (streq(*groupname, "root") || streq(*groupname, "0")) {
4335 *groupname = "root";
4343 if (parse_gid(*groupname, &id) >= 0) {
4348 *groupname = g->gr_name;
4351 g = getgrnam(*groupname);
4355 return errno > 0 ? -errno : -ESRCH;
4363 int in_gid(gid_t gid) {
4365 int ngroups_max, r, i;
4367 if (getgid() == gid)
4370 if (getegid() == gid)
4373 ngroups_max = sysconf(_SC_NGROUPS_MAX);
4374 assert(ngroups_max > 0);
4376 gids = alloca(sizeof(gid_t) * ngroups_max);
4378 r = getgroups(ngroups_max, gids);
4382 for (i = 0; i < r; i++)
4389 int in_group(const char *name) {
4393 r = get_group_creds(&name, &gid);
4400 int glob_exists(const char *path) {
4401 _cleanup_globfree_ glob_t g = {};
4407 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4409 if (k == GLOB_NOMATCH)
4411 else if (k == GLOB_NOSPACE)
4414 return !strv_isempty(g.gl_pathv);
4416 return errno ? -errno : -EIO;
4419 int glob_extend(char ***strv, const char *path) {
4420 _cleanup_globfree_ glob_t g = {};
4425 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4427 if (k == GLOB_NOMATCH)
4429 else if (k == GLOB_NOSPACE)
4431 else if (k != 0 || strv_isempty(g.gl_pathv))
4432 return errno ? -errno : -EIO;
4434 STRV_FOREACH(p, g.gl_pathv) {
4435 k = strv_extend(strv, *p);
4443 int dirent_ensure_type(DIR *d, struct dirent *de) {
4449 if (de->d_type != DT_UNKNOWN)
4452 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4456 S_ISREG(st.st_mode) ? DT_REG :
4457 S_ISDIR(st.st_mode) ? DT_DIR :
4458 S_ISLNK(st.st_mode) ? DT_LNK :
4459 S_ISFIFO(st.st_mode) ? DT_FIFO :
4460 S_ISSOCK(st.st_mode) ? DT_SOCK :
4461 S_ISCHR(st.st_mode) ? DT_CHR :
4462 S_ISBLK(st.st_mode) ? DT_BLK :
4468 int in_search_path(const char *path, char **search) {
4470 _cleanup_free_ char *parent = NULL;
4473 r = path_get_parent(path, &parent);
4477 STRV_FOREACH(i, search)
4478 if (path_equal(parent, *i))
4484 int get_files_in_directory(const char *path, char ***list) {
4485 _cleanup_closedir_ DIR *d = NULL;
4486 size_t bufsize = 0, n = 0;
4487 _cleanup_strv_free_ char **l = NULL;
4491 /* Returns all files in a directory in *list, and the number
4492 * of files as return value. If list is NULL returns only the
4504 if (!de && errno != 0)
4509 dirent_ensure_type(d, de);
4511 if (!dirent_is_file(de))
4515 /* one extra slot is needed for the terminating NULL */
4516 if (!GREEDY_REALLOC(l, bufsize, n + 2))
4519 l[n] = strdup(de->d_name);
4530 l = NULL; /* avoid freeing */
4536 char *strjoin(const char *x, ...) {
4550 t = va_arg(ap, const char *);
4555 if (n > ((size_t) -1) - l) {
4579 t = va_arg(ap, const char *);
4593 bool is_main_thread(void) {
4594 static thread_local int cached = 0;
4596 if (_unlikely_(cached == 0))
4597 cached = getpid() == gettid() ? 1 : -1;
4602 int block_get_whole_disk(dev_t d, dev_t *ret) {
4609 /* If it has a queue this is good enough for us */
4610 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4613 r = access(p, F_OK);
4621 /* If it is a partition find the originating device */
4622 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4625 r = access(p, F_OK);
4631 /* Get parent dev_t */
4632 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4635 r = read_one_line_file(p, &s);
4641 r = sscanf(s, "%u:%u", &m, &n);
4647 /* Only return this if it is really good enough for us. */
4648 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4651 r = access(p, F_OK);
4655 *ret = makedev(m, n);
4662 int file_is_priv_sticky(const char *p) {
4667 if (lstat(p, &st) < 0)
4671 (st.st_uid == 0 || st.st_uid == getuid()) &&
4672 (st.st_mode & S_ISVTX);
4675 static const char *const ioprio_class_table[] = {
4676 [IOPRIO_CLASS_NONE] = "none",
4677 [IOPRIO_CLASS_RT] = "realtime",
4678 [IOPRIO_CLASS_BE] = "best-effort",
4679 [IOPRIO_CLASS_IDLE] = "idle"
4682 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4684 static const char *const sigchld_code_table[] = {
4685 [CLD_EXITED] = "exited",
4686 [CLD_KILLED] = "killed",
4687 [CLD_DUMPED] = "dumped",
4688 [CLD_TRAPPED] = "trapped",
4689 [CLD_STOPPED] = "stopped",
4690 [CLD_CONTINUED] = "continued",
4693 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4695 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4696 [LOG_FAC(LOG_KERN)] = "kern",
4697 [LOG_FAC(LOG_USER)] = "user",
4698 [LOG_FAC(LOG_MAIL)] = "mail",
4699 [LOG_FAC(LOG_DAEMON)] = "daemon",
4700 [LOG_FAC(LOG_AUTH)] = "auth",
4701 [LOG_FAC(LOG_SYSLOG)] = "syslog",
4702 [LOG_FAC(LOG_LPR)] = "lpr",
4703 [LOG_FAC(LOG_NEWS)] = "news",
4704 [LOG_FAC(LOG_UUCP)] = "uucp",
4705 [LOG_FAC(LOG_CRON)] = "cron",
4706 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4707 [LOG_FAC(LOG_FTP)] = "ftp",
4708 [LOG_FAC(LOG_LOCAL0)] = "local0",
4709 [LOG_FAC(LOG_LOCAL1)] = "local1",
4710 [LOG_FAC(LOG_LOCAL2)] = "local2",
4711 [LOG_FAC(LOG_LOCAL3)] = "local3",
4712 [LOG_FAC(LOG_LOCAL4)] = "local4",
4713 [LOG_FAC(LOG_LOCAL5)] = "local5",
4714 [LOG_FAC(LOG_LOCAL6)] = "local6",
4715 [LOG_FAC(LOG_LOCAL7)] = "local7"
4718 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4720 static const char *const log_level_table[] = {
4721 [LOG_EMERG] = "emerg",
4722 [LOG_ALERT] = "alert",
4723 [LOG_CRIT] = "crit",
4725 [LOG_WARNING] = "warning",
4726 [LOG_NOTICE] = "notice",
4727 [LOG_INFO] = "info",
4728 [LOG_DEBUG] = "debug"
4731 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
4733 static const char* const sched_policy_table[] = {
4734 [SCHED_OTHER] = "other",
4735 [SCHED_BATCH] = "batch",
4736 [SCHED_IDLE] = "idle",
4737 [SCHED_FIFO] = "fifo",
4741 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
4743 static const char* const rlimit_table[_RLIMIT_MAX] = {
4744 [RLIMIT_CPU] = "LimitCPU",
4745 [RLIMIT_FSIZE] = "LimitFSIZE",
4746 [RLIMIT_DATA] = "LimitDATA",
4747 [RLIMIT_STACK] = "LimitSTACK",
4748 [RLIMIT_CORE] = "LimitCORE",
4749 [RLIMIT_RSS] = "LimitRSS",
4750 [RLIMIT_NOFILE] = "LimitNOFILE",
4751 [RLIMIT_AS] = "LimitAS",
4752 [RLIMIT_NPROC] = "LimitNPROC",
4753 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
4754 [RLIMIT_LOCKS] = "LimitLOCKS",
4755 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
4756 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
4757 [RLIMIT_NICE] = "LimitNICE",
4758 [RLIMIT_RTPRIO] = "LimitRTPRIO",
4759 [RLIMIT_RTTIME] = "LimitRTTIME"
4762 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
4764 static const char* const ip_tos_table[] = {
4765 [IPTOS_LOWDELAY] = "low-delay",
4766 [IPTOS_THROUGHPUT] = "throughput",
4767 [IPTOS_RELIABILITY] = "reliability",
4768 [IPTOS_LOWCOST] = "low-cost",
4771 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
4773 static const char *const __signal_table[] = {
4790 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
4801 [SIGVTALRM] = "VTALRM",
4803 [SIGWINCH] = "WINCH",
4809 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
4811 const char *signal_to_string(int signo) {
4812 static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
4815 name = __signal_to_string(signo);
4819 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
4820 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
4822 snprintf(buf, sizeof(buf), "%d", signo);
4827 int signal_from_string(const char *s) {
4832 signo = __signal_from_string(s);
4836 if (startswith(s, "RTMIN+")) {
4840 if (safe_atou(s, &u) >= 0) {
4841 signo = (int) u + offset;
4842 if (signo > 0 && signo < _NSIG)
4848 bool kexec_loaded(void) {
4849 bool loaded = false;
4852 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
4860 int strdup_or_null(const char *a, char **b) {
4878 int prot_from_flags(int flags) {
4880 switch (flags & O_ACCMODE) {
4889 return PROT_READ|PROT_WRITE;
4896 char *format_bytes(char *buf, size_t l, off_t t) {
4899 static const struct {
4903 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4904 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4905 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
4906 { "G", 1024ULL*1024ULL*1024ULL },
4907 { "M", 1024ULL*1024ULL },
4911 for (i = 0; i < ELEMENTSOF(table); i++) {
4913 if (t >= table[i].factor) {
4916 (unsigned long long) (t / table[i].factor),
4917 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
4924 snprintf(buf, l, "%lluB", (unsigned long long) t);
4932 void* memdup(const void *p, size_t l) {
4945 int fd_inc_sndbuf(int fd, size_t n) {
4947 socklen_t l = sizeof(value);
4949 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
4950 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4953 /* If we have the privileges we will ignore the kernel limit. */
4956 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
4957 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
4963 int fd_inc_rcvbuf(int fd, size_t n) {
4965 socklen_t l = sizeof(value);
4967 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
4968 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4971 /* If we have the privileges we will ignore the kernel limit. */
4974 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
4975 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
4980 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
4981 pid_t parent_pid, agent_pid;
4983 bool stdout_is_tty, stderr_is_tty;
4991 parent_pid = getpid();
4993 /* Spawns a temporary TTY agent, making sure it goes away when
5000 if (agent_pid != 0) {
5007 * Make sure the agent goes away when the parent dies */
5008 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5009 _exit(EXIT_FAILURE);
5011 /* Check whether our parent died before we were able
5012 * to set the death signal */
5013 if (getppid() != parent_pid)
5014 _exit(EXIT_SUCCESS);
5016 /* Don't leak fds to the agent */
5017 close_all_fds(except, n_except);
5019 stdout_is_tty = isatty(STDOUT_FILENO);
5020 stderr_is_tty = isatty(STDERR_FILENO);
5022 if (!stdout_is_tty || !stderr_is_tty) {
5023 /* Detach from stdout/stderr. and reopen
5024 * /dev/tty for them. This is important to
5025 * ensure that when systemctl is started via
5026 * popen() or a similar call that expects to
5027 * read EOF we actually do generate EOF and
5028 * not delay this indefinitely by because we
5029 * keep an unused copy of stdin around. */
5030 fd = open("/dev/tty", O_WRONLY);
5032 log_error("Failed to open /dev/tty: %m");
5033 _exit(EXIT_FAILURE);
5037 dup2(fd, STDOUT_FILENO);
5040 dup2(fd, STDERR_FILENO);
5046 /* Count arguments */
5048 for (n = 0; va_arg(ap, char*); n++)
5053 l = alloca(sizeof(char *) * (n + 1));
5055 /* Fill in arguments */
5057 for (i = 0; i <= n; i++)
5058 l[i] = va_arg(ap, char*);
5062 _exit(EXIT_FAILURE);
5065 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5066 struct rlimit highest, fixed;
5070 if (setrlimit(resource, rlim) >= 0)
5076 /* So we failed to set the desired setrlimit, then let's try
5077 * to get as close as we can */
5078 assert_se(getrlimit(resource, &highest) == 0);
5080 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5081 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5083 if (setrlimit(resource, &fixed) < 0)
5089 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5090 _cleanup_fclose_ FILE *f = NULL;
5101 path = procfs_file_alloca(pid, "environ");
5103 f = fopen(path, "re");
5111 char line[LINE_MAX];
5114 for (i = 0; i < sizeof(line)-1; i++) {
5118 if (_unlikely_(c == EOF)) {
5128 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5129 value = strdup(line + l + 1);
5143 bool is_valid_documentation_url(const char *url) {
5146 if (startswith(url, "http://") && url[7])
5149 if (startswith(url, "https://") && url[8])
5152 if (startswith(url, "file:") && url[5])
5155 if (startswith(url, "info:") && url[5])
5158 if (startswith(url, "man:") && url[4])
5164 bool in_initrd(void) {
5165 static int saved = -1;
5171 /* We make two checks here:
5173 * 1. the flag file /etc/initrd-release must exist
5174 * 2. the root file system must be a memory file system
5176 * The second check is extra paranoia, since misdetecting an
5177 * initrd can have bad bad consequences due the initrd
5178 * emptying when transititioning to the main systemd.
5181 saved = access("/etc/initrd-release", F_OK) >= 0 &&
5182 statfs("/", &s) >= 0 &&
5183 is_temporary_fs(&s);
5188 void warn_melody(void) {
5189 _cleanup_close_ int fd = -1;
5191 fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5195 /* Yeah, this is synchronous. Kinda sucks. But well... */
5197 ioctl(fd, KIOCSOUND, (int)(1193180/440));
5198 usleep(125*USEC_PER_MSEC);
5200 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5201 usleep(125*USEC_PER_MSEC);
5203 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5204 usleep(125*USEC_PER_MSEC);
5206 ioctl(fd, KIOCSOUND, 0);
5209 int make_console_stdio(void) {
5212 /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5214 fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5216 log_error("Failed to acquire terminal: %s", strerror(-fd));
5222 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5229 int get_home_dir(char **_h) {
5237 /* Take the user specified one */
5248 /* Hardcode home directory for root to avoid NSS */
5251 h = strdup("/root");
5259 /* Check the database... */
5263 return errno > 0 ? -errno : -ESRCH;
5265 if (!path_is_absolute(p->pw_dir))
5268 h = strdup(p->pw_dir);
5276 int get_shell(char **_s) {
5284 /* Take the user specified one */
5285 e = getenv("SHELL");
5295 /* Hardcode home directory for root to avoid NSS */
5298 s = strdup("/bin/sh");
5306 /* Check the database... */
5310 return errno > 0 ? -errno : -ESRCH;
5312 if (!path_is_absolute(p->pw_shell))
5315 s = strdup(p->pw_shell);
5323 bool filename_is_safe(const char *p) {
5337 if (strlen(p) > FILENAME_MAX)
5343 bool string_is_safe(const char *p) {
5348 for (t = p; *t; t++) {
5349 if (*t > 0 && *t < ' ')
5352 if (strchr("\\\"\'", *t))
5360 * Check if a string contains control characters.
5361 * Spaces and tabs are not considered control characters.
5363 bool string_has_cc(const char *p) {
5368 for (t = p; *t; t++)
5369 if (*t > 0 && *t < ' ' && *t != '\t')
5375 bool path_is_safe(const char *p) {
5380 if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5383 if (strlen(p) > PATH_MAX)
5386 /* The following two checks are not really dangerous, but hey, they still are confusing */
5387 if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5390 if (strstr(p, "//"))
5396 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5397 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5398 int (*compar) (const void *, const void *, void *), void *arg) {
5407 p = (void *)(((const char *) base) + (idx * size));
5408 comparison = compar(key, p, arg);
5411 else if (comparison > 0)
5419 bool is_locale_utf8(void) {
5421 static int cached_answer = -1;
5423 if (cached_answer >= 0)
5426 if (!setlocale(LC_ALL, "")) {
5427 cached_answer = true;
5431 set = nl_langinfo(CODESET);
5433 cached_answer = true;
5437 if (streq(set, "UTF-8")) {
5438 cached_answer = true;
5442 /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5443 * unset and everything can do to UTF-8 nowadays. */
5444 set = setlocale(LC_CTYPE, NULL);
5446 cached_answer = true;
5450 /* Check result, but ignore the result if C was set
5454 !getenv("LC_ALL") &&
5455 !getenv("LC_CTYPE") &&
5459 return (bool) cached_answer;
5462 const char *draw_special_char(DrawSpecialChar ch) {
5463 static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5466 [DRAW_TREE_VERTICAL] = "\342\224\202 ", /* │ */
5467 [DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
5468 [DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
5469 [DRAW_TREE_SPACE] = " ", /* */
5470 [DRAW_TRIANGULAR_BULLET] = "\342\200\243", /* ‣ */
5471 [DRAW_BLACK_CIRCLE] = "\342\227\217", /* ● */
5472 [DRAW_ARROW] = "\342\206\222", /* → */
5475 /* ASCII fallback */ {
5476 [DRAW_TREE_VERTICAL] = "| ",
5477 [DRAW_TREE_BRANCH] = "|-",
5478 [DRAW_TREE_RIGHT] = "`-",
5479 [DRAW_TREE_SPACE] = " ",
5480 [DRAW_TRIANGULAR_BULLET] = ">",
5481 [DRAW_BLACK_CIRCLE] = "*",
5482 [DRAW_ARROW] = "->",
5486 return draw_table[!is_locale_utf8()][ch];
5489 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5492 size_t l, old_len, new_len;
5498 old_len = strlen(old_string);
5499 new_len = strlen(new_string);
5512 if (!startswith(f, old_string)) {
5518 nl = l - old_len + new_len;
5519 a = realloc(r, nl + 1);
5527 t = stpcpy(t, new_string);
5539 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5540 const char *i, *begin = NULL;
5545 } state = STATE_OTHER;
5547 size_t osz = 0, isz;
5553 /* Strips ANSI color and replaces TABs by 8 spaces */
5555 isz = _isz ? *_isz : strlen(*ibuf);
5557 f = open_memstream(&obuf, &osz);
5561 for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5566 if (i >= *ibuf + isz) /* EOT */
5568 else if (*i == '\x1B')
5569 state = STATE_ESCAPE;
5570 else if (*i == '\t')
5577 if (i >= *ibuf + isz) { /* EOT */
5580 } else if (*i == '[') {
5581 state = STATE_BRACKET;
5586 state = STATE_OTHER;
5593 if (i >= *ibuf + isz || /* EOT */
5594 (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5597 state = STATE_OTHER;
5599 } else if (*i == 'm')
5600 state = STATE_OTHER;
5622 int on_ac_power(void) {
5623 bool found_offline = false, found_online = false;
5624 _cleanup_closedir_ DIR *d = NULL;
5626 d = opendir("/sys/class/power_supply");
5632 _cleanup_close_ int fd = -1, device = -1;
5638 if (!de && errno != 0)
5644 if (ignore_file(de->d_name))
5647 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5649 if (errno == ENOENT || errno == ENOTDIR)
5655 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5657 if (errno == ENOENT)
5663 n = read(fd, contents, sizeof(contents));
5667 if (n != 6 || memcmp(contents, "Mains\n", 6))
5671 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5673 if (errno == ENOENT)
5679 n = read(fd, contents, sizeof(contents));
5683 if (n != 2 || contents[1] != '\n')
5686 if (contents[0] == '1') {
5687 found_online = true;
5689 } else if (contents[0] == '0')
5690 found_offline = true;
5695 return found_online || !found_offline;
5698 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
5705 if (!path_strv_canonicalize_absolute_uniq(search, root))
5708 STRV_FOREACH(i, search) {
5709 _cleanup_free_ char *p = NULL;
5712 p = strjoin(*i, "/", path, NULL);
5722 if (errno != ENOENT)
5729 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
5730 _cleanup_strv_free_ char **copy = NULL;
5736 if (path_is_absolute(path)) {
5739 f = fopen(path, mode);
5748 copy = strv_copy((char**) search);
5752 return search_and_fopen_internal(path, mode, root, copy, _f);
5755 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
5756 _cleanup_strv_free_ char **s = NULL;
5758 if (path_is_absolute(path)) {
5761 f = fopen(path, mode);
5770 s = strv_split_nulstr(search);
5774 return search_and_fopen_internal(path, mode, root, s, _f);
5777 char *strextend(char **x, ...) {
5784 l = f = *x ? strlen(*x) : 0;
5791 t = va_arg(ap, const char *);
5796 if (n > ((size_t) -1) - l) {
5805 r = realloc(*x, l+1);
5815 t = va_arg(ap, const char *);
5829 char *strrep(const char *s, unsigned n) {
5837 p = r = malloc(l * n + 1);
5841 for (i = 0; i < n; i++)
5848 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
5855 if (*allocated >= need)
5858 newalloc = MAX(need * 2, 64u / size);
5859 a = newalloc * size;
5861 /* check for overflows */
5862 if (a < size * need)
5870 *allocated = newalloc;
5874 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
5883 q = greedy_realloc(p, allocated, need, size);
5887 if (*allocated > prev)
5888 memzero(q + prev * size, (*allocated - prev) * size);
5893 bool id128_is_valid(const char *s) {
5899 /* Simple formatted 128bit hex string */
5901 for (i = 0; i < l; i++) {
5904 if (!(c >= '0' && c <= '9') &&
5905 !(c >= 'a' && c <= 'z') &&
5906 !(c >= 'A' && c <= 'Z'))
5910 } else if (l == 36) {
5912 /* Formatted UUID */
5914 for (i = 0; i < l; i++) {
5917 if ((i == 8 || i == 13 || i == 18 || i == 23)) {
5921 if (!(c >= '0' && c <= '9') &&
5922 !(c >= 'a' && c <= 'z') &&
5923 !(c >= 'A' && c <= 'Z'))
5934 int split_pair(const char *s, const char *sep, char **l, char **r) {
5949 a = strndup(s, x - s);
5953 b = strdup(x + strlen(sep));
5965 int shall_restore_state(void) {
5966 _cleanup_free_ char *line = NULL;
5971 r = proc_cmdline(&line);
5974 if (r == 0) /* Container ... */
5979 FOREACH_WORD_QUOTED(w, l, line, state) {
5987 e = startswith(n, "systemd.restore_state=");
5991 k = parse_boolean(e);
5999 int proc_cmdline(char **ret) {
6002 if (detect_container(NULL) > 0) {
6003 char *buf = NULL, *p;
6006 r = read_full_file("/proc/1/cmdline", &buf, &sz);
6010 for (p = buf; p + 1 < buf + sz; p++)
6019 r = read_one_line_file("/proc/cmdline", ret);
6026 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6027 _cleanup_free_ char *line = NULL;
6034 r = proc_cmdline(&line);
6036 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
6040 FOREACH_WORD_QUOTED(w, l, line, state) {
6041 char word[l+1], *value;
6046 /* Filter out arguments that are intended only for the
6048 if (!in_initrd() && startswith(word, "rd."))
6051 value = strchr(word, '=');
6055 r = parse_item(word, value);
6063 int container_get_leader(const char *machine, pid_t *pid) {
6064 _cleanup_free_ char *s = NULL, *class = NULL;
6072 p = strappenda("/run/systemd/machines/", machine);
6073 r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6081 if (!streq_ptr(class, "container"))
6084 r = parse_pid(s, &leader);
6094 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *root_fd) {
6095 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1;
6096 const char *pidns, *mntns, *root;
6104 mntns = procfs_file_alloca(pid, "ns/mnt");
6105 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6109 pidns = procfs_file_alloca(pid, "ns/pid");
6110 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6114 root = procfs_file_alloca(pid, "root");
6115 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6119 *pidns_fd = pidnsfd;
6120 *mntns_fd = mntnsfd;
6128 int namespace_enter(int pidns_fd, int mntns_fd, int root_fd) {
6129 assert(pidns_fd >= 0);
6130 assert(mntns_fd >= 0);
6131 assert(root_fd >= 0);
6133 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6136 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6139 if (fchdir(root_fd) < 0)
6142 if (chroot(".") < 0)
6145 if (setresgid(0, 0, 0) < 0)
6148 if (setresuid(0, 0, 0) < 0)
6154 bool pid_is_unwaited(pid_t pid) {
6155 /* Checks whether a PID is still valid at all, including a zombie */
6160 if (kill(pid, 0) >= 0)
6163 return errno != ESRCH;
6166 bool pid_is_alive(pid_t pid) {
6169 /* Checks whether a PID is still valid and not a zombie */
6174 r = get_process_state(pid);
6175 if (r == -ENOENT || r == 'Z')
6181 int getpeercred(int fd, struct ucred *ucred) {
6182 socklen_t n = sizeof(struct ucred);
6189 r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6193 if (n != sizeof(struct ucred))
6196 /* Check if the data is actually useful and not suppressed due
6197 * to namespacing issues */
6205 int getpeersec(int fd, char **ret) {
6217 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6221 if (errno != ERANGE)
6228 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6244 /* This is much like like mkostemp() but is subject to umask(). */
6245 int mkostemp_safe(char *pattern, int flags) {
6246 _cleanup_umask_ mode_t u;
6253 fd = mkostemp(pattern, flags);
6260 int open_tmpfile(const char *path, int flags) {
6267 /* Try O_TMPFILE first, if it is supported */
6268 fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6273 /* Fall back to unguessable name + unlinking */
6274 p = strappenda(path, "/systemd-tmp-XXXXXX");
6276 fd = mkostemp_safe(p, flags);
6284 int fd_warn_permissions(const char *path, int fd) {
6287 if (fstat(fd, &st) < 0)
6290 if (st.st_mode & 0111)
6291 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6293 if (st.st_mode & 0002)
6294 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6296 if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6297 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);
6302 unsigned long personality_from_string(const char *p) {
6304 /* Parse a personality specifier. We introduce our own
6305 * identifiers that indicate specific ABIs, rather than just
6306 * hints regarding the register size, since we want to keep
6307 * things open for multiple locally supported ABIs for the
6308 * same register size. We try to reuse the ABI identifiers
6309 * used by libseccomp. */
6311 #if defined(__x86_64__)
6313 if (streq(p, "x86"))
6316 if (streq(p, "x86-64"))
6319 #elif defined(__i386__)
6321 if (streq(p, "x86"))
6325 /* personality(7) documents that 0xffffffffUL is used for
6326 * querying the current personality, hence let's use that here
6327 * as error indicator. */
6328 return 0xffffffffUL;
6331 const char* personality_to_string(unsigned long p) {
6333 #if defined(__x86_64__)
6335 if (p == PER_LINUX32)
6341 #elif defined(__i386__)
6350 uint64_t physical_memory(void) {
6353 /* We return this as uint64_t in case we are running as 32bit
6354 * process on a 64bit kernel with huge amounts of memory */
6356 mem = sysconf(_SC_PHYS_PAGES);
6359 return (uint64_t) mem * (uint64_t) page_size();
6362 char* mount_test_option(const char *haystack, const char *needle) {
6364 struct mntent me = {
6365 .mnt_opts = (char*) haystack
6370 /* Like glibc's hasmntopt(), but works on a string, not a
6376 return hasmntopt(&me, needle);
6379 void hexdump(FILE *f, const void *p, size_t s) {
6380 const uint8_t *b = p;
6383 assert(s == 0 || b);
6388 fprintf(f, "%04x ", n);
6390 for (i = 0; i < 16; i++) {
6395 fprintf(f, "%02x ", b[i]);
6403 for (i = 0; i < 16; i++) {
6408 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
6422 int update_reboot_param_file(const char *param)
6428 r = write_string_file(REBOOT_PARAM_FILE, param);
6430 log_error("Failed to write reboot param to "
6431 REBOOT_PARAM_FILE": %s", strerror(-r));
6433 unlink(REBOOT_PARAM_FILE);