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"
89 char **saved_argv = NULL;
91 static volatile unsigned cached_columns = 0;
92 static volatile unsigned cached_lines = 0;
94 size_t page_size(void) {
95 static thread_local size_t pgsz = 0;
98 if (_likely_(pgsz > 0))
101 r = sysconf(_SC_PAGESIZE);
108 bool streq_ptr(const char *a, const char *b) {
110 /* Like streq(), but tries to make sense of NULL pointers */
121 char* endswith(const char *s, const char *postfix) {
128 pl = strlen(postfix);
131 return (char*) s + sl;
136 if (memcmp(s + sl - pl, postfix, pl) != 0)
139 return (char*) s + sl - pl;
142 bool first_word(const char *s, const char *word) {
157 if (memcmp(s, word, wl) != 0)
161 strchr(WHITESPACE, s[wl]);
164 int close_nointr(int fd) {
171 else if (errno == EINTR)
173 * Just ignore EINTR; a retry loop is the wrong
174 * thing to do on Linux.
176 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
177 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
178 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
179 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
186 int safe_close(int fd) {
189 * Like close_nointr() but cannot fail. Guarantees errno is
190 * unchanged. Is a NOP with negative fds passed, and returns
191 * -1, so that it can be used in this syntax:
193 * fd = safe_close(fd);
199 /* The kernel might return pretty much any error code
200 * via close(), but the fd will be closed anyway. The
201 * only condition we want to check for here is whether
202 * the fd was invalid at all... */
204 assert_se(close_nointr(fd) != -EBADF);
210 void close_many(const int fds[], unsigned n_fd) {
213 assert(fds || n_fd <= 0);
215 for (i = 0; i < n_fd; i++)
219 int unlink_noerrno(const char *path) {
230 int parse_boolean(const char *v) {
233 if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
235 else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
241 int parse_pid(const char *s, pid_t* ret_pid) {
242 unsigned long ul = 0;
249 r = safe_atolu(s, &ul);
255 if ((unsigned long) pid != ul)
265 int parse_uid(const char *s, uid_t* ret_uid) {
266 unsigned long ul = 0;
273 r = safe_atolu(s, &ul);
279 if ((unsigned long) uid != ul)
286 int safe_atou(const char *s, unsigned *ret_u) {
294 l = strtoul(s, &x, 0);
296 if (!x || x == s || *x || errno)
297 return errno > 0 ? -errno : -EINVAL;
299 if ((unsigned long) (unsigned) l != l)
302 *ret_u = (unsigned) l;
306 int safe_atoi(const char *s, int *ret_i) {
314 l = strtol(s, &x, 0);
316 if (!x || x == s || *x || errno)
317 return errno > 0 ? -errno : -EINVAL;
319 if ((long) (int) l != l)
326 int safe_atollu(const char *s, long long unsigned *ret_llu) {
328 unsigned long long l;
334 l = strtoull(s, &x, 0);
336 if (!x || x == s || *x || errno)
337 return errno ? -errno : -EINVAL;
343 int safe_atolli(const char *s, long long int *ret_lli) {
351 l = strtoll(s, &x, 0);
353 if (!x || x == s || *x || errno)
354 return errno ? -errno : -EINVAL;
360 int safe_atod(const char *s, double *ret_d) {
367 RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
372 if (!x || x == s || *x || errno)
373 return errno ? -errno : -EINVAL;
379 static size_t strcspn_escaped(const char *s, const char *reject) {
380 bool escaped = false;
383 for (n=0; s[n]; n++) {
386 else if (s[n] == '\\')
388 else if (strchr(reject, s[n]))
394 /* Split a string into words. */
395 char *split(const char *c, size_t *l, const char *separator, bool quoted, char **state) {
398 current = *state ? *state : (char*) c;
400 if (!*current || *c == 0)
403 current += strspn(current, separator);
407 if (quoted && strchr("\'\"", *current)) {
408 char quotechar = *(current++);
409 *l = strcspn_escaped(current, (char[]){quotechar, '\0'});
410 *state = current+*l+1;
412 *l = strcspn_escaped(current, separator);
415 *l = strcspn(current, separator);
419 return (char*) current;
422 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
424 _cleanup_free_ char *line = NULL;
436 p = procfs_file_alloca(pid, "stat");
437 r = read_one_line_file(p, &line);
441 /* Let's skip the pid and comm fields. The latter is enclosed
442 * in () but does not escape any () in its value, so let's
443 * skip over it manually */
445 p = strrchr(line, ')');
457 if ((long unsigned) (pid_t) ppid != ppid)
460 *_ppid = (pid_t) ppid;
465 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
467 _cleanup_free_ char *line = NULL;
473 p = procfs_file_alloca(pid, "stat");
474 r = read_one_line_file(p, &line);
478 /* Let's skip the pid and comm fields. The latter is enclosed
479 * in () but does not escape any () in its value, so let's
480 * skip over it manually */
482 p = strrchr(line, ')');
504 "%*d " /* priority */
506 "%*d " /* num_threads */
507 "%*d " /* itrealvalue */
508 "%llu " /* starttime */,
515 int fchmod_umask(int fd, mode_t m) {
520 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
526 char *truncate_nl(char *s) {
529 s[strcspn(s, NEWLINE)] = 0;
533 int get_process_state(pid_t pid) {
537 _cleanup_free_ char *line = NULL;
541 p = procfs_file_alloca(pid, "stat");
542 r = read_one_line_file(p, &line);
546 p = strrchr(line, ')');
552 if (sscanf(p, " %c", &state) != 1)
555 return (unsigned char) state;
558 int get_process_comm(pid_t pid, char **name) {
565 p = procfs_file_alloca(pid, "comm");
567 r = read_one_line_file(p, name);
574 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
575 _cleanup_fclose_ FILE *f = NULL;
583 p = procfs_file_alloca(pid, "cmdline");
589 if (max_length == 0) {
590 size_t len = 0, allocated = 0;
592 while ((c = getc(f)) != EOF) {
594 if (!GREEDY_REALLOC(r, allocated, len+2)) {
599 r[len++] = isprint(c) ? c : ' ';
609 r = new(char, max_length);
615 while ((c = getc(f)) != EOF) {
637 size_t n = MIN(left-1, 3U);
644 /* Kernel threads have no argv[] */
645 if (r == NULL || r[0] == 0) {
646 _cleanup_free_ char *t = NULL;
654 h = get_process_comm(pid, &t);
658 r = strjoin("[", t, "]", NULL);
667 int is_kernel_thread(pid_t pid) {
679 p = procfs_file_alloca(pid, "cmdline");
684 count = fread(&c, 1, 1, f);
688 /* Kernel threads have an empty cmdline */
691 return eof ? 1 : -errno;
696 int get_process_capeff(pid_t pid, char **capeff) {
702 p = procfs_file_alloca(pid, "status");
704 return get_status_field(p, "\nCapEff:", capeff);
707 int get_process_exe(pid_t pid, char **name) {
715 p = procfs_file_alloca(pid, "exe");
717 r = readlink_malloc(p, name);
719 return r == -ENOENT ? -ESRCH : r;
721 d = endswith(*name, " (deleted)");
728 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
729 _cleanup_fclose_ FILE *f = NULL;
739 p = procfs_file_alloca(pid, "status");
744 FOREACH_LINE(line, f, return -errno) {
749 if (startswith(l, field)) {
751 l += strspn(l, WHITESPACE);
753 l[strcspn(l, WHITESPACE)] = 0;
755 return parse_uid(l, uid);
762 int get_process_uid(pid_t pid, uid_t *uid) {
763 return get_process_id(pid, "Uid:", uid);
766 int get_process_gid(pid_t pid, gid_t *gid) {
767 assert_cc(sizeof(uid_t) == sizeof(gid_t));
768 return get_process_id(pid, "Gid:", gid);
771 char *strnappend(const char *s, const char *suffix, size_t b) {
779 return strndup(suffix, b);
788 if (b > ((size_t) -1) - a)
791 r = new(char, a+b+1);
796 memcpy(r+a, suffix, b);
802 char *strappend(const char *s, const char *suffix) {
803 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
806 int readlink_malloc(const char *p, char **ret) {
821 n = readlink(p, c, l-1);
828 if ((size_t) n < l-1) {
839 int readlink_and_make_absolute(const char *p, char **r) {
840 _cleanup_free_ char *target = NULL;
847 j = readlink_malloc(p, &target);
851 k = file_in_same_dir(p, target);
859 int readlink_and_canonicalize(const char *p, char **r) {
866 j = readlink_and_make_absolute(p, &t);
870 s = canonicalize_file_name(t);
877 path_kill_slashes(*r);
882 int reset_all_signal_handlers(void) {
885 for (sig = 1; sig < _NSIG; sig++) {
886 struct sigaction sa = {
887 .sa_handler = SIG_DFL,
888 .sa_flags = SA_RESTART,
891 if (sig == SIGKILL || sig == SIGSTOP)
894 /* On Linux the first two RT signals are reserved by
895 * glibc, and sigaction() will return EINVAL for them. */
896 if ((sigaction(sig, &sa, NULL) < 0))
904 char *strstrip(char *s) {
907 /* Drops trailing whitespace. Modifies the string in
908 * place. Returns pointer to first non-space character */
910 s += strspn(s, WHITESPACE);
912 for (e = strchr(s, 0); e > s; e --)
913 if (!strchr(WHITESPACE, e[-1]))
921 char *delete_chars(char *s, const char *bad) {
924 /* Drops all whitespace, regardless where in the string */
926 for (f = s, t = s; *f; f++) {
938 char *file_in_same_dir(const char *path, const char *filename) {
945 /* This removes the last component of path and appends
946 * filename, unless the latter is absolute anyway or the
949 if (path_is_absolute(filename))
950 return strdup(filename);
952 if (!(e = strrchr(path, '/')))
953 return strdup(filename);
955 k = strlen(filename);
956 if (!(r = new(char, e-path+1+k+1)))
959 memcpy(r, path, e-path+1);
960 memcpy(r+(e-path)+1, filename, k+1);
965 int rmdir_parents(const char *path, const char *stop) {
974 /* Skip trailing slashes */
975 while (l > 0 && path[l-1] == '/')
981 /* Skip last component */
982 while (l > 0 && path[l-1] != '/')
985 /* Skip trailing slashes */
986 while (l > 0 && path[l-1] == '/')
992 if (!(t = strndup(path, l)))
995 if (path_startswith(stop, t)) {
1004 if (errno != ENOENT)
1011 char hexchar(int x) {
1012 static const char table[16] = "0123456789abcdef";
1014 return table[x & 15];
1017 int unhexchar(char c) {
1019 if (c >= '0' && c <= '9')
1022 if (c >= 'a' && c <= 'f')
1023 return c - 'a' + 10;
1025 if (c >= 'A' && c <= 'F')
1026 return c - 'A' + 10;
1031 char *hexmem(const void *p, size_t l) {
1035 z = r = malloc(l * 2 + 1);
1039 for (x = p; x < (const uint8_t*) p + l; x++) {
1040 *(z++) = hexchar(*x >> 4);
1041 *(z++) = hexchar(*x & 15);
1048 void *unhexmem(const char *p, size_t l) {
1054 z = r = malloc((l + 1) / 2 + 1);
1058 for (x = p; x < p + l; x += 2) {
1061 a = unhexchar(x[0]);
1063 b = unhexchar(x[1]);
1067 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1074 char octchar(int x) {
1075 return '0' + (x & 7);
1078 int unoctchar(char c) {
1080 if (c >= '0' && c <= '7')
1086 char decchar(int x) {
1087 return '0' + (x % 10);
1090 int undecchar(char c) {
1092 if (c >= '0' && c <= '9')
1098 char *cescape(const char *s) {
1104 /* Does C style string escaping. */
1106 r = new(char, strlen(s)*4 + 1);
1110 for (f = s, t = r; *f; f++)
1156 /* For special chars we prefer octal over
1157 * hexadecimal encoding, simply because glib's
1158 * g_strescape() does the same */
1159 if ((*f < ' ') || (*f >= 127)) {
1161 *(t++) = octchar((unsigned char) *f >> 6);
1162 *(t++) = octchar((unsigned char) *f >> 3);
1163 *(t++) = octchar((unsigned char) *f);
1174 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1181 /* Undoes C style string escaping, and optionally prefixes it. */
1183 pl = prefix ? strlen(prefix) : 0;
1185 r = new(char, pl+length+1);
1190 memcpy(r, prefix, pl);
1192 for (f = s, t = r + pl; f < s + length; f++) {
1235 /* This is an extension of the XDG syntax files */
1240 /* hexadecimal encoding */
1243 a = unhexchar(f[1]);
1244 b = unhexchar(f[2]);
1246 if (a < 0 || b < 0) {
1247 /* Invalid escape code, let's take it literal then */
1251 *(t++) = (char) ((a << 4) | b);
1266 /* octal encoding */
1269 a = unoctchar(f[0]);
1270 b = unoctchar(f[1]);
1271 c = unoctchar(f[2]);
1273 if (a < 0 || b < 0 || c < 0) {
1274 /* Invalid escape code, let's take it literal then */
1278 *(t++) = (char) ((a << 6) | (b << 3) | c);
1286 /* premature end of string.*/
1291 /* Invalid escape code, let's take it literal then */
1303 char *cunescape_length(const char *s, size_t length) {
1304 return cunescape_length_with_prefix(s, length, NULL);
1307 char *cunescape(const char *s) {
1310 return cunescape_length(s, strlen(s));
1313 char *xescape(const char *s, const char *bad) {
1317 /* Escapes all chars in bad, in addition to \ and all special
1318 * chars, in \xFF style escaping. May be reversed with
1321 r = new(char, strlen(s) * 4 + 1);
1325 for (f = s, t = r; *f; f++) {
1327 if ((*f < ' ') || (*f >= 127) ||
1328 (*f == '\\') || strchr(bad, *f)) {
1331 *(t++) = hexchar(*f >> 4);
1332 *(t++) = hexchar(*f);
1342 char *ascii_strlower(char *t) {
1347 for (p = t; *p; p++)
1348 if (*p >= 'A' && *p <= 'Z')
1349 *p = *p - 'A' + 'a';
1354 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1358 filename[0] == '.' ||
1359 streq(filename, "lost+found") ||
1360 streq(filename, "aquota.user") ||
1361 streq(filename, "aquota.group") ||
1362 endswith(filename, ".rpmnew") ||
1363 endswith(filename, ".rpmsave") ||
1364 endswith(filename, ".rpmorig") ||
1365 endswith(filename, ".dpkg-old") ||
1366 endswith(filename, ".dpkg-new") ||
1367 endswith(filename, ".swp");
1370 bool ignore_file(const char *filename) {
1373 if (endswith(filename, "~"))
1376 return ignore_file_allow_backup(filename);
1379 int fd_nonblock(int fd, bool nonblock) {
1384 if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1388 flags |= O_NONBLOCK;
1390 flags &= ~O_NONBLOCK;
1392 if (fcntl(fd, F_SETFL, flags) < 0)
1398 int fd_cloexec(int fd, bool cloexec) {
1403 if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1407 flags |= FD_CLOEXEC;
1409 flags &= ~FD_CLOEXEC;
1411 if (fcntl(fd, F_SETFD, flags) < 0)
1417 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1420 assert(n_fdset == 0 || fdset);
1422 for (i = 0; i < n_fdset; i++)
1429 int close_all_fds(const int except[], unsigned n_except) {
1434 assert(n_except == 0 || except);
1436 d = opendir("/proc/self/fd");
1441 /* When /proc isn't available (for example in chroots)
1442 * the fallback is brute forcing through the fd
1445 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1446 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1448 if (fd_in_set(fd, except, n_except))
1451 if (close_nointr(fd) < 0)
1452 if (errno != EBADF && r == 0)
1459 while ((de = readdir(d))) {
1462 if (ignore_file(de->d_name))
1465 if (safe_atoi(de->d_name, &fd) < 0)
1466 /* Let's better ignore this, just in case */
1475 if (fd_in_set(fd, except, n_except))
1478 if (close_nointr(fd) < 0) {
1479 /* Valgrind has its own FD and doesn't want to have it closed */
1480 if (errno != EBADF && r == 0)
1489 bool chars_intersect(const char *a, const char *b) {
1492 /* Returns true if any of the chars in a are in b. */
1493 for (p = a; *p; p++)
1500 bool fstype_is_network(const char *fstype) {
1501 static const char table[] =
1514 x = startswith(fstype, "fuse.");
1518 return nulstr_contains(table, fstype);
1522 _cleanup_close_ int fd;
1524 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1530 TIOCL_GETKMSGREDIRECT,
1534 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1537 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1540 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1546 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1547 struct termios old_termios, new_termios;
1549 char line[LINE_MAX];
1554 if (tcgetattr(fileno(f), &old_termios) >= 0) {
1555 new_termios = old_termios;
1557 new_termios.c_lflag &= ~ICANON;
1558 new_termios.c_cc[VMIN] = 1;
1559 new_termios.c_cc[VTIME] = 0;
1561 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1564 if (t != (usec_t) -1) {
1565 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1566 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1571 k = fread(&c, 1, 1, f);
1573 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1579 *need_nl = c != '\n';
1586 if (t != (usec_t) -1)
1587 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1590 if (!fgets(line, sizeof(line), f))
1595 if (strlen(line) != 1)
1605 int ask(char *ret, const char *replies, const char *text, ...) {
1615 bool need_nl = true;
1618 fputs(ANSI_HIGHLIGHT_ON, stdout);
1625 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1629 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1632 if (r == -EBADMSG) {
1633 puts("Bad input, please try again.");
1644 if (strchr(replies, c)) {
1649 puts("Read unexpected character, please try again.");
1653 int reset_terminal_fd(int fd, bool switch_to_text) {
1654 struct termios termios;
1657 /* Set terminal to some sane defaults */
1661 /* We leave locked terminal attributes untouched, so that
1662 * Plymouth may set whatever it wants to set, and we don't
1663 * interfere with that. */
1665 /* Disable exclusive mode, just in case */
1666 ioctl(fd, TIOCNXCL);
1668 /* Switch to text mode */
1670 ioctl(fd, KDSETMODE, KD_TEXT);
1672 /* Enable console unicode mode */
1673 ioctl(fd, KDSKBMODE, K_UNICODE);
1675 if (tcgetattr(fd, &termios) < 0) {
1680 /* We only reset the stuff that matters to the software. How
1681 * hardware is set up we don't touch assuming that somebody
1682 * else will do that for us */
1684 termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1685 termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1686 termios.c_oflag |= ONLCR;
1687 termios.c_cflag |= CREAD;
1688 termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1690 termios.c_cc[VINTR] = 03; /* ^C */
1691 termios.c_cc[VQUIT] = 034; /* ^\ */
1692 termios.c_cc[VERASE] = 0177;
1693 termios.c_cc[VKILL] = 025; /* ^X */
1694 termios.c_cc[VEOF] = 04; /* ^D */
1695 termios.c_cc[VSTART] = 021; /* ^Q */
1696 termios.c_cc[VSTOP] = 023; /* ^S */
1697 termios.c_cc[VSUSP] = 032; /* ^Z */
1698 termios.c_cc[VLNEXT] = 026; /* ^V */
1699 termios.c_cc[VWERASE] = 027; /* ^W */
1700 termios.c_cc[VREPRINT] = 022; /* ^R */
1701 termios.c_cc[VEOL] = 0;
1702 termios.c_cc[VEOL2] = 0;
1704 termios.c_cc[VTIME] = 0;
1705 termios.c_cc[VMIN] = 1;
1707 if (tcsetattr(fd, TCSANOW, &termios) < 0)
1711 /* Just in case, flush all crap out */
1712 tcflush(fd, TCIOFLUSH);
1717 int reset_terminal(const char *name) {
1718 _cleanup_close_ int fd = -1;
1720 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1724 return reset_terminal_fd(fd, true);
1727 int open_terminal(const char *name, int mode) {
1732 * If a TTY is in the process of being closed opening it might
1733 * cause EIO. This is horribly awful, but unlikely to be
1734 * changed in the kernel. Hence we work around this problem by
1735 * retrying a couple of times.
1737 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1740 assert(!(mode & O_CREAT));
1743 fd = open(name, mode, 0);
1750 /* Max 1s in total */
1754 usleep(50 * USEC_PER_MSEC);
1775 int flush_fd(int fd) {
1776 struct pollfd pollfd = {
1786 r = poll(&pollfd, 1, 0);
1796 l = read(fd, buf, sizeof(buf));
1802 if (errno == EAGAIN)
1811 int acquire_terminal(
1815 bool ignore_tiocstty_eperm,
1818 int fd = -1, notify = -1, r = 0, wd = -1;
1823 /* We use inotify to be notified when the tty is closed. We
1824 * create the watch before checking if we can actually acquire
1825 * it, so that we don't lose any event.
1827 * Note: strictly speaking this actually watches for the
1828 * device being closed, it does *not* really watch whether a
1829 * tty loses its controlling process. However, unless some
1830 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1831 * its tty otherwise this will not become a problem. As long
1832 * as the administrator makes sure not configure any service
1833 * on the same tty as an untrusted user this should not be a
1834 * problem. (Which he probably should not do anyway.) */
1836 if (timeout != (usec_t) -1)
1837 ts = now(CLOCK_MONOTONIC);
1839 if (!fail && !force) {
1840 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1846 wd = inotify_add_watch(notify, name, IN_CLOSE);
1854 struct sigaction sa_old, sa_new = {
1855 .sa_handler = SIG_IGN,
1856 .sa_flags = SA_RESTART,
1860 r = flush_fd(notify);
1865 /* We pass here O_NOCTTY only so that we can check the return
1866 * value TIOCSCTTY and have a reliable way to figure out if we
1867 * successfully became the controlling process of the tty */
1868 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1872 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1873 * if we already own the tty. */
1874 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1876 /* First, try to get the tty */
1877 if (ioctl(fd, TIOCSCTTY, force) < 0)
1880 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1882 /* Sometimes it makes sense to ignore TIOCSCTTY
1883 * returning EPERM, i.e. when very likely we already
1884 * are have this controlling terminal. */
1885 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1888 if (r < 0 && (force || fail || r != -EPERM)) {
1897 assert(notify >= 0);
1900 uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1902 struct inotify_event *e;
1904 if (timeout != (usec_t) -1) {
1907 n = now(CLOCK_MONOTONIC);
1908 if (ts + timeout < n) {
1913 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1923 l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1926 if (errno == EINTR || errno == EAGAIN)
1933 e = (struct inotify_event*) inotify_buffer;
1938 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
1943 step = sizeof(struct inotify_event) + e->len;
1944 assert(step <= (size_t) l);
1946 e = (struct inotify_event*) ((uint8_t*) e + step);
1953 /* We close the tty fd here since if the old session
1954 * ended our handle will be dead. It's important that
1955 * we do this after sleeping, so that we don't enter
1956 * an endless loop. */
1962 r = reset_terminal_fd(fd, true);
1964 log_warning("Failed to reset terminal: %s", strerror(-r));
1975 int release_terminal(void) {
1977 struct sigaction sa_old, sa_new = {
1978 .sa_handler = SIG_IGN,
1979 .sa_flags = SA_RESTART,
1981 _cleanup_close_ int fd;
1983 fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
1987 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1988 * by our own TIOCNOTTY */
1989 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1991 if (ioctl(fd, TIOCNOTTY) < 0)
1994 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1999 int sigaction_many(const struct sigaction *sa, ...) {
2004 while ((sig = va_arg(ap, int)) > 0)
2005 if (sigaction(sig, sa, NULL) < 0)
2012 int ignore_signals(int sig, ...) {
2013 struct sigaction sa = {
2014 .sa_handler = SIG_IGN,
2015 .sa_flags = SA_RESTART,
2021 if (sigaction(sig, &sa, NULL) < 0)
2025 while ((sig = va_arg(ap, int)) > 0)
2026 if (sigaction(sig, &sa, NULL) < 0)
2033 int default_signals(int sig, ...) {
2034 struct sigaction sa = {
2035 .sa_handler = SIG_DFL,
2036 .sa_flags = SA_RESTART,
2041 if (sigaction(sig, &sa, NULL) < 0)
2045 while ((sig = va_arg(ap, int)) > 0)
2046 if (sigaction(sig, &sa, NULL) < 0)
2053 void safe_close_pair(int p[]) {
2057 /* Special case pairs which use the same fd in both
2059 p[0] = p[1] = safe_close(p[0]);
2063 p[0] = safe_close(p[0]);
2064 p[1] = safe_close(p[1]);
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_size(const char *t, off_t base, off_t *size) {
2139 /* Soo, sometimes we want to parse IEC binary suffxies, and
2140 * sometimes SI decimal suffixes. This function can parse
2141 * both. Which one is the right way depends on the
2142 * context. Wikipedia suggests that SI is customary for
2143 * hardrware metrics and network speeds, while IEC is
2144 * customary for most data sizes used by software and volatile
2145 * (RAM) memory. Hence be careful which one you pick!
2147 * In either case we use just K, M, G as suffix, and not Ki,
2148 * Mi, Gi or so (as IEC would suggest). That's because that's
2149 * frickin' ugly. But this means you really need to make sure
2150 * to document which base you are parsing when you use this
2155 unsigned long long factor;
2158 static const struct table iec[] = {
2159 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2160 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2161 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2162 { "G", 1024ULL*1024ULL*1024ULL },
2163 { "M", 1024ULL*1024ULL },
2169 static const struct table si[] = {
2170 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2171 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2172 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2173 { "G", 1000ULL*1000ULL*1000ULL },
2174 { "M", 1000ULL*1000ULL },
2180 const struct table *table;
2182 unsigned long long r = 0;
2183 unsigned n_entries, start_pos = 0;
2186 assert(base == 1000 || base == 1024);
2191 n_entries = ELEMENTSOF(si);
2194 n_entries = ELEMENTSOF(iec);
2200 unsigned long long l2;
2206 l = strtoll(p, &e, 10);
2219 if (*e >= '0' && *e <= '9') {
2222 /* strotoull itself would accept space/+/- */
2223 l2 = strtoull(e, &e2, 10);
2225 if (errno == ERANGE)
2228 /* Ignore failure. E.g. 10.M is valid */
2235 e += strspn(e, WHITESPACE);
2237 for (i = start_pos; i < n_entries; i++)
2238 if (startswith(e, table[i].suffix)) {
2239 unsigned long long tmp;
2240 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2242 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2243 if (tmp > ULLONG_MAX - r)
2247 if ((unsigned long long) (off_t) r != r)
2250 p = e + strlen(table[i].suffix);
2266 int make_stdio(int fd) {
2271 r = dup3(fd, STDIN_FILENO, 0);
2272 s = dup3(fd, STDOUT_FILENO, 0);
2273 t = dup3(fd, STDERR_FILENO, 0);
2278 if (r < 0 || s < 0 || t < 0)
2281 /* We rely here that the new fd has O_CLOEXEC not set */
2286 int make_null_stdio(void) {
2289 null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2293 return make_stdio(null_fd);
2296 bool is_device_path(const char *path) {
2298 /* Returns true on paths that refer to a device, either in
2299 * sysfs or in /dev */
2302 path_startswith(path, "/dev/") ||
2303 path_startswith(path, "/sys/");
2306 int dir_is_empty(const char *path) {
2307 _cleanup_closedir_ DIR *d;
2318 if (!de && errno != 0)
2324 if (!ignore_file(de->d_name))
2329 char* dirname_malloc(const char *path) {
2330 char *d, *dir, *dir2;
2347 int dev_urandom(void *p, size_t n) {
2348 _cleanup_close_ int fd;
2351 fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2353 return errno == ENOENT ? -ENOSYS : -errno;
2355 k = loop_read(fd, p, n, true);
2358 if ((size_t) k != n)
2364 void random_bytes(void *p, size_t n) {
2365 static bool srand_called = false;
2369 r = dev_urandom(p, n);
2373 /* If some idiot made /dev/urandom unavailable to us, he'll
2374 * get a PRNG instead. */
2376 if (!srand_called) {
2379 #ifdef HAVE_SYS_AUXV_H
2380 /* The kernel provides us with a bit of entropy in
2381 * auxv, so let's try to make use of that to seed the
2382 * pseudo-random generator. It's better than
2387 auxv = (void*) getauxval(AT_RANDOM);
2389 x ^= *(unsigned*) auxv;
2392 x ^= (unsigned) now(CLOCK_REALTIME);
2393 x ^= (unsigned) gettid();
2396 srand_called = true;
2399 for (q = p; q < (uint8_t*) p + n; q ++)
2403 void rename_process(const char name[8]) {
2406 /* This is a like a poor man's setproctitle(). It changes the
2407 * comm field, argv[0], and also the glibc's internally used
2408 * name of the process. For the first one a limit of 16 chars
2409 * applies, to the second one usually one of 10 (i.e. length
2410 * of "/sbin/init"), to the third one one of 7 (i.e. length of
2411 * "systemd"). If you pass a longer string it will be
2414 prctl(PR_SET_NAME, name);
2416 if (program_invocation_name)
2417 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2419 if (saved_argc > 0) {
2423 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2425 for (i = 1; i < saved_argc; i++) {
2429 memzero(saved_argv[i], strlen(saved_argv[i]));
2434 void sigset_add_many(sigset_t *ss, ...) {
2441 while ((sig = va_arg(ap, int)) > 0)
2442 assert_se(sigaddset(ss, sig) == 0);
2446 char* gethostname_malloc(void) {
2449 assert_se(uname(&u) >= 0);
2451 if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2452 return strdup(u.nodename);
2454 return strdup(u.sysname);
2457 bool hostname_is_set(void) {
2460 assert_se(uname(&u) >= 0);
2462 return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2465 static char *lookup_uid(uid_t uid) {
2468 _cleanup_free_ char *buf = NULL;
2469 struct passwd pwbuf, *pw = NULL;
2471 /* Shortcut things to avoid NSS lookups */
2473 return strdup("root");
2475 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2479 buf = malloc(bufsize);
2483 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2484 return strdup(pw->pw_name);
2486 if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
2492 char* getlogname_malloc(void) {
2496 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2501 return lookup_uid(uid);
2504 char *getusername_malloc(void) {
2511 return lookup_uid(getuid());
2514 int getttyname_malloc(int fd, char **r) {
2515 char path[PATH_MAX], *c;
2520 k = ttyname_r(fd, path, sizeof(path));
2526 c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2534 int getttyname_harder(int fd, char **r) {
2538 k = getttyname_malloc(fd, &s);
2542 if (streq(s, "tty")) {
2544 return get_ctty(0, NULL, r);
2551 int get_ctty_devnr(pid_t pid, dev_t *d) {
2553 _cleanup_free_ char *line = NULL;
2555 unsigned long ttynr;
2559 p = procfs_file_alloca(pid, "stat");
2560 r = read_one_line_file(p, &line);
2564 p = strrchr(line, ')');
2574 "%*d " /* session */
2579 if (major(ttynr) == 0 && minor(ttynr) == 0)
2588 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2589 char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2590 _cleanup_free_ char *s = NULL;
2597 k = get_ctty_devnr(pid, &devnr);
2601 snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2603 k = readlink_malloc(fn, &s);
2609 /* This is an ugly hack */
2610 if (major(devnr) == 136) {
2611 asprintf(&b, "pts/%lu", (unsigned long) minor(devnr));
2615 /* Probably something like the ptys which have no
2616 * symlink in /dev/char. Let's return something
2617 * vaguely useful. */
2623 if (startswith(s, "/dev/"))
2625 else if (startswith(s, "../"))
2643 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2649 /* This returns the first error we run into, but nevertheless
2650 * tries to go on. This closes the passed fd. */
2656 return errno == ENOENT ? 0 : -errno;
2661 bool is_dir, keep_around;
2667 if (!de && errno != 0) {
2676 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2679 if (de->d_type == DT_UNKNOWN ||
2681 (de->d_type == DT_DIR && root_dev)) {
2682 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2683 if (ret == 0 && errno != ENOENT)
2688 is_dir = S_ISDIR(st.st_mode);
2691 (st.st_uid == 0 || st.st_uid == getuid()) &&
2692 (st.st_mode & S_ISVTX);
2694 is_dir = de->d_type == DT_DIR;
2695 keep_around = false;
2701 /* if root_dev is set, remove subdirectories only, if device is same as dir */
2702 if (root_dev && st.st_dev != root_dev->st_dev)
2705 subdir_fd = openat(fd, de->d_name,
2706 O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2707 if (subdir_fd < 0) {
2708 if (ret == 0 && errno != ENOENT)
2713 r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2714 if (r < 0 && ret == 0)
2718 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2719 if (ret == 0 && errno != ENOENT)
2723 } else if (!only_dirs && !keep_around) {
2725 if (unlinkat(fd, de->d_name, 0) < 0) {
2726 if (ret == 0 && errno != ENOENT)
2737 _pure_ static int is_temporary_fs(struct statfs *s) {
2740 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2741 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2744 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2749 if (fstatfs(fd, &s) < 0) {
2754 /* We refuse to clean disk file systems with this call. This
2755 * is extra paranoia just to be sure we never ever remove
2757 if (!is_temporary_fs(&s)) {
2758 log_error("Attempted to remove disk file system, and we can't allow that.");
2763 return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2766 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2772 /* We refuse to clean the root file system with this
2773 * call. This is extra paranoia to never cause a really
2774 * seriously broken system. */
2775 if (path_equal(path, "/")) {
2776 log_error("Attempted to remove entire root file system, and we can't allow that.");
2780 fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2783 if (errno != ENOTDIR)
2787 if (statfs(path, &s) < 0)
2790 if (!is_temporary_fs(&s)) {
2791 log_error("Attempted to remove disk file system, and we can't allow that.");
2796 if (delete_root && !only_dirs)
2797 if (unlink(path) < 0 && errno != ENOENT)
2804 if (fstatfs(fd, &s) < 0) {
2809 if (!is_temporary_fs(&s)) {
2810 log_error("Attempted to remove disk file system, and we can't allow that.");
2816 r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2819 if (honour_sticky && file_is_priv_sticky(path) > 0)
2822 if (rmdir(path) < 0 && errno != ENOENT) {
2831 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2832 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2835 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2836 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2839 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2842 /* Under the assumption that we are running privileged we
2843 * first change the access mode and only then hand out
2844 * ownership to avoid a window where access is too open. */
2846 if (mode != (mode_t) -1)
2847 if (chmod(path, mode) < 0)
2850 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2851 if (chown(path, uid, gid) < 0)
2857 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2860 /* Under the assumption that we are running privileged we
2861 * first change the access mode and only then hand out
2862 * ownership to avoid a window where access is too open. */
2864 if (mode != (mode_t) -1)
2865 if (fchmod(fd, mode) < 0)
2868 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2869 if (fchown(fd, uid, gid) < 0)
2875 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2879 /* Allocates the cpuset in the right size */
2882 if (!(r = CPU_ALLOC(n)))
2885 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2886 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2896 if (errno != EINVAL)
2903 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2904 static const char status_indent[] = " "; /* "[" STATUS "] " */
2905 _cleanup_free_ char *s = NULL;
2906 _cleanup_close_ int fd = -1;
2907 struct iovec iovec[6] = {};
2909 static bool prev_ephemeral;
2913 /* This is independent of logging, as status messages are
2914 * optional and go exclusively to the console. */
2916 if (vasprintf(&s, format, ap) < 0)
2919 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2932 sl = status ? sizeof(status_indent)-1 : 0;
2938 e = ellipsize(s, emax, 75);
2946 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2947 prev_ephemeral = ephemeral;
2950 if (!isempty(status)) {
2951 IOVEC_SET_STRING(iovec[n++], "[");
2952 IOVEC_SET_STRING(iovec[n++], status);
2953 IOVEC_SET_STRING(iovec[n++], "] ");
2955 IOVEC_SET_STRING(iovec[n++], status_indent);
2958 IOVEC_SET_STRING(iovec[n++], s);
2960 IOVEC_SET_STRING(iovec[n++], "\n");
2962 if (writev(fd, iovec, n) < 0)
2968 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2974 va_start(ap, format);
2975 r = status_vprintf(status, ellipse, ephemeral, format, ap);
2981 char *replace_env(const char *format, char **env) {
2988 const char *e, *word = format;
2993 for (e = format; *e; e ++) {
3004 if (!(k = strnappend(r, word, e-word-1)))
3013 } else if (*e == '$') {
3014 if (!(k = strnappend(r, word, e-word)))
3030 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3032 k = strappend(r, t);
3046 if (!(k = strnappend(r, word, e-word)))
3057 char **replace_env_argv(char **argv, char **env) {
3059 unsigned k = 0, l = 0;
3061 l = strv_length(argv);
3063 if (!(r = new(char*, l+1)))
3066 STRV_FOREACH(i, argv) {
3068 /* If $FOO appears as single word, replace it by the split up variable */
3069 if ((*i)[0] == '$' && (*i)[1] != '{') {
3074 e = strv_env_get(env, *i+1);
3077 if (!(m = strv_split_quoted(e))) {
3088 if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3097 memcpy(r + k, m, q * sizeof(char*));
3105 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3106 if (!(r[k++] = replace_env(*i, env))) {
3116 int fd_columns(int fd) {
3117 struct winsize ws = {};
3119 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3128 unsigned columns(void) {
3132 if (_likely_(cached_columns > 0))
3133 return cached_columns;
3136 e = getenv("COLUMNS");
3141 c = fd_columns(STDOUT_FILENO);
3150 int fd_lines(int fd) {
3151 struct winsize ws = {};
3153 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3162 unsigned lines(void) {
3166 if (_likely_(cached_lines > 0))
3167 return cached_lines;
3170 e = getenv("LINES");
3175 l = fd_lines(STDOUT_FILENO);
3181 return cached_lines;
3184 /* intended to be used as a SIGWINCH sighandler */
3185 void columns_lines_cache_reset(int signum) {
3191 static int cached_on_tty = -1;
3193 if (_unlikely_(cached_on_tty < 0))
3194 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3196 return cached_on_tty;
3199 int files_same(const char *filea, const char *fileb) {
3202 if (stat(filea, &a) < 0)
3205 if (stat(fileb, &b) < 0)
3208 return a.st_dev == b.st_dev &&
3209 a.st_ino == b.st_ino;
3212 int running_in_chroot(void) {
3215 ret = files_same("/proc/1/root", "/");
3222 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3227 assert(percent <= 100);
3228 assert(new_length >= 3);
3230 if (old_length <= 3 || old_length <= new_length)
3231 return strndup(s, old_length);
3233 r = new0(char, new_length+1);
3237 x = (new_length * percent) / 100;
3239 if (x > new_length - 3)
3247 s + old_length - (new_length - x - 3),
3248 new_length - x - 3);
3253 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3257 unsigned k, len, len2;
3260 assert(percent <= 100);
3261 assert(new_length >= 3);
3263 /* if no multibyte characters use ascii_ellipsize_mem for speed */
3264 if (ascii_is_valid(s))
3265 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3267 if (old_length <= 3 || old_length <= new_length)
3268 return strndup(s, old_length);
3270 x = (new_length * percent) / 100;
3272 if (x > new_length - 3)
3276 for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3279 c = utf8_encoded_to_unichar(i);
3282 k += unichar_iswide(c) ? 2 : 1;
3285 if (k > x) /* last character was wide and went over quota */
3288 for (j = s + old_length; k < new_length && j > i; ) {
3291 j = utf8_prev_char(j);
3292 c = utf8_encoded_to_unichar(j);
3295 k += unichar_iswide(c) ? 2 : 1;
3299 /* we don't actually need to ellipsize */
3301 return memdup(s, old_length + 1);
3303 /* make space for ellipsis */
3304 j = utf8_next_char(j);
3307 len2 = s + old_length - j;
3308 e = new(char, len + 3 + len2 + 1);
3313 printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3314 old_length, new_length, x, len, len2, k);
3318 e[len] = 0xe2; /* tri-dot ellipsis: … */
3322 memcpy(e + len + 3, j, len2 + 1);
3327 char *ellipsize(const char *s, size_t length, unsigned percent) {
3328 return ellipsize_mem(s, strlen(s), length, percent);
3331 int touch(const char *path) {
3332 _cleanup_close_ int fd;
3336 /* This just opens the file for writing, ensuring it
3337 * exists. It doesn't call utimensat() the way /usr/bin/touch
3340 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3347 char *unquote(const char *s, const char* quotes) {
3351 /* This is rather stupid, simply removes the heading and
3352 * trailing quotes if there is one. Doesn't care about
3353 * escaping or anything. We should make this smarter one
3360 if (strchr(quotes, s[0]) && s[l-1] == s[0])
3361 return strndup(s+1, l-2);
3366 char *normalize_env_assignment(const char *s) {
3367 _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3370 eq = strchr(s, '=');
3382 memmove(r, t, strlen(t) + 1);
3386 name = strndup(s, eq - s);
3394 value = unquote(strstrip(p), QUOTES);
3398 if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3404 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3415 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3427 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3434 r = wait_for_terminate(pid, &status);
3436 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3440 if (status.si_code == CLD_EXITED) {
3441 if (status.si_status != 0) {
3442 log_warning("%s failed with error code %i.", name, status.si_status);
3443 return status.si_status;
3446 log_debug("%s succeeded.", name);
3449 } else if (status.si_code == CLD_KILLED ||
3450 status.si_code == CLD_DUMPED) {
3452 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3456 log_warning("%s failed due to unknown reason.", name);
3460 noreturn void freeze(void) {
3462 /* Make sure nobody waits for us on a socket anymore */
3463 close_all_fds(NULL, 0);
3471 bool null_or_empty(struct stat *st) {
3474 if (S_ISREG(st->st_mode) && st->st_size <= 0)
3477 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3483 int null_or_empty_path(const char *fn) {
3488 if (stat(fn, &st) < 0)
3491 return null_or_empty(&st);
3494 DIR *xopendirat(int fd, const char *name, int flags) {
3498 assert(!(flags & O_CREAT));
3500 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3513 int signal_from_string_try_harder(const char *s) {
3517 signo = signal_from_string(s);
3519 if (startswith(s, "SIG"))
3520 return signal_from_string(s+3);
3525 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3526 _cleanup_free_ char *t = NULL, *u = NULL;
3529 u = unquote(tagvalue, "\"\'");
3533 enc_len = strlen(u) * 4 + 1;
3534 t = new(char, enc_len);
3538 if (encode_devnode_name(u, t, enc_len) < 0)
3541 return strjoin("/dev/disk/by-", by, "/", t, NULL);
3544 char *fstab_node_to_udev_node(const char *p) {
3547 if (startswith(p, "LABEL="))
3548 return tag_to_udev_node(p+6, "label");
3550 if (startswith(p, "UUID="))
3551 return tag_to_udev_node(p+5, "uuid");
3553 if (startswith(p, "PARTUUID="))
3554 return tag_to_udev_node(p+9, "partuuid");
3556 if (startswith(p, "PARTLABEL="))
3557 return tag_to_udev_node(p+10, "partlabel");
3562 bool tty_is_vc(const char *tty) {
3565 if (startswith(tty, "/dev/"))
3568 return vtnr_from_tty(tty) >= 0;
3571 bool tty_is_console(const char *tty) {
3574 if (startswith(tty, "/dev/"))
3577 return streq(tty, "console");
3580 int vtnr_from_tty(const char *tty) {
3585 if (startswith(tty, "/dev/"))
3588 if (!startswith(tty, "tty") )
3591 if (tty[3] < '0' || tty[3] > '9')
3594 r = safe_atoi(tty+3, &i);
3598 if (i < 0 || i > 63)
3604 char *resolve_dev_console(char **active) {
3607 /* Resolve where /dev/console is pointing to, if /sys is actually ours
3608 * (i.e. not read-only-mounted which is a sign for container setups) */
3610 if (path_is_read_only_fs("/sys") > 0)
3613 if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3616 /* If multiple log outputs are configured the last one is what
3617 * /dev/console points to */
3618 tty = strrchr(*active, ' ');
3624 if (streq(tty, "tty0")) {
3627 /* Get the active VC (e.g. tty1) */
3628 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3630 tty = *active = tmp;
3637 bool tty_is_vc_resolve(const char *tty) {
3638 _cleanup_free_ char *active = NULL;
3642 if (startswith(tty, "/dev/"))
3645 if (streq(tty, "console")) {
3646 tty = resolve_dev_console(&active);
3651 return tty_is_vc(tty);
3654 const char *default_term_for_tty(const char *tty) {
3657 return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3660 bool dirent_is_file(const struct dirent *de) {
3663 if (ignore_file(de->d_name))
3666 if (de->d_type != DT_REG &&
3667 de->d_type != DT_LNK &&
3668 de->d_type != DT_UNKNOWN)
3674 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3677 if (de->d_type != DT_REG &&
3678 de->d_type != DT_LNK &&
3679 de->d_type != DT_UNKNOWN)
3682 if (ignore_file_allow_backup(de->d_name))
3685 return endswith(de->d_name, suffix);
3688 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
3694 /* Executes all binaries in a directory in parallel and waits
3695 * for them to finish. Optionally a timeout is applied. */
3697 executor_pid = fork();
3698 if (executor_pid < 0) {
3699 log_error("Failed to fork: %m");
3702 } else if (executor_pid == 0) {
3703 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
3704 _cleanup_closedir_ DIR *_d = NULL;
3708 /* We fork this all off from a child process so that
3709 * we can somewhat cleanly make use of SIGALRM to set
3712 reset_all_signal_handlers();
3714 assert_se(sigemptyset(&ss) == 0);
3715 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
3717 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3720 d = _d = opendir(directory);
3722 if (errno == ENOENT)
3723 _exit(EXIT_SUCCESS);
3725 log_error("Failed to enumerate directory %s: %m", directory);
3726 _exit(EXIT_FAILURE);
3730 pids = hashmap_new(NULL, NULL);
3733 _exit(EXIT_FAILURE);
3736 FOREACH_DIRENT(de, d, break) {
3737 _cleanup_free_ char *path = NULL;
3740 if (!dirent_is_file(de))
3743 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3745 _exit(EXIT_FAILURE);
3750 log_error("Failed to fork: %m");
3752 } else if (pid == 0) {
3755 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3765 log_error("Failed to execute %s: %m", path);
3766 _exit(EXIT_FAILURE);
3770 log_debug("Spawned %s as " PID_FMT ".", path, pid);
3772 r = hashmap_put(pids, UINT_TO_PTR(pid), path);
3775 _exit(EXIT_FAILURE);
3781 /* Abort execution of this process after the
3782 * timout. We simply rely on SIGALRM as default action
3783 * terminating the process, and turn on alarm(). */
3785 if (timeout != (usec_t) -1)
3786 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
3788 while (!hashmap_isempty(pids)) {
3789 _cleanup_free_ char *path = NULL;
3792 pid = PTR_TO_UINT(hashmap_first_key(pids));
3795 path = hashmap_remove(pids, UINT_TO_PTR(pid));
3798 wait_for_terminate_and_warn(path, pid);
3801 _exit(EXIT_SUCCESS);
3804 wait_for_terminate_and_warn(directory, executor_pid);
3807 int kill_and_sigcont(pid_t pid, int sig) {
3810 r = kill(pid, sig) < 0 ? -errno : 0;
3818 bool nulstr_contains(const char*nulstr, const char *needle) {
3824 NULSTR_FOREACH(i, nulstr)
3825 if (streq(i, needle))
3831 bool plymouth_running(void) {
3832 return access("/run/plymouth/pid", F_OK) >= 0;
3835 char* strshorten(char *s, size_t l) {
3844 static bool hostname_valid_char(char c) {
3846 (c >= 'a' && c <= 'z') ||
3847 (c >= 'A' && c <= 'Z') ||
3848 (c >= '0' && c <= '9') ||
3854 bool hostname_is_valid(const char *s) {
3861 for (p = s, dot = true; *p; p++) {
3868 if (!hostname_valid_char(*p))
3878 if (p-s > HOST_NAME_MAX)
3884 char* hostname_cleanup(char *s, bool lowercase) {
3888 for (p = s, d = s, dot = true; *p; p++) {
3895 } else if (hostname_valid_char(*p)) {
3896 *(d++) = lowercase ? tolower(*p) : *p;
3907 strshorten(s, HOST_NAME_MAX);
3912 int pipe_eof(int fd) {
3913 struct pollfd pollfd = {
3915 .events = POLLIN|POLLHUP,
3920 r = poll(&pollfd, 1, 0);
3927 return pollfd.revents & POLLHUP;
3930 int fd_wait_for_event(int fd, int event, usec_t t) {
3932 struct pollfd pollfd = {
3940 r = ppoll(&pollfd, 1, t == (usec_t) -1 ? NULL : timespec_store(&ts, t), NULL);
3947 return pollfd.revents;
3950 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3961 t = new(char, strlen(path) + 1 + 6 + 1);
3965 fn = basename(path);
3969 stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
3971 fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
3977 f = fdopen(fd, "we");
3990 int terminal_vhangup_fd(int fd) {
3993 if (ioctl(fd, TIOCVHANGUP) < 0)
3999 int terminal_vhangup(const char *name) {
4000 _cleanup_close_ int fd;
4002 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4006 return terminal_vhangup_fd(fd);
4009 int vt_disallocate(const char *name) {
4013 /* Deallocate the VT if possible. If not possible
4014 * (i.e. because it is the active one), at least clear it
4015 * entirely (including the scrollback buffer) */
4017 if (!startswith(name, "/dev/"))
4020 if (!tty_is_vc(name)) {
4021 /* So this is not a VT. I guess we cannot deallocate
4022 * it then. But let's at least clear the screen */
4024 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4029 "\033[r" /* clear scrolling region */
4030 "\033[H" /* move home */
4031 "\033[2J", /* clear screen */
4038 if (!startswith(name, "/dev/tty"))
4041 r = safe_atou(name+8, &u);
4048 /* Try to deallocate */
4049 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4053 r = ioctl(fd, VT_DISALLOCATE, u);
4062 /* Couldn't deallocate, so let's clear it fully with
4064 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4069 "\033[r" /* clear scrolling region */
4070 "\033[H" /* move home */
4071 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4078 int copy_file(const char *from, const char *to, int flags) {
4079 _cleanup_close_ int fdf = -1;
4085 fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4089 fdt = open(to, flags|O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
4097 n = read(fdf, buf, sizeof(buf));
4111 k = loop_write(fdt, buf, n, false);
4113 r = k < 0 ? k : (errno ? -errno : -EIO);
4122 r = close_nointr(fdt);
4132 int symlink_atomic(const char *from, const char *to) {
4134 _cleanup_free_ char *t;
4144 t = new(char, strlen(to) + 1 + 16 + 1);
4152 x = stpcpy(t+k+1, fn);
4155 for (i = 0; i < 16; i++) {
4156 *(x++) = hexchar(u & 0xF);
4162 if (symlink(from, t) < 0)
4165 if (rename(t, to) < 0) {
4174 bool display_is_local(const char *display) {
4178 display[0] == ':' &&
4179 display[1] >= '0' &&
4183 int socket_from_display(const char *display, char **path) {
4190 if (!display_is_local(display))
4193 k = strspn(display+1, "0123456789");
4195 f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4199 c = stpcpy(f, "/tmp/.X11-unix/X");
4200 memcpy(c, display+1, k);
4209 const char **username,
4210 uid_t *uid, gid_t *gid,
4212 const char **shell) {
4220 /* We enforce some special rules for uid=0: in order to avoid
4221 * NSS lookups for root we hardcode its data. */
4223 if (streq(*username, "root") || streq(*username, "0")) {
4241 if (parse_uid(*username, &u) >= 0) {
4245 /* If there are multiple users with the same id, make
4246 * sure to leave $USER to the configured value instead
4247 * of the first occurrence in the database. However if
4248 * the uid was configured by a numeric uid, then let's
4249 * pick the real username from /etc/passwd. */
4251 *username = p->pw_name;
4254 p = getpwnam(*username);
4258 return errno > 0 ? -errno : -ESRCH;
4270 *shell = p->pw_shell;
4275 char* uid_to_name(uid_t uid) {
4280 return strdup("root");
4284 return strdup(p->pw_name);
4286 if (asprintf(&r, "%lu", (unsigned long) uid) < 0)
4292 char* gid_to_name(gid_t gid) {
4297 return strdup("root");
4301 return strdup(p->gr_name);
4303 if (asprintf(&r, "%lu", (unsigned long) gid) < 0)
4309 int get_group_creds(const char **groupname, gid_t *gid) {
4315 /* We enforce some special rules for gid=0: in order to avoid
4316 * NSS lookups for root we hardcode its data. */
4318 if (streq(*groupname, "root") || streq(*groupname, "0")) {
4319 *groupname = "root";
4327 if (parse_gid(*groupname, &id) >= 0) {
4332 *groupname = g->gr_name;
4335 g = getgrnam(*groupname);
4339 return errno > 0 ? -errno : -ESRCH;
4347 int in_gid(gid_t gid) {
4349 int ngroups_max, r, i;
4351 if (getgid() == gid)
4354 if (getegid() == gid)
4357 ngroups_max = sysconf(_SC_NGROUPS_MAX);
4358 assert(ngroups_max > 0);
4360 gids = alloca(sizeof(gid_t) * ngroups_max);
4362 r = getgroups(ngroups_max, gids);
4366 for (i = 0; i < r; i++)
4373 int in_group(const char *name) {
4377 r = get_group_creds(&name, &gid);
4384 int glob_exists(const char *path) {
4385 _cleanup_globfree_ glob_t g = {};
4391 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4393 if (k == GLOB_NOMATCH)
4395 else if (k == GLOB_NOSPACE)
4398 return !strv_isempty(g.gl_pathv);
4400 return errno ? -errno : -EIO;
4403 int glob_extend(char ***strv, const char *path) {
4404 _cleanup_globfree_ glob_t g = {};
4409 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4411 if (k == GLOB_NOMATCH)
4413 else if (k == GLOB_NOSPACE)
4415 else if (k != 0 || strv_isempty(g.gl_pathv))
4416 return errno ? -errno : -EIO;
4418 STRV_FOREACH(p, g.gl_pathv) {
4419 k = strv_extend(strv, *p);
4427 int dirent_ensure_type(DIR *d, struct dirent *de) {
4433 if (de->d_type != DT_UNKNOWN)
4436 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4440 S_ISREG(st.st_mode) ? DT_REG :
4441 S_ISDIR(st.st_mode) ? DT_DIR :
4442 S_ISLNK(st.st_mode) ? DT_LNK :
4443 S_ISFIFO(st.st_mode) ? DT_FIFO :
4444 S_ISSOCK(st.st_mode) ? DT_SOCK :
4445 S_ISCHR(st.st_mode) ? DT_CHR :
4446 S_ISBLK(st.st_mode) ? DT_BLK :
4452 int in_search_path(const char *path, char **search) {
4454 _cleanup_free_ char *parent = NULL;
4457 r = path_get_parent(path, &parent);
4461 STRV_FOREACH(i, search)
4462 if (path_equal(parent, *i))
4468 int get_files_in_directory(const char *path, char ***list) {
4469 _cleanup_closedir_ DIR *d = NULL;
4470 size_t bufsize = 0, n = 0;
4471 _cleanup_strv_free_ char **l = NULL;
4475 /* Returns all files in a directory in *list, and the number
4476 * of files as return value. If list is NULL returns only the
4488 if (!de && errno != 0)
4493 dirent_ensure_type(d, de);
4495 if (!dirent_is_file(de))
4499 /* one extra slot is needed for the terminating NULL */
4500 if (!GREEDY_REALLOC(l, bufsize, n + 2))
4503 l[n] = strdup(de->d_name);
4514 l = NULL; /* avoid freeing */
4520 char *strjoin(const char *x, ...) {
4534 t = va_arg(ap, const char *);
4539 if (n > ((size_t) -1) - l) {
4563 t = va_arg(ap, const char *);
4577 bool is_main_thread(void) {
4578 static thread_local int cached = 0;
4580 if (_unlikely_(cached == 0))
4581 cached = getpid() == gettid() ? 1 : -1;
4586 int block_get_whole_disk(dev_t d, dev_t *ret) {
4593 /* If it has a queue this is good enough for us */
4594 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4597 r = access(p, F_OK);
4605 /* If it is a partition find the originating device */
4606 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4609 r = access(p, F_OK);
4615 /* Get parent dev_t */
4616 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4619 r = read_one_line_file(p, &s);
4625 r = sscanf(s, "%u:%u", &m, &n);
4631 /* Only return this if it is really good enough for us. */
4632 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4635 r = access(p, F_OK);
4639 *ret = makedev(m, n);
4646 int file_is_priv_sticky(const char *p) {
4651 if (lstat(p, &st) < 0)
4655 (st.st_uid == 0 || st.st_uid == getuid()) &&
4656 (st.st_mode & S_ISVTX);
4659 static const char *const ioprio_class_table[] = {
4660 [IOPRIO_CLASS_NONE] = "none",
4661 [IOPRIO_CLASS_RT] = "realtime",
4662 [IOPRIO_CLASS_BE] = "best-effort",
4663 [IOPRIO_CLASS_IDLE] = "idle"
4666 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4668 static const char *const sigchld_code_table[] = {
4669 [CLD_EXITED] = "exited",
4670 [CLD_KILLED] = "killed",
4671 [CLD_DUMPED] = "dumped",
4672 [CLD_TRAPPED] = "trapped",
4673 [CLD_STOPPED] = "stopped",
4674 [CLD_CONTINUED] = "continued",
4677 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4679 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4680 [LOG_FAC(LOG_KERN)] = "kern",
4681 [LOG_FAC(LOG_USER)] = "user",
4682 [LOG_FAC(LOG_MAIL)] = "mail",
4683 [LOG_FAC(LOG_DAEMON)] = "daemon",
4684 [LOG_FAC(LOG_AUTH)] = "auth",
4685 [LOG_FAC(LOG_SYSLOG)] = "syslog",
4686 [LOG_FAC(LOG_LPR)] = "lpr",
4687 [LOG_FAC(LOG_NEWS)] = "news",
4688 [LOG_FAC(LOG_UUCP)] = "uucp",
4689 [LOG_FAC(LOG_CRON)] = "cron",
4690 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4691 [LOG_FAC(LOG_FTP)] = "ftp",
4692 [LOG_FAC(LOG_LOCAL0)] = "local0",
4693 [LOG_FAC(LOG_LOCAL1)] = "local1",
4694 [LOG_FAC(LOG_LOCAL2)] = "local2",
4695 [LOG_FAC(LOG_LOCAL3)] = "local3",
4696 [LOG_FAC(LOG_LOCAL4)] = "local4",
4697 [LOG_FAC(LOG_LOCAL5)] = "local5",
4698 [LOG_FAC(LOG_LOCAL6)] = "local6",
4699 [LOG_FAC(LOG_LOCAL7)] = "local7"
4702 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4704 static const char *const log_level_table[] = {
4705 [LOG_EMERG] = "emerg",
4706 [LOG_ALERT] = "alert",
4707 [LOG_CRIT] = "crit",
4709 [LOG_WARNING] = "warning",
4710 [LOG_NOTICE] = "notice",
4711 [LOG_INFO] = "info",
4712 [LOG_DEBUG] = "debug"
4715 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
4717 static const char* const sched_policy_table[] = {
4718 [SCHED_OTHER] = "other",
4719 [SCHED_BATCH] = "batch",
4720 [SCHED_IDLE] = "idle",
4721 [SCHED_FIFO] = "fifo",
4725 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
4727 static const char* const rlimit_table[_RLIMIT_MAX] = {
4728 [RLIMIT_CPU] = "LimitCPU",
4729 [RLIMIT_FSIZE] = "LimitFSIZE",
4730 [RLIMIT_DATA] = "LimitDATA",
4731 [RLIMIT_STACK] = "LimitSTACK",
4732 [RLIMIT_CORE] = "LimitCORE",
4733 [RLIMIT_RSS] = "LimitRSS",
4734 [RLIMIT_NOFILE] = "LimitNOFILE",
4735 [RLIMIT_AS] = "LimitAS",
4736 [RLIMIT_NPROC] = "LimitNPROC",
4737 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
4738 [RLIMIT_LOCKS] = "LimitLOCKS",
4739 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
4740 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
4741 [RLIMIT_NICE] = "LimitNICE",
4742 [RLIMIT_RTPRIO] = "LimitRTPRIO",
4743 [RLIMIT_RTTIME] = "LimitRTTIME"
4746 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
4748 static const char* const ip_tos_table[] = {
4749 [IPTOS_LOWDELAY] = "low-delay",
4750 [IPTOS_THROUGHPUT] = "throughput",
4751 [IPTOS_RELIABILITY] = "reliability",
4752 [IPTOS_LOWCOST] = "low-cost",
4755 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
4757 static const char *const __signal_table[] = {
4774 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
4785 [SIGVTALRM] = "VTALRM",
4787 [SIGWINCH] = "WINCH",
4793 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
4795 const char *signal_to_string(int signo) {
4796 static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
4799 name = __signal_to_string(signo);
4803 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
4804 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
4806 snprintf(buf, sizeof(buf), "%d", signo);
4811 int signal_from_string(const char *s) {
4816 signo = __signal_from_string(s);
4820 if (startswith(s, "RTMIN+")) {
4824 if (safe_atou(s, &u) >= 0) {
4825 signo = (int) u + offset;
4826 if (signo > 0 && signo < _NSIG)
4832 bool kexec_loaded(void) {
4833 bool loaded = false;
4836 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
4844 int strdup_or_null(const char *a, char **b) {
4862 int prot_from_flags(int flags) {
4864 switch (flags & O_ACCMODE) {
4873 return PROT_READ|PROT_WRITE;
4880 char *format_bytes(char *buf, size_t l, off_t t) {
4883 static const struct {
4887 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4888 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4889 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
4890 { "G", 1024ULL*1024ULL*1024ULL },
4891 { "M", 1024ULL*1024ULL },
4895 for (i = 0; i < ELEMENTSOF(table); i++) {
4897 if (t >= table[i].factor) {
4900 (unsigned long long) (t / table[i].factor),
4901 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
4908 snprintf(buf, l, "%lluB", (unsigned long long) t);
4916 void* memdup(const void *p, size_t l) {
4929 int fd_inc_sndbuf(int fd, size_t n) {
4931 socklen_t l = sizeof(value);
4933 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
4934 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4937 /* If we have the privileges we will ignore the kernel limit. */
4940 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
4941 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
4947 int fd_inc_rcvbuf(int fd, size_t n) {
4949 socklen_t l = sizeof(value);
4951 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
4952 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4955 /* If we have the privileges we will ignore the kernel limit. */
4958 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
4959 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
4964 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
4965 pid_t parent_pid, agent_pid;
4967 bool stdout_is_tty, stderr_is_tty;
4975 parent_pid = getpid();
4977 /* Spawns a temporary TTY agent, making sure it goes away when
4984 if (agent_pid != 0) {
4991 * Make sure the agent goes away when the parent dies */
4992 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
4993 _exit(EXIT_FAILURE);
4995 /* Check whether our parent died before we were able
4996 * to set the death signal */
4997 if (getppid() != parent_pid)
4998 _exit(EXIT_SUCCESS);
5000 /* Don't leak fds to the agent */
5001 close_all_fds(except, n_except);
5003 stdout_is_tty = isatty(STDOUT_FILENO);
5004 stderr_is_tty = isatty(STDERR_FILENO);
5006 if (!stdout_is_tty || !stderr_is_tty) {
5007 /* Detach from stdout/stderr. and reopen
5008 * /dev/tty for them. This is important to
5009 * ensure that when systemctl is started via
5010 * popen() or a similar call that expects to
5011 * read EOF we actually do generate EOF and
5012 * not delay this indefinitely by because we
5013 * keep an unused copy of stdin around. */
5014 fd = open("/dev/tty", O_WRONLY);
5016 log_error("Failed to open /dev/tty: %m");
5017 _exit(EXIT_FAILURE);
5021 dup2(fd, STDOUT_FILENO);
5024 dup2(fd, STDERR_FILENO);
5030 /* Count arguments */
5032 for (n = 0; va_arg(ap, char*); n++)
5037 l = alloca(sizeof(char *) * (n + 1));
5039 /* Fill in arguments */
5041 for (i = 0; i <= n; i++)
5042 l[i] = va_arg(ap, char*);
5046 _exit(EXIT_FAILURE);
5049 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5050 struct rlimit highest, fixed;
5054 if (setrlimit(resource, rlim) >= 0)
5060 /* So we failed to set the desired setrlimit, then let's try
5061 * to get as close as we can */
5062 assert_se(getrlimit(resource, &highest) == 0);
5064 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5065 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5067 if (setrlimit(resource, &fixed) < 0)
5073 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5074 _cleanup_fclose_ FILE *f = NULL;
5085 path = procfs_file_alloca(pid, "environ");
5087 f = fopen(path, "re");
5095 char line[LINE_MAX];
5098 for (i = 0; i < sizeof(line)-1; i++) {
5102 if (_unlikely_(c == EOF)) {
5112 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5113 value = strdup(line + l + 1);
5127 bool is_valid_documentation_url(const char *url) {
5130 if (startswith(url, "http://") && url[7])
5133 if (startswith(url, "https://") && url[8])
5136 if (startswith(url, "file:") && url[5])
5139 if (startswith(url, "info:") && url[5])
5142 if (startswith(url, "man:") && url[4])
5148 bool in_initrd(void) {
5149 static int saved = -1;
5155 /* We make two checks here:
5157 * 1. the flag file /etc/initrd-release must exist
5158 * 2. the root file system must be a memory file system
5160 * The second check is extra paranoia, since misdetecting an
5161 * initrd can have bad bad consequences due the initrd
5162 * emptying when transititioning to the main systemd.
5165 saved = access("/etc/initrd-release", F_OK) >= 0 &&
5166 statfs("/", &s) >= 0 &&
5167 is_temporary_fs(&s);
5172 void warn_melody(void) {
5173 _cleanup_close_ int fd = -1;
5175 fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5179 /* Yeah, this is synchronous. Kinda sucks. But well... */
5181 ioctl(fd, KIOCSOUND, (int)(1193180/440));
5182 usleep(125*USEC_PER_MSEC);
5184 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5185 usleep(125*USEC_PER_MSEC);
5187 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5188 usleep(125*USEC_PER_MSEC);
5190 ioctl(fd, KIOCSOUND, 0);
5193 int make_console_stdio(void) {
5196 /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5198 fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5200 log_error("Failed to acquire terminal: %s", strerror(-fd));
5206 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5213 int get_home_dir(char **_h) {
5221 /* Take the user specified one */
5232 /* Hardcode home directory for root to avoid NSS */
5235 h = strdup("/root");
5243 /* Check the database... */
5247 return errno > 0 ? -errno : -ESRCH;
5249 if (!path_is_absolute(p->pw_dir))
5252 h = strdup(p->pw_dir);
5260 int get_shell(char **_s) {
5268 /* Take the user specified one */
5269 e = getenv("SHELL");
5279 /* Hardcode home directory for root to avoid NSS */
5282 s = strdup("/bin/sh");
5290 /* Check the database... */
5294 return errno > 0 ? -errno : -ESRCH;
5296 if (!path_is_absolute(p->pw_shell))
5299 s = strdup(p->pw_shell);
5307 bool filename_is_safe(const char *p) {
5321 if (strlen(p) > FILENAME_MAX)
5327 bool string_is_safe(const char *p) {
5332 for (t = p; *t; t++) {
5333 if (*t > 0 && *t < ' ')
5336 if (strchr("\\\"\'", *t))
5344 * Check if a string contains control characters.
5345 * Spaces and tabs are not considered control characters.
5347 bool string_has_cc(const char *p) {
5352 for (t = p; *t; t++)
5353 if (*t > 0 && *t < ' ' && *t != '\t')
5359 bool path_is_safe(const char *p) {
5364 if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5367 if (strlen(p) > PATH_MAX)
5370 /* The following two checks are not really dangerous, but hey, they still are confusing */
5371 if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5374 if (strstr(p, "//"))
5380 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5381 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5382 int (*compar) (const void *, const void *, void *), void *arg) {
5391 p = (void *)(((const char *) base) + (idx * size));
5392 comparison = compar(key, p, arg);
5395 else if (comparison > 0)
5403 bool is_locale_utf8(void) {
5405 static int cached_answer = -1;
5407 if (cached_answer >= 0)
5410 if (!setlocale(LC_ALL, "")) {
5411 cached_answer = true;
5415 set = nl_langinfo(CODESET);
5417 cached_answer = true;
5421 if (streq(set, "UTF-8")) {
5422 cached_answer = true;
5426 /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5427 * unset and everything can do to UTF-8 nowadays. */
5428 set = setlocale(LC_CTYPE, NULL);
5430 cached_answer = true;
5434 /* Check result, but ignore the result if C was set
5438 !getenv("LC_ALL") &&
5439 !getenv("LC_CTYPE") &&
5443 return (bool) cached_answer;
5446 const char *draw_special_char(DrawSpecialChar ch) {
5447 static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5449 [DRAW_TREE_VERT] = "\342\224\202 ", /* │ */
5450 [DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
5451 [DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
5452 [DRAW_TREE_SPACE] = " ", /* */
5453 [DRAW_TRIANGULAR_BULLET] = "\342\200\243 ", /* ‣ */
5454 [DRAW_BLACK_CIRCLE] = "\342\227\217 ", /* ● */
5456 /* ASCII fallback */ {
5457 [DRAW_TREE_VERT] = "| ",
5458 [DRAW_TREE_BRANCH] = "|-",
5459 [DRAW_TREE_RIGHT] = "`-",
5460 [DRAW_TREE_SPACE] = " ",
5461 [DRAW_TRIANGULAR_BULLET] = "> ",
5462 [DRAW_BLACK_CIRCLE] = "* ",
5466 return draw_table[!is_locale_utf8()][ch];
5469 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5472 size_t l, old_len, new_len;
5478 old_len = strlen(old_string);
5479 new_len = strlen(new_string);
5492 if (!startswith(f, old_string)) {
5498 nl = l - old_len + new_len;
5499 a = realloc(r, nl + 1);
5507 t = stpcpy(t, new_string);
5519 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5520 const char *i, *begin = NULL;
5525 } state = STATE_OTHER;
5527 size_t osz = 0, isz;
5533 /* Strips ANSI color and replaces TABs by 8 spaces */
5535 isz = _isz ? *_isz : strlen(*ibuf);
5537 f = open_memstream(&obuf, &osz);
5541 for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5546 if (i >= *ibuf + isz) /* EOT */
5548 else if (*i == '\x1B')
5549 state = STATE_ESCAPE;
5550 else if (*i == '\t')
5557 if (i >= *ibuf + isz) { /* EOT */
5560 } else if (*i == '[') {
5561 state = STATE_BRACKET;
5566 state = STATE_OTHER;
5573 if (i >= *ibuf + isz || /* EOT */
5574 (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5577 state = STATE_OTHER;
5579 } else if (*i == 'm')
5580 state = STATE_OTHER;
5602 int on_ac_power(void) {
5603 bool found_offline = false, found_online = false;
5604 _cleanup_closedir_ DIR *d = NULL;
5606 d = opendir("/sys/class/power_supply");
5612 _cleanup_close_ int fd = -1, device = -1;
5618 if (!de && errno != 0)
5624 if (ignore_file(de->d_name))
5627 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5629 if (errno == ENOENT || errno == ENOTDIR)
5635 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5637 if (errno == ENOENT)
5643 n = read(fd, contents, sizeof(contents));
5647 if (n != 6 || memcmp(contents, "Mains\n", 6))
5651 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5653 if (errno == ENOENT)
5659 n = read(fd, contents, sizeof(contents));
5663 if (n != 2 || contents[1] != '\n')
5666 if (contents[0] == '1') {
5667 found_online = true;
5669 } else if (contents[0] == '0')
5670 found_offline = true;
5675 return found_online || !found_offline;
5678 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
5685 if (!path_strv_canonicalize_absolute_uniq(search, root))
5688 STRV_FOREACH(i, search) {
5689 _cleanup_free_ char *p = NULL;
5692 p = strjoin(*i, "/", path, NULL);
5702 if (errno != ENOENT)
5709 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
5710 _cleanup_strv_free_ char **copy = NULL;
5716 if (path_is_absolute(path)) {
5719 f = fopen(path, mode);
5728 copy = strv_copy((char**) search);
5732 return search_and_fopen_internal(path, mode, root, copy, _f);
5735 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
5736 _cleanup_strv_free_ char **s = NULL;
5738 if (path_is_absolute(path)) {
5741 f = fopen(path, mode);
5750 s = strv_split_nulstr(search);
5754 return search_and_fopen_internal(path, mode, root, s, _f);
5757 char *strextend(char **x, ...) {
5764 l = f = *x ? strlen(*x) : 0;
5771 t = va_arg(ap, const char *);
5776 if (n > ((size_t) -1) - l) {
5785 r = realloc(*x, l+1);
5795 t = va_arg(ap, const char *);
5809 char *strrep(const char *s, unsigned n) {
5817 p = r = malloc(l * n + 1);
5821 for (i = 0; i < n; i++)
5828 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
5835 if (*allocated >= need)
5838 newalloc = MAX(need * 2, 64u / size);
5839 a = newalloc * size;
5841 /* check for overflows */
5842 if (a < size * need)
5850 *allocated = newalloc;
5854 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
5863 q = greedy_realloc(p, allocated, need, size);
5867 if (*allocated > prev)
5868 memzero(q + prev * size, (*allocated - prev) * size);
5873 bool id128_is_valid(const char *s) {
5879 /* Simple formatted 128bit hex string */
5881 for (i = 0; i < l; i++) {
5884 if (!(c >= '0' && c <= '9') &&
5885 !(c >= 'a' && c <= 'z') &&
5886 !(c >= 'A' && c <= 'Z'))
5890 } else if (l == 36) {
5892 /* Formatted UUID */
5894 for (i = 0; i < l; i++) {
5897 if ((i == 8 || i == 13 || i == 18 || i == 23)) {
5901 if (!(c >= '0' && c <= '9') &&
5902 !(c >= 'a' && c <= 'z') &&
5903 !(c >= 'A' && c <= 'Z'))
5914 int split_pair(const char *s, const char *sep, char **l, char **r) {
5929 a = strndup(s, x - s);
5933 b = strdup(x + strlen(sep));
5945 int shall_restore_state(void) {
5946 _cleanup_free_ char *line = NULL;
5951 r = proc_cmdline(&line);
5954 if (r == 0) /* Container ... */
5959 FOREACH_WORD_QUOTED(w, l, line, state) {
5967 e = startswith(n, "systemd.restore_state=");
5971 k = parse_boolean(e);
5979 int proc_cmdline(char **ret) {
5982 if (detect_container(NULL) > 0) {
5983 char *buf = NULL, *p;
5986 r = read_full_file("/proc/1/cmdline", &buf, &sz);
5990 for (p = buf; p + 1 < buf + sz; p++)
5999 r = read_one_line_file("/proc/cmdline", ret);
6006 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6007 _cleanup_free_ char *line = NULL;
6014 r = proc_cmdline(&line);
6016 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
6020 FOREACH_WORD_QUOTED(w, l, line, state) {
6021 char word[l+1], *value;
6026 /* Filter out arguments that are intended only for the
6028 if (!in_initrd() && startswith(word, "rd."))
6031 value = strchr(word, '=');
6035 r = parse_item(word, value);
6043 int container_get_leader(const char *machine, pid_t *pid) {
6044 _cleanup_free_ char *s = NULL, *class = NULL;
6052 p = strappenda("/run/systemd/machines/", machine);
6053 r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6061 if (!streq_ptr(class, "container"))
6064 r = parse_pid(s, &leader);
6074 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *root_fd) {
6075 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1;
6076 const char *pidns, *mntns, *root;
6084 mntns = procfs_file_alloca(pid, "ns/mnt");
6085 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6089 pidns = procfs_file_alloca(pid, "ns/pid");
6090 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6094 root = procfs_file_alloca(pid, "root");
6095 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6099 *pidns_fd = pidnsfd;
6100 *mntns_fd = mntnsfd;
6108 int namespace_enter(int pidns_fd, int mntns_fd, int root_fd) {
6109 assert(pidns_fd >= 0);
6110 assert(mntns_fd >= 0);
6111 assert(root_fd >= 0);
6113 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6116 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6119 if (fchdir(root_fd) < 0)
6122 if (chroot(".") < 0)
6125 if (setresgid(0, 0, 0) < 0)
6128 if (setresuid(0, 0, 0) < 0)
6134 bool pid_is_unwaited(pid_t pid) {
6135 /* Checks whether a PID is still valid at all, including a zombie */
6140 if (kill(pid, 0) >= 0)
6143 return errno != ESRCH;
6146 bool pid_is_alive(pid_t pid) {
6149 /* Checks whether a PID is still valid and not a zombie */
6154 r = get_process_state(pid);
6155 if (r == -ENOENT || r == 'Z')
6161 int getpeercred(int fd, struct ucred *ucred) {
6162 socklen_t n = sizeof(struct ucred);
6169 r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6173 if (n != sizeof(struct ucred))
6176 /* Check if the data is actually useful and not suppressed due
6177 * to namespacing issues */
6185 int getpeersec(int fd, char **ret) {
6197 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6201 if (errno != ERANGE)
6208 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6224 /* This is much like like mkostemp() but is subject to umask(). */
6225 int mkostemp_safe(char *pattern, int flags) {
6226 _cleanup_umask_ mode_t u;
6233 fd = mkostemp(pattern, flags);
6240 int open_tmpfile(const char *path, int flags) {
6247 /* Try O_TMPFILE first, if it is supported */
6248 fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6253 /* Fall back to unguessable name + unlinking */
6254 p = strappenda(path, "/systemd-tmp-XXXXXX");
6256 fd = mkostemp_safe(p, flags);
6264 int fd_warn_permissions(const char *path, int fd) {
6267 if (fstat(fd, &st) < 0)
6270 if (st.st_mode & 0111)
6271 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6273 if (st.st_mode & 0002)
6274 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6276 if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6277 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);
6282 unsigned long personality_from_string(const char *p) {
6284 /* Parse a personality specifier. We introduce our own
6285 * identifiers that indicate specific ABIs, rather than just
6286 * hints regarding the register size, since we want to keep
6287 * things open for multiple locally supported ABIs for the
6288 * same register size. We try to reuse the ABI identifiers
6289 * used by libseccomp. */
6291 #if defined(__x86_64__)
6293 if (streq(p, "x86"))
6296 if (streq(p, "x86-64"))
6299 #elif defined(__i386__)
6301 if (streq(p, "x86"))
6305 /* personality(7) documents that 0xffffffffUL is used for
6306 * querying the current personality, hence let's use that here
6307 * as error indicator. */
6308 return 0xffffffffUL;
6311 const char* personality_to_string(unsigned long p) {
6313 #if defined(__x86_64__)
6315 if (p == PER_LINUX32)
6321 #elif defined(__i386__)
6330 uint64_t physical_memory(void) {
6333 /* We return this as uint64_t in case we are running as 32bit
6334 * process on a 64bit kernel with huge amounts of memory */
6336 mem = sysconf(_SC_PHYS_PAGES);
6339 return (uint64_t) mem * (uint64_t) page_size();
6342 char* mount_test_option(const char *haystack, const char *needle) {
6344 struct mntent me = {
6345 .mnt_opts = (char*) haystack
6350 /* Like glibc's hasmntopt(), but works on a string, not a
6356 return hasmntopt(&me, needle);
6359 void hexdump(FILE *f, const void *p, size_t s) {
6360 const uint8_t *b = p;
6363 assert(s == 0 || b);
6368 fprintf(f, "%04x ", n);
6370 for (i = 0; i < 16; i++) {
6375 fprintf(f, "%02x ", b[i]);
6383 for (i = 0; i < 16; i++) {
6388 fputc(isprint(b[i]) ? (char) b[i] : '.', f);