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>
44 #include <sys/prctl.h>
45 #include <sys/utsname.h>
47 #include <netinet/ip.h>
56 #include <sys/mount.h>
57 #include <linux/magic.h>
61 #include <sys/personality.h>
62 #include <sys/xattr.h>
66 #ifdef HAVE_SYS_AUXV_H
78 #include "path-util.h"
79 #include "exit-status.h"
83 #include "device-nodes.h"
88 #include "sparse-endian.h"
91 char **saved_argv = NULL;
93 static volatile unsigned cached_columns = 0;
94 static volatile unsigned cached_lines = 0;
96 size_t page_size(void) {
97 static thread_local size_t pgsz = 0;
100 if (_likely_(pgsz > 0))
103 r = sysconf(_SC_PAGESIZE);
110 bool streq_ptr(const char *a, const char *b) {
112 /* Like streq(), but tries to make sense of NULL pointers */
123 char* endswith(const char *s, const char *postfix) {
130 pl = strlen(postfix);
133 return (char*) s + sl;
138 if (memcmp(s + sl - pl, postfix, pl) != 0)
141 return (char*) s + sl - pl;
144 char* first_word(const char *s, const char *word) {
151 /* Checks if the string starts with the specified word, either
152 * followed by NUL or by whitespace. Returns a pointer to the
153 * NUL or the first character after the whitespace. */
164 if (memcmp(s, word, wl) != 0)
171 if (!strchr(WHITESPACE, *p))
174 p += strspn(p, WHITESPACE);
178 static size_t cescape_char(char c, char *buf) {
179 char * buf_old = buf;
225 /* For special chars we prefer octal over
226 * hexadecimal encoding, simply because glib's
227 * g_strescape() does the same */
228 if ((c < ' ') || (c >= 127)) {
230 *(buf++) = octchar((unsigned char) c >> 6);
231 *(buf++) = octchar((unsigned char) c >> 3);
232 *(buf++) = octchar((unsigned char) c);
238 return buf - buf_old;
241 int close_nointr(int fd) {
248 * Just ignore EINTR; a retry loop is the wrong thing to do on
251 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
252 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
253 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
254 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
262 int safe_close(int fd) {
265 * Like close_nointr() but cannot fail. Guarantees errno is
266 * unchanged. Is a NOP with negative fds passed, and returns
267 * -1, so that it can be used in this syntax:
269 * fd = safe_close(fd);
275 /* The kernel might return pretty much any error code
276 * via close(), but the fd will be closed anyway. The
277 * only condition we want to check for here is whether
278 * the fd was invalid at all... */
280 assert_se(close_nointr(fd) != -EBADF);
286 void close_many(const int fds[], unsigned n_fd) {
289 assert(fds || n_fd <= 0);
291 for (i = 0; i < n_fd; i++)
295 int unlink_noerrno(const char *path) {
306 int parse_boolean(const char *v) {
309 if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
311 else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
317 int parse_pid(const char *s, pid_t* ret_pid) {
318 unsigned long ul = 0;
325 r = safe_atolu(s, &ul);
331 if ((unsigned long) pid != ul)
341 int parse_uid(const char *s, uid_t* ret_uid) {
342 unsigned long ul = 0;
349 r = safe_atolu(s, &ul);
355 if ((unsigned long) uid != ul)
358 /* Some libc APIs use UID_INVALID as special placeholder */
359 if (uid == (uid_t) 0xFFFFFFFF)
362 /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
363 if (uid == (uid_t) 0xFFFF)
370 int safe_atou(const char *s, unsigned *ret_u) {
378 l = strtoul(s, &x, 0);
380 if (!x || x == s || *x || errno)
381 return errno > 0 ? -errno : -EINVAL;
383 if ((unsigned long) (unsigned) l != l)
386 *ret_u = (unsigned) l;
390 int safe_atoi(const char *s, int *ret_i) {
398 l = strtol(s, &x, 0);
400 if (!x || x == s || *x || errno)
401 return errno > 0 ? -errno : -EINVAL;
403 if ((long) (int) l != l)
410 int safe_atou8(const char *s, uint8_t *ret) {
418 l = strtoul(s, &x, 0);
420 if (!x || x == s || *x || errno)
421 return errno > 0 ? -errno : -EINVAL;
423 if ((unsigned long) (uint8_t) l != l)
430 int safe_atou16(const char *s, uint16_t *ret) {
438 l = strtoul(s, &x, 0);
440 if (!x || x == s || *x || errno)
441 return errno > 0 ? -errno : -EINVAL;
443 if ((unsigned long) (uint16_t) l != l)
450 int safe_atoi16(const char *s, int16_t *ret) {
458 l = strtol(s, &x, 0);
460 if (!x || x == s || *x || errno)
461 return errno > 0 ? -errno : -EINVAL;
463 if ((long) (int16_t) l != l)
470 int safe_atollu(const char *s, long long unsigned *ret_llu) {
472 unsigned long long l;
478 l = strtoull(s, &x, 0);
480 if (!x || x == s || *x || errno)
481 return errno ? -errno : -EINVAL;
487 int safe_atolli(const char *s, long long int *ret_lli) {
495 l = strtoll(s, &x, 0);
497 if (!x || x == s || *x || errno)
498 return errno ? -errno : -EINVAL;
504 int safe_atod(const char *s, double *ret_d) {
511 RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
516 if (!x || x == s || *x || errno)
517 return errno ? -errno : -EINVAL;
523 static size_t strcspn_escaped(const char *s, const char *reject) {
524 bool escaped = false;
527 for (n=0; s[n]; n++) {
530 else if (s[n] == '\\')
532 else if (strchr(reject, s[n]))
536 /* if s ends in \, return index of previous char */
540 /* Split a string into words. */
541 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
547 assert(**state == '\0');
551 current += strspn(current, separator);
557 if (quoted && strchr("\'\"", *current)) {
558 char quotechars[2] = {*current, '\0'};
560 *l = strcspn_escaped(current + 1, quotechars);
561 if (current[*l + 1] == '\0' ||
562 (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
563 /* right quote missing or garbage at the end */
567 assert(current[*l + 1] == quotechars[0]);
568 *state = current++ + *l + 2;
570 *l = strcspn_escaped(current, separator);
571 if (current[*l] && !strchr(separator, current[*l])) {
572 /* unfinished escape */
576 *state = current + *l;
578 *l = strcspn(current, separator);
579 *state = current + *l;
585 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
587 _cleanup_free_ char *line = NULL;
599 p = procfs_file_alloca(pid, "stat");
600 r = read_one_line_file(p, &line);
604 /* Let's skip the pid and comm fields. The latter is enclosed
605 * in () but does not escape any () in its value, so let's
606 * skip over it manually */
608 p = strrchr(line, ')');
620 if ((long unsigned) (pid_t) ppid != ppid)
623 *_ppid = (pid_t) ppid;
628 int fchmod_umask(int fd, mode_t m) {
633 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
639 char *truncate_nl(char *s) {
642 s[strcspn(s, NEWLINE)] = 0;
646 int get_process_state(pid_t pid) {
650 _cleanup_free_ char *line = NULL;
654 p = procfs_file_alloca(pid, "stat");
655 r = read_one_line_file(p, &line);
659 p = strrchr(line, ')');
665 if (sscanf(p, " %c", &state) != 1)
668 return (unsigned char) state;
671 int get_process_comm(pid_t pid, char **name) {
678 p = procfs_file_alloca(pid, "comm");
680 r = read_one_line_file(p, name);
687 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
688 _cleanup_fclose_ FILE *f = NULL;
696 p = procfs_file_alloca(pid, "cmdline");
702 if (max_length == 0) {
703 size_t len = 0, allocated = 0;
705 while ((c = getc(f)) != EOF) {
707 if (!GREEDY_REALLOC(r, allocated, len+2)) {
712 r[len++] = isprint(c) ? c : ' ';
722 r = new(char, max_length);
728 while ((c = getc(f)) != EOF) {
750 size_t n = MIN(left-1, 3U);
757 /* Kernel threads have no argv[] */
759 _cleanup_free_ char *t = NULL;
767 h = get_process_comm(pid, &t);
771 r = strjoin("[", t, "]", NULL);
780 int is_kernel_thread(pid_t pid) {
792 p = procfs_file_alloca(pid, "cmdline");
797 count = fread(&c, 1, 1, f);
801 /* Kernel threads have an empty cmdline */
804 return eof ? 1 : -errno;
809 int get_process_capeff(pid_t pid, char **capeff) {
815 p = procfs_file_alloca(pid, "status");
817 return get_status_field(p, "\nCapEff:", capeff);
820 static int get_process_link_contents(const char *proc_file, char **name) {
826 r = readlink_malloc(proc_file, name);
828 return r == -ENOENT ? -ESRCH : r;
833 int get_process_exe(pid_t pid, char **name) {
840 p = procfs_file_alloca(pid, "exe");
841 r = get_process_link_contents(p, name);
845 d = endswith(*name, " (deleted)");
852 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
853 _cleanup_fclose_ FILE *f = NULL;
863 p = procfs_file_alloca(pid, "status");
868 FOREACH_LINE(line, f, return -errno) {
873 if (startswith(l, field)) {
875 l += strspn(l, WHITESPACE);
877 l[strcspn(l, WHITESPACE)] = 0;
879 return parse_uid(l, uid);
886 int get_process_uid(pid_t pid, uid_t *uid) {
887 return get_process_id(pid, "Uid:", uid);
890 int get_process_gid(pid_t pid, gid_t *gid) {
891 assert_cc(sizeof(uid_t) == sizeof(gid_t));
892 return get_process_id(pid, "Gid:", gid);
895 int get_process_cwd(pid_t pid, char **cwd) {
900 p = procfs_file_alloca(pid, "cwd");
902 return get_process_link_contents(p, cwd);
905 int get_process_root(pid_t pid, char **root) {
910 p = procfs_file_alloca(pid, "root");
912 return get_process_link_contents(p, root);
915 int get_process_environ(pid_t pid, char **env) {
916 _cleanup_fclose_ FILE *f = NULL;
917 _cleanup_free_ char *outcome = NULL;
920 size_t allocated = 0, sz = 0;
925 p = procfs_file_alloca(pid, "environ");
931 while ((c = fgetc(f)) != EOF) {
932 if (!GREEDY_REALLOC(outcome, allocated, sz + 5))
936 outcome[sz++] = '\n';
938 sz += cescape_char(c, outcome + sz);
948 char *strnappend(const char *s, const char *suffix, size_t b) {
956 return strndup(suffix, b);
965 if (b > ((size_t) -1) - a)
968 r = new(char, a+b+1);
973 memcpy(r+a, suffix, b);
979 char *strappend(const char *s, const char *suffix) {
980 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
983 int readlinkat_malloc(int fd, const char *p, char **ret) {
998 n = readlinkat(fd, p, c, l-1);
1005 if ((size_t) n < l-1) {
1016 int readlink_malloc(const char *p, char **ret) {
1017 return readlinkat_malloc(AT_FDCWD, p, ret);
1020 int readlink_value(const char *p, char **ret) {
1021 _cleanup_free_ char *link = NULL;
1025 r = readlink_malloc(p, &link);
1029 value = basename(link);
1033 value = strdup(value);
1042 int readlink_and_make_absolute(const char *p, char **r) {
1043 _cleanup_free_ char *target = NULL;
1050 j = readlink_malloc(p, &target);
1054 k = file_in_same_dir(p, target);
1062 int readlink_and_canonicalize(const char *p, char **r) {
1069 j = readlink_and_make_absolute(p, &t);
1073 s = canonicalize_file_name(t);
1080 path_kill_slashes(*r);
1085 int reset_all_signal_handlers(void) {
1088 for (sig = 1; sig < _NSIG; sig++) {
1089 struct sigaction sa = {
1090 .sa_handler = SIG_DFL,
1091 .sa_flags = SA_RESTART,
1094 /* These two cannot be caught... */
1095 if (sig == SIGKILL || sig == SIGSTOP)
1098 /* On Linux the first two RT signals are reserved by
1099 * glibc, and sigaction() will return EINVAL for them. */
1100 if ((sigaction(sig, &sa, NULL) < 0))
1101 if (errno != EINVAL && r == 0)
1108 int reset_signal_mask(void) {
1111 if (sigemptyset(&ss) < 0)
1114 if (sigprocmask(SIG_SETMASK, &ss, NULL) < 0)
1120 char *strstrip(char *s) {
1123 /* Drops trailing whitespace. Modifies the string in
1124 * place. Returns pointer to first non-space character */
1126 s += strspn(s, WHITESPACE);
1128 for (e = strchr(s, 0); e > s; e --)
1129 if (!strchr(WHITESPACE, e[-1]))
1137 char *delete_chars(char *s, const char *bad) {
1140 /* Drops all whitespace, regardless where in the string */
1142 for (f = s, t = s; *f; f++) {
1143 if (strchr(bad, *f))
1154 char *file_in_same_dir(const char *path, const char *filename) {
1161 /* This removes the last component of path and appends
1162 * filename, unless the latter is absolute anyway or the
1165 if (path_is_absolute(filename))
1166 return strdup(filename);
1168 e = strrchr(path, '/');
1170 return strdup(filename);
1172 k = strlen(filename);
1173 ret = new(char, (e + 1 - path) + k + 1);
1177 memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);
1181 int rmdir_parents(const char *path, const char *stop) {
1190 /* Skip trailing slashes */
1191 while (l > 0 && path[l-1] == '/')
1197 /* Skip last component */
1198 while (l > 0 && path[l-1] != '/')
1201 /* Skip trailing slashes */
1202 while (l > 0 && path[l-1] == '/')
1208 if (!(t = strndup(path, l)))
1211 if (path_startswith(stop, t)) {
1220 if (errno != ENOENT)
1227 char hexchar(int x) {
1228 static const char table[16] = "0123456789abcdef";
1230 return table[x & 15];
1233 int unhexchar(char c) {
1235 if (c >= '0' && c <= '9')
1238 if (c >= 'a' && c <= 'f')
1239 return c - 'a' + 10;
1241 if (c >= 'A' && c <= 'F')
1242 return c - 'A' + 10;
1247 char *hexmem(const void *p, size_t l) {
1251 z = r = malloc(l * 2 + 1);
1255 for (x = p; x < (const uint8_t*) p + l; x++) {
1256 *(z++) = hexchar(*x >> 4);
1257 *(z++) = hexchar(*x & 15);
1264 void *unhexmem(const char *p, size_t l) {
1270 z = r = malloc((l + 1) / 2 + 1);
1274 for (x = p; x < p + l; x += 2) {
1277 a = unhexchar(x[0]);
1279 b = unhexchar(x[1]);
1283 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1290 char octchar(int x) {
1291 return '0' + (x & 7);
1294 int unoctchar(char c) {
1296 if (c >= '0' && c <= '7')
1302 char decchar(int x) {
1303 return '0' + (x % 10);
1306 int undecchar(char c) {
1308 if (c >= '0' && c <= '9')
1314 char *cescape(const char *s) {
1320 /* Does C style string escaping. */
1322 r = new(char, strlen(s)*4 + 1);
1326 for (f = s, t = r; *f; f++)
1327 t += cescape_char(*f, t);
1334 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1341 /* Undoes C style string escaping, and optionally prefixes it. */
1343 pl = prefix ? strlen(prefix) : 0;
1345 r = new(char, pl+length+1);
1350 memcpy(r, prefix, pl);
1352 for (f = s, t = r + pl; f < s + length; f++) {
1395 /* This is an extension of the XDG syntax files */
1400 /* hexadecimal encoding */
1403 a = unhexchar(f[1]);
1404 b = unhexchar(f[2]);
1406 if (a < 0 || b < 0 || (a == 0 && b == 0)) {
1407 /* Invalid escape code, let's take it literal then */
1411 *(t++) = (char) ((a << 4) | b);
1426 /* octal encoding */
1429 a = unoctchar(f[0]);
1430 b = unoctchar(f[1]);
1431 c = unoctchar(f[2]);
1433 if (a < 0 || b < 0 || c < 0 || (a == 0 && b == 0 && c == 0)) {
1434 /* Invalid escape code, let's take it literal then */
1438 *(t++) = (char) ((a << 6) | (b << 3) | c);
1446 /* premature end of string. */
1451 /* Invalid escape code, let's take it literal then */
1463 char *cunescape_length(const char *s, size_t length) {
1464 return cunescape_length_with_prefix(s, length, NULL);
1467 char *cunescape(const char *s) {
1470 return cunescape_length(s, strlen(s));
1473 char *xescape(const char *s, const char *bad) {
1477 /* Escapes all chars in bad, in addition to \ and all special
1478 * chars, in \xFF style escaping. May be reversed with
1481 r = new(char, strlen(s) * 4 + 1);
1485 for (f = s, t = r; *f; f++) {
1487 if ((*f < ' ') || (*f >= 127) ||
1488 (*f == '\\') || strchr(bad, *f)) {
1491 *(t++) = hexchar(*f >> 4);
1492 *(t++) = hexchar(*f);
1502 char *ascii_strlower(char *t) {
1507 for (p = t; *p; p++)
1508 if (*p >= 'A' && *p <= 'Z')
1509 *p = *p - 'A' + 'a';
1514 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1518 filename[0] == '.' ||
1519 streq(filename, "lost+found") ||
1520 streq(filename, "aquota.user") ||
1521 streq(filename, "aquota.group") ||
1522 endswith(filename, ".rpmnew") ||
1523 endswith(filename, ".rpmsave") ||
1524 endswith(filename, ".rpmorig") ||
1525 endswith(filename, ".dpkg-old") ||
1526 endswith(filename, ".dpkg-new") ||
1527 endswith(filename, ".dpkg-tmp") ||
1528 endswith(filename, ".swp");
1531 bool hidden_file(const char *filename) {
1534 if (endswith(filename, "~"))
1537 return hidden_file_allow_backup(filename);
1540 int fd_nonblock(int fd, bool nonblock) {
1545 flags = fcntl(fd, F_GETFL, 0);
1550 nflags = flags | O_NONBLOCK;
1552 nflags = flags & ~O_NONBLOCK;
1554 if (nflags == flags)
1557 if (fcntl(fd, F_SETFL, nflags) < 0)
1563 int fd_cloexec(int fd, bool cloexec) {
1568 flags = fcntl(fd, F_GETFD, 0);
1573 nflags = flags | FD_CLOEXEC;
1575 nflags = flags & ~FD_CLOEXEC;
1577 if (nflags == flags)
1580 if (fcntl(fd, F_SETFD, nflags) < 0)
1586 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1589 assert(n_fdset == 0 || fdset);
1591 for (i = 0; i < n_fdset; i++)
1598 int close_all_fds(const int except[], unsigned n_except) {
1599 _cleanup_closedir_ DIR *d = NULL;
1603 assert(n_except == 0 || except);
1605 d = opendir("/proc/self/fd");
1610 /* When /proc isn't available (for example in chroots)
1611 * the fallback is brute forcing through the fd
1614 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1615 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1617 if (fd_in_set(fd, except, n_except))
1620 if (close_nointr(fd) < 0)
1621 if (errno != EBADF && r == 0)
1628 while ((de = readdir(d))) {
1631 if (hidden_file(de->d_name))
1634 if (safe_atoi(de->d_name, &fd) < 0)
1635 /* Let's better ignore this, just in case */
1644 if (fd_in_set(fd, except, n_except))
1647 if (close_nointr(fd) < 0) {
1648 /* Valgrind has its own FD and doesn't want to have it closed */
1649 if (errno != EBADF && r == 0)
1657 bool chars_intersect(const char *a, const char *b) {
1660 /* Returns true if any of the chars in a are in b. */
1661 for (p = a; *p; p++)
1668 bool fstype_is_network(const char *fstype) {
1669 static const char table[] =
1683 x = startswith(fstype, "fuse.");
1687 return nulstr_contains(table, fstype);
1691 _cleanup_close_ int fd;
1693 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1699 TIOCL_GETKMSGREDIRECT,
1703 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1706 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1709 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1715 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1716 struct termios old_termios, new_termios;
1717 char c, line[LINE_MAX];
1722 if (tcgetattr(fileno(f), &old_termios) >= 0) {
1723 new_termios = old_termios;
1725 new_termios.c_lflag &= ~ICANON;
1726 new_termios.c_cc[VMIN] = 1;
1727 new_termios.c_cc[VTIME] = 0;
1729 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1732 if (t != USEC_INFINITY) {
1733 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1734 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1739 k = fread(&c, 1, 1, f);
1741 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1747 *need_nl = c != '\n';
1754 if (t != USEC_INFINITY) {
1755 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1760 if (!fgets(line, sizeof(line), f))
1761 return errno ? -errno : -EIO;
1765 if (strlen(line) != 1)
1775 int ask_char(char *ret, const char *replies, const char *text, ...) {
1785 bool need_nl = true;
1788 fputs(ANSI_HIGHLIGHT_ON, stdout);
1795 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1799 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1802 if (r == -EBADMSG) {
1803 puts("Bad input, please try again.");
1814 if (strchr(replies, c)) {
1819 puts("Read unexpected character, please try again.");
1823 int ask_string(char **ret, const char *text, ...) {
1828 char line[LINE_MAX];
1832 fputs(ANSI_HIGHLIGHT_ON, stdout);
1839 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1844 if (!fgets(line, sizeof(line), stdin))
1845 return errno ? -errno : -EIO;
1847 if (!endswith(line, "\n"))
1866 int reset_terminal_fd(int fd, bool switch_to_text) {
1867 struct termios termios;
1870 /* Set terminal to some sane defaults */
1874 /* We leave locked terminal attributes untouched, so that
1875 * Plymouth may set whatever it wants to set, and we don't
1876 * interfere with that. */
1878 /* Disable exclusive mode, just in case */
1879 ioctl(fd, TIOCNXCL);
1881 /* Switch to text mode */
1883 ioctl(fd, KDSETMODE, KD_TEXT);
1885 /* Enable console unicode mode */
1886 ioctl(fd, KDSKBMODE, K_UNICODE);
1888 if (tcgetattr(fd, &termios) < 0) {
1893 /* We only reset the stuff that matters to the software. How
1894 * hardware is set up we don't touch assuming that somebody
1895 * else will do that for us */
1897 termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1898 termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1899 termios.c_oflag |= ONLCR;
1900 termios.c_cflag |= CREAD;
1901 termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1903 termios.c_cc[VINTR] = 03; /* ^C */
1904 termios.c_cc[VQUIT] = 034; /* ^\ */
1905 termios.c_cc[VERASE] = 0177;
1906 termios.c_cc[VKILL] = 025; /* ^X */
1907 termios.c_cc[VEOF] = 04; /* ^D */
1908 termios.c_cc[VSTART] = 021; /* ^Q */
1909 termios.c_cc[VSTOP] = 023; /* ^S */
1910 termios.c_cc[VSUSP] = 032; /* ^Z */
1911 termios.c_cc[VLNEXT] = 026; /* ^V */
1912 termios.c_cc[VWERASE] = 027; /* ^W */
1913 termios.c_cc[VREPRINT] = 022; /* ^R */
1914 termios.c_cc[VEOL] = 0;
1915 termios.c_cc[VEOL2] = 0;
1917 termios.c_cc[VTIME] = 0;
1918 termios.c_cc[VMIN] = 1;
1920 if (tcsetattr(fd, TCSANOW, &termios) < 0)
1924 /* Just in case, flush all crap out */
1925 tcflush(fd, TCIOFLUSH);
1930 int reset_terminal(const char *name) {
1931 _cleanup_close_ int fd = -1;
1933 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1937 return reset_terminal_fd(fd, true);
1940 int open_terminal(const char *name, int mode) {
1945 * If a TTY is in the process of being closed opening it might
1946 * cause EIO. This is horribly awful, but unlikely to be
1947 * changed in the kernel. Hence we work around this problem by
1948 * retrying a couple of times.
1950 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1953 assert(!(mode & O_CREAT));
1956 fd = open(name, mode, 0);
1963 /* Max 1s in total */
1967 usleep(50 * USEC_PER_MSEC);
1985 int flush_fd(int fd) {
1986 struct pollfd pollfd = {
1996 r = poll(&pollfd, 1, 0);
2006 l = read(fd, buf, sizeof(buf));
2012 if (errno == EAGAIN)
2021 int acquire_terminal(
2025 bool ignore_tiocstty_eperm,
2028 int fd = -1, notify = -1, r = 0, wd = -1;
2033 /* We use inotify to be notified when the tty is closed. We
2034 * create the watch before checking if we can actually acquire
2035 * it, so that we don't lose any event.
2037 * Note: strictly speaking this actually watches for the
2038 * device being closed, it does *not* really watch whether a
2039 * tty loses its controlling process. However, unless some
2040 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2041 * its tty otherwise this will not become a problem. As long
2042 * as the administrator makes sure not configure any service
2043 * on the same tty as an untrusted user this should not be a
2044 * problem. (Which he probably should not do anyway.) */
2046 if (timeout != USEC_INFINITY)
2047 ts = now(CLOCK_MONOTONIC);
2049 if (!fail && !force) {
2050 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
2056 wd = inotify_add_watch(notify, name, IN_CLOSE);
2064 struct sigaction sa_old, sa_new = {
2065 .sa_handler = SIG_IGN,
2066 .sa_flags = SA_RESTART,
2070 r = flush_fd(notify);
2075 /* We pass here O_NOCTTY only so that we can check the return
2076 * value TIOCSCTTY and have a reliable way to figure out if we
2077 * successfully became the controlling process of the tty */
2078 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2082 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2083 * if we already own the tty. */
2084 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2086 /* First, try to get the tty */
2087 if (ioctl(fd, TIOCSCTTY, force) < 0)
2090 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2092 /* Sometimes it makes sense to ignore TIOCSCTTY
2093 * returning EPERM, i.e. when very likely we already
2094 * are have this controlling terminal. */
2095 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
2098 if (r < 0 && (force || fail || r != -EPERM)) {
2107 assert(notify >= 0);
2110 union inotify_event_buffer buffer;
2111 struct inotify_event *e;
2114 if (timeout != USEC_INFINITY) {
2117 n = now(CLOCK_MONOTONIC);
2118 if (ts + timeout < n) {
2123 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2133 l = read(notify, &buffer, sizeof(buffer));
2135 if (errno == EINTR || errno == EAGAIN)
2142 FOREACH_INOTIFY_EVENT(e, buffer, l) {
2143 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2152 /* We close the tty fd here since if the old session
2153 * ended our handle will be dead. It's important that
2154 * we do this after sleeping, so that we don't enter
2155 * an endless loop. */
2156 fd = safe_close(fd);
2161 r = reset_terminal_fd(fd, true);
2163 log_warning_errno(r, "Failed to reset terminal: %m");
2174 int release_terminal(void) {
2175 static const struct sigaction sa_new = {
2176 .sa_handler = SIG_IGN,
2177 .sa_flags = SA_RESTART,
2180 _cleanup_close_ int fd = -1;
2181 struct sigaction sa_old;
2184 fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2188 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2189 * by our own TIOCNOTTY */
2190 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2192 if (ioctl(fd, TIOCNOTTY) < 0)
2195 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2200 int sigaction_many(const struct sigaction *sa, ...) {
2205 while ((sig = va_arg(ap, int)) > 0)
2206 if (sigaction(sig, sa, NULL) < 0)
2213 int ignore_signals(int sig, ...) {
2214 struct sigaction sa = {
2215 .sa_handler = SIG_IGN,
2216 .sa_flags = SA_RESTART,
2221 if (sigaction(sig, &sa, NULL) < 0)
2225 while ((sig = va_arg(ap, int)) > 0)
2226 if (sigaction(sig, &sa, NULL) < 0)
2233 int default_signals(int sig, ...) {
2234 struct sigaction sa = {
2235 .sa_handler = SIG_DFL,
2236 .sa_flags = SA_RESTART,
2241 if (sigaction(sig, &sa, NULL) < 0)
2245 while ((sig = va_arg(ap, int)) > 0)
2246 if (sigaction(sig, &sa, NULL) < 0)
2253 void safe_close_pair(int p[]) {
2257 /* Special case pairs which use the same fd in both
2259 p[0] = p[1] = safe_close(p[0]);
2263 p[0] = safe_close(p[0]);
2264 p[1] = safe_close(p[1]);
2267 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2274 while (nbytes > 0) {
2277 k = read(fd, p, nbytes);
2282 if (errno == EAGAIN && do_poll) {
2284 /* We knowingly ignore any return value here,
2285 * and expect that any error/EOF is reported
2288 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2292 return n > 0 ? n : -errno;
2306 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2307 const uint8_t *p = buf;
2314 while (nbytes > 0) {
2317 k = write(fd, p, nbytes);
2322 if (errno == EAGAIN && do_poll) {
2323 /* We knowingly ignore any return value here,
2324 * and expect that any error/EOF is reported
2327 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2334 if (k == 0) /* Can't really happen */
2344 int parse_size(const char *t, off_t base, off_t *size) {
2346 /* Soo, sometimes we want to parse IEC binary suffxies, and
2347 * sometimes SI decimal suffixes. This function can parse
2348 * both. Which one is the right way depends on the
2349 * context. Wikipedia suggests that SI is customary for
2350 * hardrware metrics and network speeds, while IEC is
2351 * customary for most data sizes used by software and volatile
2352 * (RAM) memory. Hence be careful which one you pick!
2354 * In either case we use just K, M, G as suffix, and not Ki,
2355 * Mi, Gi or so (as IEC would suggest). That's because that's
2356 * frickin' ugly. But this means you really need to make sure
2357 * to document which base you are parsing when you use this
2362 unsigned long long factor;
2365 static const struct table iec[] = {
2366 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2367 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2368 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2369 { "G", 1024ULL*1024ULL*1024ULL },
2370 { "M", 1024ULL*1024ULL },
2376 static const struct table si[] = {
2377 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2378 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2379 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2380 { "G", 1000ULL*1000ULL*1000ULL },
2381 { "M", 1000ULL*1000ULL },
2387 const struct table *table;
2389 unsigned long long r = 0;
2390 unsigned n_entries, start_pos = 0;
2393 assert(base == 1000 || base == 1024);
2398 n_entries = ELEMENTSOF(si);
2401 n_entries = ELEMENTSOF(iec);
2407 unsigned long long l2;
2413 l = strtoll(p, &e, 10);
2426 if (*e >= '0' && *e <= '9') {
2429 /* strotoull itself would accept space/+/- */
2430 l2 = strtoull(e, &e2, 10);
2432 if (errno == ERANGE)
2435 /* Ignore failure. E.g. 10.M is valid */
2442 e += strspn(e, WHITESPACE);
2444 for (i = start_pos; i < n_entries; i++)
2445 if (startswith(e, table[i].suffix)) {
2446 unsigned long long tmp;
2447 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2449 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2450 if (tmp > ULLONG_MAX - r)
2454 if ((unsigned long long) (off_t) r != r)
2457 p = e + strlen(table[i].suffix);
2473 int make_stdio(int fd) {
2478 r = dup2(fd, STDIN_FILENO);
2479 s = dup2(fd, STDOUT_FILENO);
2480 t = dup2(fd, STDERR_FILENO);
2485 if (r < 0 || s < 0 || t < 0)
2488 /* Explicitly unset O_CLOEXEC, since if fd was < 3, then
2489 * dup2() was a NOP and the bit hence possibly set. */
2490 fd_cloexec(STDIN_FILENO, false);
2491 fd_cloexec(STDOUT_FILENO, false);
2492 fd_cloexec(STDERR_FILENO, false);
2497 int make_null_stdio(void) {
2500 null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2504 return make_stdio(null_fd);
2507 bool is_device_path(const char *path) {
2509 /* Returns true on paths that refer to a device, either in
2510 * sysfs or in /dev */
2513 path_startswith(path, "/dev/") ||
2514 path_startswith(path, "/sys/");
2517 int dir_is_empty(const char *path) {
2518 _cleanup_closedir_ DIR *d;
2529 if (!de && errno != 0)
2535 if (!hidden_file(de->d_name))
2540 char* dirname_malloc(const char *path) {
2541 char *d, *dir, *dir2;
2558 int dev_urandom(void *p, size_t n) {
2559 static int have_syscall = -1;
2563 /* Gathers some randomness from the kernel. This call will
2564 * never block, and will always return some data from the
2565 * kernel, regardless if the random pool is fully initialized
2566 * or not. It thus makes no guarantee for the quality of the
2567 * returned entropy, but is good enough for or usual usecases
2568 * of seeding the hash functions for hashtable */
2570 /* Use the getrandom() syscall unless we know we don't have
2571 * it, or when the requested size is too large for it. */
2572 if (have_syscall != 0 || (size_t) (int) n != n) {
2573 r = getrandom(p, n, GRND_NONBLOCK);
2575 have_syscall = true;
2580 if (errno == ENOSYS)
2581 /* we lack the syscall, continue with
2582 * reading from /dev/urandom */
2583 have_syscall = false;
2584 else if (errno == EAGAIN)
2585 /* not enough entropy for now. Let's
2586 * remember to use the syscall the
2587 * next time, again, but also read
2588 * from /dev/urandom for now, which
2589 * doesn't care about the current
2590 * amount of entropy. */
2591 have_syscall = true;
2595 /* too short read? */
2599 fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2601 return errno == ENOENT ? -ENOSYS : -errno;
2603 k = loop_read(fd, p, n, true);
2608 if ((size_t) k != n)
2614 void initialize_srand(void) {
2615 static bool srand_called = false;
2617 #ifdef HAVE_SYS_AUXV_H
2626 #ifdef HAVE_SYS_AUXV_H
2627 /* The kernel provides us with a bit of entropy in auxv, so
2628 * let's try to make use of that to seed the pseudo-random
2629 * generator. It's better than nothing... */
2631 auxv = (void*) getauxval(AT_RANDOM);
2633 x ^= *(unsigned*) auxv;
2636 x ^= (unsigned) now(CLOCK_REALTIME);
2637 x ^= (unsigned) gettid();
2640 srand_called = true;
2643 void random_bytes(void *p, size_t n) {
2647 r = dev_urandom(p, n);
2651 /* If some idiot made /dev/urandom unavailable to us, he'll
2652 * get a PRNG instead. */
2656 for (q = p; q < (uint8_t*) p + n; q ++)
2660 void rename_process(const char name[8]) {
2663 /* This is a like a poor man's setproctitle(). It changes the
2664 * comm field, argv[0], and also the glibc's internally used
2665 * name of the process. For the first one a limit of 16 chars
2666 * applies, to the second one usually one of 10 (i.e. length
2667 * of "/sbin/init"), to the third one one of 7 (i.e. length of
2668 * "systemd"). If you pass a longer string it will be
2671 prctl(PR_SET_NAME, name);
2673 if (program_invocation_name)
2674 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2676 if (saved_argc > 0) {
2680 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2682 for (i = 1; i < saved_argc; i++) {
2686 memzero(saved_argv[i], strlen(saved_argv[i]));
2691 void sigset_add_many(sigset_t *ss, ...) {
2698 while ((sig = va_arg(ap, int)) > 0)
2699 assert_se(sigaddset(ss, sig) == 0);
2703 int sigprocmask_many(int how, ...) {
2708 assert_se(sigemptyset(&ss) == 0);
2711 while ((sig = va_arg(ap, int)) > 0)
2712 assert_se(sigaddset(&ss, sig) == 0);
2715 if (sigprocmask(how, &ss, NULL) < 0)
2721 char* gethostname_malloc(void) {
2724 assert_se(uname(&u) >= 0);
2726 if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2727 return strdup(u.nodename);
2729 return strdup(u.sysname);
2732 bool hostname_is_set(void) {
2735 assert_se(uname(&u) >= 0);
2737 return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2740 char *lookup_uid(uid_t uid) {
2743 _cleanup_free_ char *buf = NULL;
2744 struct passwd pwbuf, *pw = NULL;
2746 /* Shortcut things to avoid NSS lookups */
2748 return strdup("root");
2750 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2754 buf = malloc(bufsize);
2758 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2759 return strdup(pw->pw_name);
2761 if (asprintf(&name, UID_FMT, uid) < 0)
2767 char* getlogname_malloc(void) {
2771 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2776 return lookup_uid(uid);
2779 char *getusername_malloc(void) {
2786 return lookup_uid(getuid());
2789 int getttyname_malloc(int fd, char **ret) {
2799 r = ttyname_r(fd, path, sizeof(path));
2804 p = startswith(path, "/dev/");
2805 c = strdup(p ?: path);
2822 int getttyname_harder(int fd, char **r) {
2826 k = getttyname_malloc(fd, &s);
2830 if (streq(s, "tty")) {
2832 return get_ctty(0, NULL, r);
2839 int get_ctty_devnr(pid_t pid, dev_t *d) {
2841 _cleanup_free_ char *line = NULL;
2843 unsigned long ttynr;
2847 p = procfs_file_alloca(pid, "stat");
2848 r = read_one_line_file(p, &line);
2852 p = strrchr(line, ')');
2862 "%*d " /* session */
2867 if (major(ttynr) == 0 && minor(ttynr) == 0)
2876 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2877 char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2878 _cleanup_free_ char *s = NULL;
2885 k = get_ctty_devnr(pid, &devnr);
2889 sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
2891 k = readlink_malloc(fn, &s);
2897 /* This is an ugly hack */
2898 if (major(devnr) == 136) {
2899 asprintf(&b, "pts/%u", minor(devnr));
2903 /* Probably something like the ptys which have no
2904 * symlink in /dev/char. Let's return something
2905 * vaguely useful. */
2911 if (startswith(s, "/dev/"))
2913 else if (startswith(s, "../"))
2931 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2932 _cleanup_closedir_ DIR *d = NULL;
2937 /* This returns the first error we run into, but nevertheless
2938 * tries to go on. This closes the passed fd. */
2944 return errno == ENOENT ? 0 : -errno;
2949 bool is_dir, keep_around;
2956 if (errno != 0 && ret == 0)
2961 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2964 if (de->d_type == DT_UNKNOWN ||
2966 (de->d_type == DT_DIR && root_dev)) {
2967 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2968 if (ret == 0 && errno != ENOENT)
2973 is_dir = S_ISDIR(st.st_mode);
2976 (st.st_uid == 0 || st.st_uid == getuid()) &&
2977 (st.st_mode & S_ISVTX);
2979 is_dir = de->d_type == DT_DIR;
2980 keep_around = false;
2986 /* if root_dev is set, remove subdirectories only, if device is same as dir */
2987 if (root_dev && st.st_dev != root_dev->st_dev)
2990 subdir_fd = openat(fd, de->d_name,
2991 O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2992 if (subdir_fd < 0) {
2993 if (ret == 0 && errno != ENOENT)
2998 r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2999 if (r < 0 && ret == 0)
3003 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3004 if (ret == 0 && errno != ENOENT)
3008 } else if (!only_dirs && !keep_around) {
3010 if (unlinkat(fd, de->d_name, 0) < 0) {
3011 if (ret == 0 && errno != ENOENT)
3018 _pure_ static int is_temporary_fs(struct statfs *s) {
3021 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
3022 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
3025 int is_fd_on_temporary_fs(int fd) {
3028 if (fstatfs(fd, &s) < 0)
3031 return is_temporary_fs(&s);
3034 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3039 if (fstatfs(fd, &s) < 0) {
3044 /* We refuse to clean disk file systems with this call. This
3045 * is extra paranoia just to be sure we never ever remove
3047 if (!is_temporary_fs(&s)) {
3048 log_error("Attempted to remove disk file system, and we can't allow that.");
3053 return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
3056 static int file_is_priv_sticky(const char *p) {
3061 if (lstat(p, &st) < 0)
3065 (st.st_uid == 0 || st.st_uid == getuid()) &&
3066 (st.st_mode & S_ISVTX);
3069 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
3075 /* We refuse to clean the root file system with this
3076 * call. This is extra paranoia to never cause a really
3077 * seriously broken system. */
3078 if (path_equal(path, "/")) {
3079 log_error("Attempted to remove entire root file system, and we can't allow that.");
3083 fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3086 if (errno != ENOTDIR && errno != ELOOP)
3090 if (statfs(path, &s) < 0)
3093 if (!is_temporary_fs(&s)) {
3094 log_error("Attempted to remove disk file system, and we can't allow that.");
3099 if (delete_root && !only_dirs)
3100 if (unlink(path) < 0 && errno != ENOENT)
3107 if (fstatfs(fd, &s) < 0) {
3112 if (!is_temporary_fs(&s)) {
3113 log_error("Attempted to remove disk file system, and we can't allow that.");
3119 r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
3122 if (honour_sticky && file_is_priv_sticky(path) > 0)
3125 if (rmdir(path) < 0 && errno != ENOENT) {
3134 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3135 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
3138 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3139 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
3142 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3145 /* Under the assumption that we are running privileged we
3146 * first change the access mode and only then hand out
3147 * ownership to avoid a window where access is too open. */
3149 if (mode != MODE_INVALID)
3150 if (chmod(path, mode) < 0)
3153 if (uid != UID_INVALID || gid != GID_INVALID)
3154 if (chown(path, uid, gid) < 0)
3160 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3163 /* Under the assumption that we are running privileged we
3164 * first change the access mode and only then hand out
3165 * ownership to avoid a window where access is too open. */
3167 if (mode != MODE_INVALID)
3168 if (fchmod(fd, mode) < 0)
3171 if (uid != UID_INVALID || gid != GID_INVALID)
3172 if (fchown(fd, uid, gid) < 0)
3178 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3182 /* Allocates the cpuset in the right size */
3185 if (!(r = CPU_ALLOC(n)))
3188 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3189 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3199 if (errno != EINVAL)
3206 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3207 static const char status_indent[] = " "; /* "[" STATUS "] " */
3208 _cleanup_free_ char *s = NULL;
3209 _cleanup_close_ int fd = -1;
3210 struct iovec iovec[6] = {};
3212 static bool prev_ephemeral;
3216 /* This is independent of logging, as status messages are
3217 * optional and go exclusively to the console. */
3219 if (vasprintf(&s, format, ap) < 0)
3222 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3235 sl = status ? sizeof(status_indent)-1 : 0;
3241 e = ellipsize(s, emax, 50);
3249 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3250 prev_ephemeral = ephemeral;
3253 if (!isempty(status)) {
3254 IOVEC_SET_STRING(iovec[n++], "[");
3255 IOVEC_SET_STRING(iovec[n++], status);
3256 IOVEC_SET_STRING(iovec[n++], "] ");
3258 IOVEC_SET_STRING(iovec[n++], status_indent);
3261 IOVEC_SET_STRING(iovec[n++], s);
3263 IOVEC_SET_STRING(iovec[n++], "\n");
3265 if (writev(fd, iovec, n) < 0)
3271 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3277 va_start(ap, format);
3278 r = status_vprintf(status, ellipse, ephemeral, format, ap);
3284 char *replace_env(const char *format, char **env) {
3291 const char *e, *word = format;
3296 for (e = format; *e; e ++) {
3307 k = strnappend(r, word, e-word-1);
3317 } else if (*e == '$') {
3318 k = strnappend(r, word, e-word);
3335 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3337 k = strappend(r, t);
3351 k = strnappend(r, word, e-word);
3363 char **replace_env_argv(char **argv, char **env) {
3365 unsigned k = 0, l = 0;
3367 l = strv_length(argv);
3369 ret = new(char*, l+1);
3373 STRV_FOREACH(i, argv) {
3375 /* If $FOO appears as single word, replace it by the split up variable */
3376 if ((*i)[0] == '$' && (*i)[1] != '{') {
3381 e = strv_env_get(env, *i+1);
3385 r = strv_split_quoted(&m, e, true);
3397 w = realloc(ret, sizeof(char*) * (l+1));
3407 memcpy(ret + k, m, q * sizeof(char*));
3415 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3416 ret[k] = replace_env(*i, env);
3428 int fd_columns(int fd) {
3429 struct winsize ws = {};
3431 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3440 unsigned columns(void) {
3444 if (_likely_(cached_columns > 0))
3445 return cached_columns;
3448 e = getenv("COLUMNS");
3450 (void) safe_atoi(e, &c);
3453 c = fd_columns(STDOUT_FILENO);
3462 int fd_lines(int fd) {
3463 struct winsize ws = {};
3465 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3474 unsigned lines(void) {
3478 if (_likely_(cached_lines > 0))
3479 return cached_lines;
3482 e = getenv("LINES");
3484 (void) safe_atou(e, &l);
3487 l = fd_lines(STDOUT_FILENO);
3493 return cached_lines;
3496 /* intended to be used as a SIGWINCH sighandler */
3497 void columns_lines_cache_reset(int signum) {
3503 static int cached_on_tty = -1;
3505 if (_unlikely_(cached_on_tty < 0))
3506 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3508 return cached_on_tty;
3511 int files_same(const char *filea, const char *fileb) {
3514 if (stat(filea, &a) < 0)
3517 if (stat(fileb, &b) < 0)
3520 return a.st_dev == b.st_dev &&
3521 a.st_ino == b.st_ino;
3524 int running_in_chroot(void) {
3527 ret = files_same("/proc/1/root", "/");
3534 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3539 assert(percent <= 100);
3540 assert(new_length >= 3);
3542 if (old_length <= 3 || old_length <= new_length)
3543 return strndup(s, old_length);
3545 r = new0(char, new_length+1);
3549 x = (new_length * percent) / 100;
3551 if (x > new_length - 3)
3559 s + old_length - (new_length - x - 3),
3560 new_length - x - 3);
3565 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3569 unsigned k, len, len2;
3572 assert(percent <= 100);
3573 assert(new_length >= 3);
3575 /* if no multibyte characters use ascii_ellipsize_mem for speed */
3576 if (ascii_is_valid(s))
3577 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3579 if (old_length <= 3 || old_length <= new_length)
3580 return strndup(s, old_length);
3582 x = (new_length * percent) / 100;
3584 if (x > new_length - 3)
3588 for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3591 c = utf8_encoded_to_unichar(i);
3594 k += unichar_iswide(c) ? 2 : 1;
3597 if (k > x) /* last character was wide and went over quota */
3600 for (j = s + old_length; k < new_length && j > i; ) {
3603 j = utf8_prev_char(j);
3604 c = utf8_encoded_to_unichar(j);
3607 k += unichar_iswide(c) ? 2 : 1;
3611 /* we don't actually need to ellipsize */
3613 return memdup(s, old_length + 1);
3615 /* make space for ellipsis */
3616 j = utf8_next_char(j);
3619 len2 = s + old_length - j;
3620 e = new(char, len + 3 + len2 + 1);
3625 printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3626 old_length, new_length, x, len, len2, k);
3630 e[len] = 0xe2; /* tri-dot ellipsis: … */
3634 memcpy(e + len + 3, j, len2 + 1);
3639 char *ellipsize(const char *s, size_t length, unsigned percent) {
3640 return ellipsize_mem(s, strlen(s), length, percent);
3643 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3644 _cleanup_close_ int fd;
3650 mkdir_parents(path, 0755);
3652 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3657 r = fchmod(fd, mode);
3662 if (uid != UID_INVALID || gid != GID_INVALID) {
3663 r = fchown(fd, uid, gid);
3668 if (stamp != USEC_INFINITY) {
3669 struct timespec ts[2];
3671 timespec_store(&ts[0], stamp);
3673 r = futimens(fd, ts);
3675 r = futimens(fd, NULL);
3682 int touch(const char *path) {
3683 return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
3686 char *unquote(const char *s, const char* quotes) {
3690 /* This is rather stupid, simply removes the heading and
3691 * trailing quotes if there is one. Doesn't care about
3692 * escaping or anything. We should make this smarter one
3699 if (strchr(quotes, s[0]) && s[l-1] == s[0])
3700 return strndup(s+1, l-2);
3705 char *normalize_env_assignment(const char *s) {
3706 _cleanup_free_ char *value = NULL;
3710 eq = strchr(s, '=');
3720 memmove(r, t, strlen(t) + 1);
3725 name = strndupa(s, eq - s);
3726 p = strdupa(eq + 1);
3728 value = unquote(strstrip(p), QUOTES);
3732 return strjoin(strstrip(name), "=", value, NULL);
3735 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3746 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3760 * < 0 : wait_for_terminate() failed to get the state of the
3761 * process, the process was terminated by a signal, or
3762 * failed for an unknown reason.
3763 * >=0 : The process terminated normally, and its exit code is
3766 * That is, success is indicated by a return value of zero, and an
3767 * error is indicated by a non-zero value.
3769 * A warning is emitted if the process terminates abnormally,
3770 * and also if it returns non-zero unless check_exit_code is true.
3772 int wait_for_terminate_and_warn(const char *name, pid_t pid, bool check_exit_code) {
3779 r = wait_for_terminate(pid, &status);
3781 return log_warning_errno(r, "Failed to wait for %s: %m", name);
3783 if (status.si_code == CLD_EXITED) {
3784 if (status.si_status != 0)
3785 log_full(check_exit_code ? LOG_WARNING : LOG_DEBUG,
3786 "%s failed with error code %i.", name, status.si_status);
3788 log_debug("%s succeeded.", name);
3790 return status.si_status;
3791 } else if (status.si_code == CLD_KILLED ||
3792 status.si_code == CLD_DUMPED) {
3794 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3798 log_warning("%s failed due to unknown reason.", name);
3802 noreturn void freeze(void) {
3804 /* Make sure nobody waits for us on a socket anymore */
3805 close_all_fds(NULL, 0);
3813 bool null_or_empty(struct stat *st) {
3816 if (S_ISREG(st->st_mode) && st->st_size <= 0)
3819 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3825 int null_or_empty_path(const char *fn) {
3830 if (stat(fn, &st) < 0)
3833 return null_or_empty(&st);
3836 int null_or_empty_fd(int fd) {
3841 if (fstat(fd, &st) < 0)
3844 return null_or_empty(&st);
3847 DIR *xopendirat(int fd, const char *name, int flags) {
3851 assert(!(flags & O_CREAT));
3853 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3866 int signal_from_string_try_harder(const char *s) {
3870 signo = signal_from_string(s);
3872 if (startswith(s, "SIG"))
3873 return signal_from_string(s+3);
3878 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3879 _cleanup_free_ char *t = NULL, *u = NULL;
3882 u = unquote(tagvalue, "\"\'");
3886 enc_len = strlen(u) * 4 + 1;
3887 t = new(char, enc_len);
3891 if (encode_devnode_name(u, t, enc_len) < 0)
3894 return strjoin("/dev/disk/by-", by, "/", t, NULL);
3897 char *fstab_node_to_udev_node(const char *p) {
3900 if (startswith(p, "LABEL="))
3901 return tag_to_udev_node(p+6, "label");
3903 if (startswith(p, "UUID="))
3904 return tag_to_udev_node(p+5, "uuid");
3906 if (startswith(p, "PARTUUID="))
3907 return tag_to_udev_node(p+9, "partuuid");
3909 if (startswith(p, "PARTLABEL="))
3910 return tag_to_udev_node(p+10, "partlabel");
3915 bool tty_is_vc(const char *tty) {
3918 return vtnr_from_tty(tty) >= 0;
3921 bool tty_is_console(const char *tty) {
3924 if (startswith(tty, "/dev/"))
3927 return streq(tty, "console");
3930 int vtnr_from_tty(const char *tty) {
3935 if (startswith(tty, "/dev/"))
3938 if (!startswith(tty, "tty") )
3941 if (tty[3] < '0' || tty[3] > '9')
3944 r = safe_atoi(tty+3, &i);
3948 if (i < 0 || i > 63)
3954 char *resolve_dev_console(char **active) {
3957 /* Resolve where /dev/console is pointing to, if /sys is actually ours
3958 * (i.e. not read-only-mounted which is a sign for container setups) */
3960 if (path_is_read_only_fs("/sys") > 0)
3963 if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3966 /* If multiple log outputs are configured the last one is what
3967 * /dev/console points to */
3968 tty = strrchr(*active, ' ');
3974 if (streq(tty, "tty0")) {
3977 /* Get the active VC (e.g. tty1) */
3978 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3980 tty = *active = tmp;
3987 bool tty_is_vc_resolve(const char *tty) {
3988 _cleanup_free_ char *active = NULL;
3992 if (startswith(tty, "/dev/"))
3995 if (streq(tty, "console")) {
3996 tty = resolve_dev_console(&active);
4001 return tty_is_vc(tty);
4004 const char *default_term_for_tty(const char *tty) {
4007 return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
4010 bool dirent_is_file(const struct dirent *de) {
4013 if (hidden_file(de->d_name))
4016 if (de->d_type != DT_REG &&
4017 de->d_type != DT_LNK &&
4018 de->d_type != DT_UNKNOWN)
4024 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4027 if (de->d_type != DT_REG &&
4028 de->d_type != DT_LNK &&
4029 de->d_type != DT_UNKNOWN)
4032 if (hidden_file_allow_backup(de->d_name))
4035 return endswith(de->d_name, suffix);
4038 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
4044 /* Executes all binaries in a directory in parallel and waits
4045 * for them to finish. Optionally a timeout is applied. */
4047 executor_pid = fork();
4048 if (executor_pid < 0) {
4049 log_error_errno(errno, "Failed to fork: %m");
4052 } else if (executor_pid == 0) {
4053 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
4054 _cleanup_closedir_ DIR *_d = NULL;
4057 /* We fork this all off from a child process so that
4058 * we can somewhat cleanly make use of SIGALRM to set
4061 reset_all_signal_handlers();
4062 reset_signal_mask();
4064 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4067 d = _d = opendir(directory);
4069 if (errno == ENOENT)
4070 _exit(EXIT_SUCCESS);
4072 log_error_errno(errno, "Failed to enumerate directory %s: %m", directory);
4073 _exit(EXIT_FAILURE);
4077 pids = hashmap_new(NULL);
4080 _exit(EXIT_FAILURE);
4083 FOREACH_DIRENT(de, d, break) {
4084 _cleanup_free_ char *path = NULL;
4087 if (!dirent_is_file(de))
4090 path = strjoin(directory, "/", de->d_name, NULL);
4093 _exit(EXIT_FAILURE);
4098 log_error_errno(errno, "Failed to fork: %m");
4100 } else if (pid == 0) {
4103 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4113 log_error_errno(errno, "Failed to execute %s: %m", path);
4114 _exit(EXIT_FAILURE);
4117 log_debug("Spawned %s as " PID_FMT ".", path, pid);
4119 r = hashmap_put(pids, UINT_TO_PTR(pid), path);
4122 _exit(EXIT_FAILURE);
4128 /* Abort execution of this process after the
4129 * timout. We simply rely on SIGALRM as default action
4130 * terminating the process, and turn on alarm(). */
4132 if (timeout != USEC_INFINITY)
4133 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
4135 while (!hashmap_isempty(pids)) {
4136 _cleanup_free_ char *path = NULL;
4139 pid = PTR_TO_UINT(hashmap_first_key(pids));
4142 path = hashmap_remove(pids, UINT_TO_PTR(pid));
4145 wait_for_terminate_and_warn(path, pid, true);
4148 _exit(EXIT_SUCCESS);
4151 wait_for_terminate_and_warn(directory, executor_pid, true);
4154 int kill_and_sigcont(pid_t pid, int sig) {
4157 r = kill(pid, sig) < 0 ? -errno : 0;
4165 bool nulstr_contains(const char*nulstr, const char *needle) {
4171 NULSTR_FOREACH(i, nulstr)
4172 if (streq(i, needle))
4178 bool plymouth_running(void) {
4179 return access("/run/plymouth/pid", F_OK) >= 0;
4182 char* strshorten(char *s, size_t l) {
4191 static bool hostname_valid_char(char c) {
4193 (c >= 'a' && c <= 'z') ||
4194 (c >= 'A' && c <= 'Z') ||
4195 (c >= '0' && c <= '9') ||
4201 bool hostname_is_valid(const char *s) {
4208 for (p = s, dot = true; *p; p++) {
4215 if (!hostname_valid_char(*p))
4225 if (p-s > HOST_NAME_MAX)
4231 char* hostname_cleanup(char *s, bool lowercase) {
4235 for (p = s, d = s, dot = true; *p; p++) {
4242 } else if (hostname_valid_char(*p)) {
4243 *(d++) = lowercase ? tolower(*p) : *p;
4254 strshorten(s, HOST_NAME_MAX);
4259 bool machine_name_is_valid(const char *s) {
4261 if (!hostname_is_valid(s))
4264 /* Machine names should be useful hostnames, but also be
4265 * useful in unit names, hence we enforce a stricter length
4274 bool image_name_is_valid(const char *s) {
4275 if (!filename_is_valid(s))
4278 if (string_has_cc(s, NULL))
4281 if (!utf8_is_valid(s))
4284 /* Temporary files for atomically creating new files */
4285 if (startswith(s, ".#"))
4291 int pipe_eof(int fd) {
4292 struct pollfd pollfd = {
4294 .events = POLLIN|POLLHUP,
4299 r = poll(&pollfd, 1, 0);
4306 return pollfd.revents & POLLHUP;
4309 int fd_wait_for_event(int fd, int event, usec_t t) {
4311 struct pollfd pollfd = {
4319 r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
4326 return pollfd.revents;
4329 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4338 r = tempfn_xxxxxx(path, &t);
4342 fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
4348 f = fdopen(fd, "we");
4361 int terminal_vhangup_fd(int fd) {
4364 if (ioctl(fd, TIOCVHANGUP) < 0)
4370 int terminal_vhangup(const char *name) {
4371 _cleanup_close_ int fd;
4373 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4377 return terminal_vhangup_fd(fd);
4380 int vt_disallocate(const char *name) {
4384 /* Deallocate the VT if possible. If not possible
4385 * (i.e. because it is the active one), at least clear it
4386 * entirely (including the scrollback buffer) */
4388 if (!startswith(name, "/dev/"))
4391 if (!tty_is_vc(name)) {
4392 /* So this is not a VT. I guess we cannot deallocate
4393 * it then. But let's at least clear the screen */
4395 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4400 "\033[r" /* clear scrolling region */
4401 "\033[H" /* move home */
4402 "\033[2J", /* clear screen */
4409 if (!startswith(name, "/dev/tty"))
4412 r = safe_atou(name+8, &u);
4419 /* Try to deallocate */
4420 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4424 r = ioctl(fd, VT_DISALLOCATE, u);
4433 /* Couldn't deallocate, so let's clear it fully with
4435 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4440 "\033[r" /* clear scrolling region */
4441 "\033[H" /* move home */
4442 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4449 int symlink_atomic(const char *from, const char *to) {
4450 _cleanup_free_ char *t = NULL;
4456 r = tempfn_random(to, &t);
4460 if (symlink(from, t) < 0)
4463 if (rename(t, to) < 0) {
4471 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
4472 _cleanup_free_ char *t = NULL;
4477 r = tempfn_random(path, &t);
4481 if (mknod(t, mode, dev) < 0)
4484 if (rename(t, path) < 0) {
4492 int mkfifo_atomic(const char *path, mode_t mode) {
4493 _cleanup_free_ char *t = NULL;
4498 r = tempfn_random(path, &t);
4502 if (mkfifo(t, mode) < 0)
4505 if (rename(t, path) < 0) {
4513 bool display_is_local(const char *display) {
4517 display[0] == ':' &&
4518 display[1] >= '0' &&
4522 int socket_from_display(const char *display, char **path) {
4529 if (!display_is_local(display))
4532 k = strspn(display+1, "0123456789");
4534 f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4538 c = stpcpy(f, "/tmp/.X11-unix/X");
4539 memcpy(c, display+1, k);
4548 const char **username,
4549 uid_t *uid, gid_t *gid,
4551 const char **shell) {
4559 /* We enforce some special rules for uid=0: in order to avoid
4560 * NSS lookups for root we hardcode its data. */
4562 if (streq(*username, "root") || streq(*username, "0")) {
4580 if (parse_uid(*username, &u) >= 0) {
4584 /* If there are multiple users with the same id, make
4585 * sure to leave $USER to the configured value instead
4586 * of the first occurrence in the database. However if
4587 * the uid was configured by a numeric uid, then let's
4588 * pick the real username from /etc/passwd. */
4590 *username = p->pw_name;
4593 p = getpwnam(*username);
4597 return errno > 0 ? -errno : -ESRCH;
4609 *shell = p->pw_shell;
4614 char* uid_to_name(uid_t uid) {
4619 return strdup("root");
4623 return strdup(p->pw_name);
4625 if (asprintf(&r, UID_FMT, uid) < 0)
4631 char* gid_to_name(gid_t gid) {
4636 return strdup("root");
4640 return strdup(p->gr_name);
4642 if (asprintf(&r, GID_FMT, gid) < 0)
4648 int get_group_creds(const char **groupname, gid_t *gid) {
4654 /* We enforce some special rules for gid=0: in order to avoid
4655 * NSS lookups for root we hardcode its data. */
4657 if (streq(*groupname, "root") || streq(*groupname, "0")) {
4658 *groupname = "root";
4666 if (parse_gid(*groupname, &id) >= 0) {
4671 *groupname = g->gr_name;
4674 g = getgrnam(*groupname);
4678 return errno > 0 ? -errno : -ESRCH;
4686 int in_gid(gid_t gid) {
4688 int ngroups_max, r, i;
4690 if (getgid() == gid)
4693 if (getegid() == gid)
4696 ngroups_max = sysconf(_SC_NGROUPS_MAX);
4697 assert(ngroups_max > 0);
4699 gids = alloca(sizeof(gid_t) * ngroups_max);
4701 r = getgroups(ngroups_max, gids);
4705 for (i = 0; i < r; i++)
4712 int in_group(const char *name) {
4716 r = get_group_creds(&name, &gid);
4723 int glob_exists(const char *path) {
4724 _cleanup_globfree_ glob_t g = {};
4730 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4732 if (k == GLOB_NOMATCH)
4734 else if (k == GLOB_NOSPACE)
4737 return !strv_isempty(g.gl_pathv);
4739 return errno ? -errno : -EIO;
4742 int glob_extend(char ***strv, const char *path) {
4743 _cleanup_globfree_ glob_t g = {};
4748 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4750 if (k == GLOB_NOMATCH)
4752 else if (k == GLOB_NOSPACE)
4754 else if (k != 0 || strv_isempty(g.gl_pathv))
4755 return errno ? -errno : -EIO;
4757 STRV_FOREACH(p, g.gl_pathv) {
4758 k = strv_extend(strv, *p);
4766 int dirent_ensure_type(DIR *d, struct dirent *de) {
4772 if (de->d_type != DT_UNKNOWN)
4775 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4779 S_ISREG(st.st_mode) ? DT_REG :
4780 S_ISDIR(st.st_mode) ? DT_DIR :
4781 S_ISLNK(st.st_mode) ? DT_LNK :
4782 S_ISFIFO(st.st_mode) ? DT_FIFO :
4783 S_ISSOCK(st.st_mode) ? DT_SOCK :
4784 S_ISCHR(st.st_mode) ? DT_CHR :
4785 S_ISBLK(st.st_mode) ? DT_BLK :
4791 int get_files_in_directory(const char *path, char ***list) {
4792 _cleanup_closedir_ DIR *d = NULL;
4793 size_t bufsize = 0, n = 0;
4794 _cleanup_strv_free_ char **l = NULL;
4798 /* Returns all files in a directory in *list, and the number
4799 * of files as return value. If list is NULL returns only the
4811 if (!de && errno != 0)
4816 dirent_ensure_type(d, de);
4818 if (!dirent_is_file(de))
4822 /* one extra slot is needed for the terminating NULL */
4823 if (!GREEDY_REALLOC(l, bufsize, n + 2))
4826 l[n] = strdup(de->d_name);
4837 l = NULL; /* avoid freeing */
4843 char *strjoin(const char *x, ...) {
4857 t = va_arg(ap, const char *);
4862 if (n > ((size_t) -1) - l) {
4886 t = va_arg(ap, const char *);
4900 bool is_main_thread(void) {
4901 static thread_local int cached = 0;
4903 if (_unlikely_(cached == 0))
4904 cached = getpid() == gettid() ? 1 : -1;
4909 int block_get_whole_disk(dev_t d, dev_t *ret) {
4916 /* If it has a queue this is good enough for us */
4917 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4920 r = access(p, F_OK);
4928 /* If it is a partition find the originating device */
4929 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4932 r = access(p, F_OK);
4938 /* Get parent dev_t */
4939 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4942 r = read_one_line_file(p, &s);
4948 r = sscanf(s, "%u:%u", &m, &n);
4954 /* Only return this if it is really good enough for us. */
4955 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4958 r = access(p, F_OK);
4962 *ret = makedev(m, n);
4969 static const char *const ioprio_class_table[] = {
4970 [IOPRIO_CLASS_NONE] = "none",
4971 [IOPRIO_CLASS_RT] = "realtime",
4972 [IOPRIO_CLASS_BE] = "best-effort",
4973 [IOPRIO_CLASS_IDLE] = "idle"
4976 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4978 static const char *const sigchld_code_table[] = {
4979 [CLD_EXITED] = "exited",
4980 [CLD_KILLED] = "killed",
4981 [CLD_DUMPED] = "dumped",
4982 [CLD_TRAPPED] = "trapped",
4983 [CLD_STOPPED] = "stopped",
4984 [CLD_CONTINUED] = "continued",
4987 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4989 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4990 [LOG_FAC(LOG_KERN)] = "kern",
4991 [LOG_FAC(LOG_USER)] = "user",
4992 [LOG_FAC(LOG_MAIL)] = "mail",
4993 [LOG_FAC(LOG_DAEMON)] = "daemon",
4994 [LOG_FAC(LOG_AUTH)] = "auth",
4995 [LOG_FAC(LOG_SYSLOG)] = "syslog",
4996 [LOG_FAC(LOG_LPR)] = "lpr",
4997 [LOG_FAC(LOG_NEWS)] = "news",
4998 [LOG_FAC(LOG_UUCP)] = "uucp",
4999 [LOG_FAC(LOG_CRON)] = "cron",
5000 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5001 [LOG_FAC(LOG_FTP)] = "ftp",
5002 [LOG_FAC(LOG_LOCAL0)] = "local0",
5003 [LOG_FAC(LOG_LOCAL1)] = "local1",
5004 [LOG_FAC(LOG_LOCAL2)] = "local2",
5005 [LOG_FAC(LOG_LOCAL3)] = "local3",
5006 [LOG_FAC(LOG_LOCAL4)] = "local4",
5007 [LOG_FAC(LOG_LOCAL5)] = "local5",
5008 [LOG_FAC(LOG_LOCAL6)] = "local6",
5009 [LOG_FAC(LOG_LOCAL7)] = "local7"
5012 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
5014 static const char *const log_level_table[] = {
5015 [LOG_EMERG] = "emerg",
5016 [LOG_ALERT] = "alert",
5017 [LOG_CRIT] = "crit",
5019 [LOG_WARNING] = "warning",
5020 [LOG_NOTICE] = "notice",
5021 [LOG_INFO] = "info",
5022 [LOG_DEBUG] = "debug"
5025 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
5027 static const char* const sched_policy_table[] = {
5028 [SCHED_OTHER] = "other",
5029 [SCHED_BATCH] = "batch",
5030 [SCHED_IDLE] = "idle",
5031 [SCHED_FIFO] = "fifo",
5035 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
5037 static const char* const rlimit_table[_RLIMIT_MAX] = {
5038 [RLIMIT_CPU] = "LimitCPU",
5039 [RLIMIT_FSIZE] = "LimitFSIZE",
5040 [RLIMIT_DATA] = "LimitDATA",
5041 [RLIMIT_STACK] = "LimitSTACK",
5042 [RLIMIT_CORE] = "LimitCORE",
5043 [RLIMIT_RSS] = "LimitRSS",
5044 [RLIMIT_NOFILE] = "LimitNOFILE",
5045 [RLIMIT_AS] = "LimitAS",
5046 [RLIMIT_NPROC] = "LimitNPROC",
5047 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5048 [RLIMIT_LOCKS] = "LimitLOCKS",
5049 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5050 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5051 [RLIMIT_NICE] = "LimitNICE",
5052 [RLIMIT_RTPRIO] = "LimitRTPRIO",
5053 [RLIMIT_RTTIME] = "LimitRTTIME"
5056 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5058 static const char* const ip_tos_table[] = {
5059 [IPTOS_LOWDELAY] = "low-delay",
5060 [IPTOS_THROUGHPUT] = "throughput",
5061 [IPTOS_RELIABILITY] = "reliability",
5062 [IPTOS_LOWCOST] = "low-cost",
5065 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
5067 static const char *const __signal_table[] = {
5084 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
5095 [SIGVTALRM] = "VTALRM",
5097 [SIGWINCH] = "WINCH",
5103 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5105 const char *signal_to_string(int signo) {
5106 static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
5109 name = __signal_to_string(signo);
5113 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5114 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
5116 snprintf(buf, sizeof(buf), "%d", signo);
5121 int signal_from_string(const char *s) {
5126 signo = __signal_from_string(s);
5130 if (startswith(s, "RTMIN+")) {
5134 if (safe_atou(s, &u) >= 0) {
5135 signo = (int) u + offset;
5136 if (signo > 0 && signo < _NSIG)
5142 bool kexec_loaded(void) {
5143 bool loaded = false;
5146 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5154 int prot_from_flags(int flags) {
5156 switch (flags & O_ACCMODE) {
5165 return PROT_READ|PROT_WRITE;
5172 char *format_bytes(char *buf, size_t l, off_t t) {
5175 static const struct {
5179 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5180 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5181 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5182 { "G", 1024ULL*1024ULL*1024ULL },
5183 { "M", 1024ULL*1024ULL },
5187 if (t == (off_t) -1)
5190 for (i = 0; i < ELEMENTSOF(table); i++) {
5192 if (t >= table[i].factor) {
5195 (unsigned long long) (t / table[i].factor),
5196 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5203 snprintf(buf, l, "%lluB", (unsigned long long) t);
5211 void* memdup(const void *p, size_t l) {
5224 int fd_inc_sndbuf(int fd, size_t n) {
5226 socklen_t l = sizeof(value);
5228 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5229 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5232 /* If we have the privileges we will ignore the kernel limit. */
5235 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
5236 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
5242 int fd_inc_rcvbuf(int fd, size_t n) {
5244 socklen_t l = sizeof(value);
5246 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5247 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5250 /* If we have the privileges we will ignore the kernel limit. */
5253 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
5254 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
5259 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5260 bool stdout_is_tty, stderr_is_tty;
5261 pid_t parent_pid, agent_pid;
5262 sigset_t ss, saved_ss;
5270 /* Spawns a temporary TTY agent, making sure it goes away when
5273 parent_pid = getpid();
5275 /* First we temporarily block all signals, so that the new
5276 * child has them blocked initially. This way, we can be sure
5277 * that SIGTERMs are not lost we might send to the agent. */
5278 assert_se(sigfillset(&ss) >= 0);
5279 assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
5282 if (agent_pid < 0) {
5283 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5287 if (agent_pid != 0) {
5288 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5295 * Make sure the agent goes away when the parent dies */
5296 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5297 _exit(EXIT_FAILURE);
5299 /* Make sure we actually can kill the agent, if we need to, in
5300 * case somebody invoked us from a shell script that trapped
5301 * SIGTERM or so... */
5302 reset_all_signal_handlers();
5303 reset_signal_mask();
5305 /* Check whether our parent died before we were able
5306 * to set the death signal and unblock the signals */
5307 if (getppid() != parent_pid)
5308 _exit(EXIT_SUCCESS);
5310 /* Don't leak fds to the agent */
5311 close_all_fds(except, n_except);
5313 stdout_is_tty = isatty(STDOUT_FILENO);
5314 stderr_is_tty = isatty(STDERR_FILENO);
5316 if (!stdout_is_tty || !stderr_is_tty) {
5319 /* Detach from stdout/stderr. and reopen
5320 * /dev/tty for them. This is important to
5321 * ensure that when systemctl is started via
5322 * popen() or a similar call that expects to
5323 * read EOF we actually do generate EOF and
5324 * not delay this indefinitely by because we
5325 * keep an unused copy of stdin around. */
5326 fd = open("/dev/tty", O_WRONLY);
5328 log_error_errno(errno, "Failed to open /dev/tty: %m");
5329 _exit(EXIT_FAILURE);
5333 dup2(fd, STDOUT_FILENO);
5336 dup2(fd, STDERR_FILENO);
5342 /* Count arguments */
5344 for (n = 0; va_arg(ap, char*); n++)
5349 l = alloca(sizeof(char *) * (n + 1));
5351 /* Fill in arguments */
5353 for (i = 0; i <= n; i++)
5354 l[i] = va_arg(ap, char*);
5358 _exit(EXIT_FAILURE);
5361 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5362 struct rlimit highest, fixed;
5366 if (setrlimit(resource, rlim) >= 0)
5372 /* So we failed to set the desired setrlimit, then let's try
5373 * to get as close as we can */
5374 assert_se(getrlimit(resource, &highest) == 0);
5376 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5377 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5379 if (setrlimit(resource, &fixed) < 0)
5385 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5386 _cleanup_fclose_ FILE *f = NULL;
5397 path = procfs_file_alloca(pid, "environ");
5399 f = fopen(path, "re");
5407 char line[LINE_MAX];
5410 for (i = 0; i < sizeof(line)-1; i++) {
5414 if (_unlikely_(c == EOF)) {
5424 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5425 value = strdup(line + l + 1);
5439 bool is_valid_documentation_url(const char *url) {
5442 if (startswith(url, "http://") && url[7])
5445 if (startswith(url, "https://") && url[8])
5448 if (startswith(url, "file:") && url[5])
5451 if (startswith(url, "info:") && url[5])
5454 if (startswith(url, "man:") && url[4])
5460 bool in_initrd(void) {
5461 static int saved = -1;
5467 /* We make two checks here:
5469 * 1. the flag file /etc/initrd-release must exist
5470 * 2. the root file system must be a memory file system
5472 * The second check is extra paranoia, since misdetecting an
5473 * initrd can have bad bad consequences due the initrd
5474 * emptying when transititioning to the main systemd.
5477 saved = access("/etc/initrd-release", F_OK) >= 0 &&
5478 statfs("/", &s) >= 0 &&
5479 is_temporary_fs(&s);
5484 void warn_melody(void) {
5485 _cleanup_close_ int fd = -1;
5487 fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5491 /* Yeah, this is synchronous. Kinda sucks. But well... */
5493 ioctl(fd, KIOCSOUND, (int)(1193180/440));
5494 usleep(125*USEC_PER_MSEC);
5496 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5497 usleep(125*USEC_PER_MSEC);
5499 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5500 usleep(125*USEC_PER_MSEC);
5502 ioctl(fd, KIOCSOUND, 0);
5505 int make_console_stdio(void) {
5508 /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5510 fd = acquire_terminal("/dev/console", false, true, true, USEC_INFINITY);
5512 return log_error_errno(fd, "Failed to acquire terminal: %m");
5516 return log_error_errno(r, "Failed to duplicate terminal fd: %m");
5521 int get_home_dir(char **_h) {
5529 /* Take the user specified one */
5530 e = secure_getenv("HOME");
5531 if (e && path_is_absolute(e)) {
5540 /* Hardcode home directory for root to avoid NSS */
5543 h = strdup("/root");
5551 /* Check the database... */
5555 return errno > 0 ? -errno : -ESRCH;
5557 if (!path_is_absolute(p->pw_dir))
5560 h = strdup(p->pw_dir);
5568 int get_shell(char **_s) {
5576 /* Take the user specified one */
5577 e = getenv("SHELL");
5587 /* Hardcode home directory for root to avoid NSS */
5590 s = strdup("/bin/sh");
5598 /* Check the database... */
5602 return errno > 0 ? -errno : -ESRCH;
5604 if (!path_is_absolute(p->pw_shell))
5607 s = strdup(p->pw_shell);
5615 bool filename_is_valid(const char *p) {
5629 if (strlen(p) > FILENAME_MAX)
5635 bool string_is_safe(const char *p) {
5641 for (t = p; *t; t++) {
5642 if (*t > 0 && *t < ' ')
5645 if (strchr("\\\"\'\0x7f", *t))
5653 * Check if a string contains control characters. If 'ok' is non-NULL
5654 * it may be a string containing additional CCs to be considered OK.
5656 bool string_has_cc(const char *p, const char *ok) {
5661 for (t = p; *t; t++) {
5662 if (ok && strchr(ok, *t))
5665 if (*t > 0 && *t < ' ')
5675 bool path_is_safe(const char *p) {
5680 if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5683 if (strlen(p) > PATH_MAX)
5686 /* The following two checks are not really dangerous, but hey, they still are confusing */
5687 if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5690 if (strstr(p, "//"))
5696 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5697 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5698 int (*compar) (const void *, const void *, void *), void *arg) {
5707 p = (void *)(((const char *) base) + (idx * size));
5708 comparison = compar(key, p, arg);
5711 else if (comparison > 0)
5719 bool is_locale_utf8(void) {
5721 static int cached_answer = -1;
5723 if (cached_answer >= 0)
5726 if (!setlocale(LC_ALL, "")) {
5727 cached_answer = true;
5731 set = nl_langinfo(CODESET);
5733 cached_answer = true;
5737 if (streq(set, "UTF-8")) {
5738 cached_answer = true;
5742 /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5743 * unset and everything can do to UTF-8 nowadays. */
5744 set = setlocale(LC_CTYPE, NULL);
5746 cached_answer = true;
5750 /* Check result, but ignore the result if C was set
5754 !getenv("LC_ALL") &&
5755 !getenv("LC_CTYPE") &&
5759 return (bool) cached_answer;
5762 const char *draw_special_char(DrawSpecialChar ch) {
5763 static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5766 [DRAW_TREE_VERTICAL] = "\342\224\202 ", /* │ */
5767 [DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
5768 [DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
5769 [DRAW_TREE_SPACE] = " ", /* */
5770 [DRAW_TRIANGULAR_BULLET] = "\342\200\243", /* ‣ */
5771 [DRAW_BLACK_CIRCLE] = "\342\227\217", /* ● */
5772 [DRAW_ARROW] = "\342\206\222", /* → */
5773 [DRAW_DASH] = "\342\200\223", /* – */
5776 /* ASCII fallback */ {
5777 [DRAW_TREE_VERTICAL] = "| ",
5778 [DRAW_TREE_BRANCH] = "|-",
5779 [DRAW_TREE_RIGHT] = "`-",
5780 [DRAW_TREE_SPACE] = " ",
5781 [DRAW_TRIANGULAR_BULLET] = ">",
5782 [DRAW_BLACK_CIRCLE] = "*",
5783 [DRAW_ARROW] = "->",
5788 return draw_table[!is_locale_utf8()][ch];
5791 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5794 size_t l, old_len, new_len;
5800 old_len = strlen(old_string);
5801 new_len = strlen(new_string);
5814 if (!startswith(f, old_string)) {
5820 nl = l - old_len + new_len;
5821 a = realloc(r, nl + 1);
5829 t = stpcpy(t, new_string);
5841 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5842 const char *i, *begin = NULL;
5847 } state = STATE_OTHER;
5849 size_t osz = 0, isz;
5855 /* Strips ANSI color and replaces TABs by 8 spaces */
5857 isz = _isz ? *_isz : strlen(*ibuf);
5859 f = open_memstream(&obuf, &osz);
5863 for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5868 if (i >= *ibuf + isz) /* EOT */
5870 else if (*i == '\x1B')
5871 state = STATE_ESCAPE;
5872 else if (*i == '\t')
5879 if (i >= *ibuf + isz) { /* EOT */
5882 } else if (*i == '[') {
5883 state = STATE_BRACKET;
5888 state = STATE_OTHER;
5895 if (i >= *ibuf + isz || /* EOT */
5896 (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5899 state = STATE_OTHER;
5901 } else if (*i == 'm')
5902 state = STATE_OTHER;
5924 int on_ac_power(void) {
5925 bool found_offline = false, found_online = false;
5926 _cleanup_closedir_ DIR *d = NULL;
5928 d = opendir("/sys/class/power_supply");
5934 _cleanup_close_ int fd = -1, device = -1;
5940 if (!de && errno != 0)
5946 if (hidden_file(de->d_name))
5949 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5951 if (errno == ENOENT || errno == ENOTDIR)
5957 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5959 if (errno == ENOENT)
5965 n = read(fd, contents, sizeof(contents));
5969 if (n != 6 || memcmp(contents, "Mains\n", 6))
5973 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5975 if (errno == ENOENT)
5981 n = read(fd, contents, sizeof(contents));
5985 if (n != 2 || contents[1] != '\n')
5988 if (contents[0] == '1') {
5989 found_online = true;
5991 } else if (contents[0] == '0')
5992 found_offline = true;
5997 return found_online || !found_offline;
6000 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
6007 if (!path_strv_resolve_uniq(search, root))
6010 STRV_FOREACH(i, search) {
6011 _cleanup_free_ char *p = NULL;
6015 p = strjoin(root, *i, "/", path, NULL);
6017 p = strjoin(*i, "/", path, NULL);
6027 if (errno != ENOENT)
6034 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
6035 _cleanup_strv_free_ char **copy = NULL;
6041 if (path_is_absolute(path)) {
6044 f = fopen(path, mode);
6053 copy = strv_copy((char**) search);
6057 return search_and_fopen_internal(path, mode, root, copy, _f);
6060 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
6061 _cleanup_strv_free_ char **s = NULL;
6063 if (path_is_absolute(path)) {
6066 f = fopen(path, mode);
6075 s = strv_split_nulstr(search);
6079 return search_and_fopen_internal(path, mode, root, s, _f);
6082 char *strextend(char **x, ...) {
6089 l = f = *x ? strlen(*x) : 0;
6096 t = va_arg(ap, const char *);
6101 if (n > ((size_t) -1) - l) {
6110 r = realloc(*x, l+1);
6120 t = va_arg(ap, const char *);
6134 char *strrep(const char *s, unsigned n) {
6142 p = r = malloc(l * n + 1);
6146 for (i = 0; i < n; i++)
6153 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
6160 if (*allocated >= need)
6163 newalloc = MAX(need * 2, 64u / size);
6164 a = newalloc * size;
6166 /* check for overflows */
6167 if (a < size * need)
6175 *allocated = newalloc;
6179 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
6188 q = greedy_realloc(p, allocated, need, size);
6192 if (*allocated > prev)
6193 memzero(q + prev * size, (*allocated - prev) * size);
6198 bool id128_is_valid(const char *s) {
6204 /* Simple formatted 128bit hex string */
6206 for (i = 0; i < l; i++) {
6209 if (!(c >= '0' && c <= '9') &&
6210 !(c >= 'a' && c <= 'z') &&
6211 !(c >= 'A' && c <= 'Z'))
6215 } else if (l == 36) {
6217 /* Formatted UUID */
6219 for (i = 0; i < l; i++) {
6222 if ((i == 8 || i == 13 || i == 18 || i == 23)) {
6226 if (!(c >= '0' && c <= '9') &&
6227 !(c >= 'a' && c <= 'z') &&
6228 !(c >= 'A' && c <= 'Z'))
6239 int split_pair(const char *s, const char *sep, char **l, char **r) {
6254 a = strndup(s, x - s);
6258 b = strdup(x + strlen(sep));
6270 int shall_restore_state(void) {
6271 _cleanup_free_ char *value = NULL;
6274 r = get_proc_cmdline_key("systemd.restore_state=", &value);
6280 return parse_boolean(value) != 0;
6283 int proc_cmdline(char **ret) {
6286 if (detect_container(NULL) > 0)
6287 return get_process_cmdline(1, 0, false, ret);
6289 return read_one_line_file("/proc/cmdline", ret);
6292 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6293 _cleanup_free_ char *line = NULL;
6299 r = proc_cmdline(&line);
6305 _cleanup_free_ char *word = NULL;
6308 r = unquote_first_word(&p, &word, true);
6314 /* Filter out arguments that are intended only for the
6316 if (!in_initrd() && startswith(word, "rd."))
6319 value = strchr(word, '=');
6323 r = parse_item(word, value);
6331 int get_proc_cmdline_key(const char *key, char **value) {
6332 _cleanup_free_ char *line = NULL, *ret = NULL;
6339 r = proc_cmdline(&line);
6345 _cleanup_free_ char *word = NULL;
6348 r = unquote_first_word(&p, &word, true);
6354 /* Filter out arguments that are intended only for the
6356 if (!in_initrd() && startswith(word, "rd."))
6360 e = startswith(word, key);
6364 r = free_and_strdup(&ret, e);
6370 if (streq(word, key))
6384 int container_get_leader(const char *machine, pid_t *pid) {
6385 _cleanup_free_ char *s = NULL, *class = NULL;
6393 p = strappenda("/run/systemd/machines/", machine);
6394 r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6402 if (!streq_ptr(class, "container"))
6405 r = parse_pid(s, &leader);
6415 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
6416 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
6424 mntns = procfs_file_alloca(pid, "ns/mnt");
6425 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6433 pidns = procfs_file_alloca(pid, "ns/pid");
6434 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6442 netns = procfs_file_alloca(pid, "ns/net");
6443 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6451 root = procfs_file_alloca(pid, "root");
6452 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6458 *pidns_fd = pidnsfd;
6461 *mntns_fd = mntnsfd;
6464 *netns_fd = netnsfd;
6469 pidnsfd = mntnsfd = netnsfd = -1;
6474 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
6477 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6481 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6485 if (setns(netns_fd, CLONE_NEWNET) < 0)
6489 if (fchdir(root_fd) < 0)
6492 if (chroot(".") < 0)
6496 if (setresgid(0, 0, 0) < 0)
6499 if (setgroups(0, NULL) < 0)
6502 if (setresuid(0, 0, 0) < 0)
6508 bool pid_is_unwaited(pid_t pid) {
6509 /* Checks whether a PID is still valid at all, including a zombie */
6514 if (kill(pid, 0) >= 0)
6517 return errno != ESRCH;
6520 bool pid_is_alive(pid_t pid) {
6523 /* Checks whether a PID is still valid and not a zombie */
6528 r = get_process_state(pid);
6529 if (r == -ENOENT || r == 'Z')
6535 int getpeercred(int fd, struct ucred *ucred) {
6536 socklen_t n = sizeof(struct ucred);
6543 r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6547 if (n != sizeof(struct ucred))
6550 /* Check if the data is actually useful and not suppressed due
6551 * to namespacing issues */
6554 if (u.uid == UID_INVALID)
6556 if (u.gid == GID_INVALID)
6563 int getpeersec(int fd, char **ret) {
6575 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6579 if (errno != ERANGE)
6586 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6602 /* This is much like like mkostemp() but is subject to umask(). */
6603 int mkostemp_safe(char *pattern, int flags) {
6604 _cleanup_umask_ mode_t u;
6611 fd = mkostemp(pattern, flags);
6618 int open_tmpfile(const char *path, int flags) {
6625 /* Try O_TMPFILE first, if it is supported */
6626 fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6631 /* Fall back to unguessable name + unlinking */
6632 p = strappenda(path, "/systemd-tmp-XXXXXX");
6634 fd = mkostemp_safe(p, flags);
6642 int fd_warn_permissions(const char *path, int fd) {
6645 if (fstat(fd, &st) < 0)
6648 if (st.st_mode & 0111)
6649 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6651 if (st.st_mode & 0002)
6652 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6654 if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6655 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);
6660 unsigned long personality_from_string(const char *p) {
6662 /* Parse a personality specifier. We introduce our own
6663 * identifiers that indicate specific ABIs, rather than just
6664 * hints regarding the register size, since we want to keep
6665 * things open for multiple locally supported ABIs for the
6666 * same register size. We try to reuse the ABI identifiers
6667 * used by libseccomp. */
6669 #if defined(__x86_64__)
6671 if (streq(p, "x86"))
6674 if (streq(p, "x86-64"))
6677 #elif defined(__i386__)
6679 if (streq(p, "x86"))
6683 /* personality(7) documents that 0xffffffffUL is used for
6684 * querying the current personality, hence let's use that here
6685 * as error indicator. */
6686 return 0xffffffffUL;
6689 const char* personality_to_string(unsigned long p) {
6691 #if defined(__x86_64__)
6693 if (p == PER_LINUX32)
6699 #elif defined(__i386__)
6708 uint64_t physical_memory(void) {
6711 /* We return this as uint64_t in case we are running as 32bit
6712 * process on a 64bit kernel with huge amounts of memory */
6714 mem = sysconf(_SC_PHYS_PAGES);
6717 return (uint64_t) mem * (uint64_t) page_size();
6720 char* mount_test_option(const char *haystack, const char *needle) {
6722 struct mntent me = {
6723 .mnt_opts = (char*) haystack
6728 /* Like glibc's hasmntopt(), but works on a string, not a
6734 return hasmntopt(&me, needle);
6737 void hexdump(FILE *f, const void *p, size_t s) {
6738 const uint8_t *b = p;
6741 assert(s == 0 || b);
6746 fprintf(f, "%04x ", n);
6748 for (i = 0; i < 16; i++) {
6753 fprintf(f, "%02x ", b[i]);
6761 for (i = 0; i < 16; i++) {
6766 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
6780 int update_reboot_param_file(const char *param) {
6785 r = write_string_file(REBOOT_PARAM_FILE, param);
6787 log_error("Failed to write reboot param to "
6788 REBOOT_PARAM_FILE": %s", strerror(-r));
6790 unlink(REBOOT_PARAM_FILE);
6795 int umount_recursive(const char *prefix, int flags) {
6799 /* Try to umount everything recursively below a
6800 * directory. Also, take care of stacked mounts, and keep
6801 * unmounting them until they are gone. */
6804 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6809 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6810 if (!proc_self_mountinfo)
6814 _cleanup_free_ char *path = NULL, *p = NULL;
6817 k = fscanf(proc_self_mountinfo,
6818 "%*s " /* (1) mount id */
6819 "%*s " /* (2) parent id */
6820 "%*s " /* (3) major:minor */
6821 "%*s " /* (4) root */
6822 "%ms " /* (5) mount point */
6823 "%*s" /* (6) mount options */
6824 "%*[^-]" /* (7) optional fields */
6825 "- " /* (8) separator */
6826 "%*s " /* (9) file system type */
6827 "%*s" /* (10) mount source */
6828 "%*s" /* (11) mount options 2 */
6829 "%*[^\n]", /* some rubbish at the end */
6838 p = cunescape(path);
6842 if (!path_startswith(p, prefix))
6845 if (umount2(p, flags) < 0) {
6861 int bind_remount_recursive(const char *prefix, bool ro) {
6862 _cleanup_set_free_free_ Set *done = NULL;
6863 _cleanup_free_ char *cleaned = NULL;
6866 /* Recursively remount a directory (and all its submounts)
6867 * read-only or read-write. If the directory is already
6868 * mounted, we reuse the mount and simply mark it
6869 * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
6870 * operation). If it isn't we first make it one. Afterwards we
6871 * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
6872 * submounts we can access, too. When mounts are stacked on
6873 * the same mount point we only care for each individual
6874 * "top-level" mount on each point, as we cannot
6875 * influence/access the underlying mounts anyway. We do not
6876 * have any effect on future submounts that might get
6877 * propagated, they migt be writable. This includes future
6878 * submounts that have been triggered via autofs. */
6880 cleaned = strdup(prefix);
6884 path_kill_slashes(cleaned);
6886 done = set_new(&string_hash_ops);
6891 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6892 _cleanup_set_free_free_ Set *todo = NULL;
6893 bool top_autofs = false;
6896 todo = set_new(&string_hash_ops);
6900 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6901 if (!proc_self_mountinfo)
6905 _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
6908 k = fscanf(proc_self_mountinfo,
6909 "%*s " /* (1) mount id */
6910 "%*s " /* (2) parent id */
6911 "%*s " /* (3) major:minor */
6912 "%*s " /* (4) root */
6913 "%ms " /* (5) mount point */
6914 "%*s" /* (6) mount options (superblock) */
6915 "%*[^-]" /* (7) optional fields */
6916 "- " /* (8) separator */
6917 "%ms " /* (9) file system type */
6918 "%*s" /* (10) mount source */
6919 "%*s" /* (11) mount options (bind mount) */
6920 "%*[^\n]", /* some rubbish at the end */
6930 p = cunescape(path);
6934 /* Let's ignore autofs mounts. If they aren't
6935 * triggered yet, we want to avoid triggering
6936 * them, as we don't make any guarantees for
6937 * future submounts anyway. If they are
6938 * already triggered, then we will find
6939 * another entry for this. */
6940 if (streq(type, "autofs")) {
6941 top_autofs = top_autofs || path_equal(cleaned, p);
6945 if (path_startswith(p, cleaned) &&
6946 !set_contains(done, p)) {
6948 r = set_consume(todo, p);
6958 /* If we have no submounts to process anymore and if
6959 * the root is either already done, or an autofs, we
6961 if (set_isempty(todo) &&
6962 (top_autofs || set_contains(done, cleaned)))
6965 if (!set_contains(done, cleaned) &&
6966 !set_contains(todo, cleaned)) {
6967 /* The prefix directory itself is not yet a
6968 * mount, make it one. */
6969 if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
6972 if (mount(NULL, prefix, NULL, MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
6975 x = strdup(cleaned);
6979 r = set_consume(done, x);
6984 while ((x = set_steal_first(todo))) {
6986 r = set_consume(done, x);
6992 if (mount(NULL, x, NULL, MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
6994 /* Deal with mount points that are
6995 * obstructed by a later mount */
6997 if (errno != ENOENT)
7005 int fflush_and_check(FILE *f) {
7012 return errno ? -errno : -EIO;
7017 int tempfn_xxxxxx(const char *p, char **ret) {
7029 * /foo/bar/.#waldoXXXXXX
7033 if (!filename_is_valid(fn))
7036 t = new(char, strlen(p) + 2 + 6 + 1);
7040 strcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn), "XXXXXX");
7042 *ret = path_kill_slashes(t);
7046 int tempfn_random(const char *p, char **ret) {
7060 * /foo/bar/.#waldobaa2a261115984a9
7064 if (!filename_is_valid(fn))
7067 t = new(char, strlen(p) + 2 + 16 + 1);
7071 x = stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn);
7074 for (i = 0; i < 16; i++) {
7075 *(x++) = hexchar(u & 0xF);
7081 *ret = path_kill_slashes(t);
7085 int tempfn_random_child(const char *p, char **ret) {
7096 * /foo/bar/waldo/.#3c2b6219aa75d7d0
7099 t = new(char, strlen(p) + 3 + 16 + 1);
7103 x = stpcpy(stpcpy(t, p), "/.#");
7106 for (i = 0; i < 16; i++) {
7107 *(x++) = hexchar(u & 0xF);
7113 *ret = path_kill_slashes(t);
7117 /* make sure the hostname is not "localhost" */
7118 bool is_localhost(const char *hostname) {
7121 /* This tries to identify local host and domain names
7122 * described in RFC6761 plus the redhatism of .localdomain */
7124 return streq(hostname, "localhost") ||
7125 streq(hostname, "localhost.") ||
7126 streq(hostname, "localdomain.") ||
7127 streq(hostname, "localdomain") ||
7128 endswith(hostname, ".localhost") ||
7129 endswith(hostname, ".localhost.") ||
7130 endswith(hostname, ".localdomain") ||
7131 endswith(hostname, ".localdomain.");
7134 int take_password_lock(const char *root) {
7136 struct flock flock = {
7138 .l_whence = SEEK_SET,
7146 /* This is roughly the same as lckpwdf(), but not as awful. We
7147 * don't want to use alarm() and signals, hence we implement
7148 * our own trivial version of this.
7150 * Note that shadow-utils also takes per-database locks in
7151 * addition to lckpwdf(). However, we don't given that they
7152 * are redundant as they they invoke lckpwdf() first and keep
7153 * it during everything they do. The per-database locks are
7154 * awfully racy, and thus we just won't do them. */
7157 path = strappenda(root, "/etc/.pwd.lock");
7159 path = "/etc/.pwd.lock";
7161 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
7165 r = fcntl(fd, F_SETLKW, &flock);
7174 int is_symlink(const char *path) {
7177 if (lstat(path, &info) < 0)
7180 return !!S_ISLNK(info.st_mode);
7183 int is_dir(const char* path, bool follow) {
7188 r = stat(path, &st);
7190 r = lstat(path, &st);
7194 return !!S_ISDIR(st.st_mode);
7197 int unquote_first_word(const char **p, char **ret, bool relax) {
7198 _cleanup_free_ char *s = NULL;
7199 size_t allocated = 0, sz = 0;
7206 SINGLE_QUOTE_ESCAPE,
7208 DOUBLE_QUOTE_ESCAPE,
7216 /* Parses the first word of a string, and returns it in
7217 * *ret. Removes all quotes in the process. When parsing fails
7218 * (because of an uneven number of quotes or similar), leaves
7219 * the pointer *p at the first invalid character. */
7229 else if (strchr(WHITESPACE, c))
7239 state = SINGLE_QUOTE;
7241 state = VALUE_ESCAPE;
7243 state = DOUBLE_QUOTE;
7244 else if (strchr(WHITESPACE, c))
7247 if (!GREEDY_REALLOC(s, allocated, sz+2))
7262 if (!GREEDY_REALLOC(s, allocated, sz+2))
7275 } else if (c == '\'')
7278 state = SINGLE_QUOTE_ESCAPE;
7280 if (!GREEDY_REALLOC(s, allocated, sz+2))
7288 case SINGLE_QUOTE_ESCAPE:
7295 if (!GREEDY_REALLOC(s, allocated, sz+2))
7299 state = SINGLE_QUOTE;
7308 state = DOUBLE_QUOTE_ESCAPE;
7310 if (!GREEDY_REALLOC(s, allocated, sz+2))
7318 case DOUBLE_QUOTE_ESCAPE:
7325 if (!GREEDY_REALLOC(s, allocated, sz+2))
7329 state = DOUBLE_QUOTE;
7335 if (!strchr(WHITESPACE, c))
7357 int unquote_many_words(const char **p, ...) {
7362 /* Parses a number of words from a string, stripping any
7363 * quotes if necessary. */
7367 /* Count how many words are expected */
7370 if (!va_arg(ap, char **))
7379 /* Read all words into a temporary array */
7380 l = newa0(char*, n);
7381 for (c = 0; c < n; c++) {
7383 r = unquote_first_word(p, &l[c], false);
7387 for (j = 0; j < c; j++)
7397 /* If we managed to parse all words, return them in the passed
7400 for (i = 0; i < n; i++) {
7403 v = va_arg(ap, char **);
7413 int free_and_strdup(char **p, const char *s) {
7418 /* Replaces a string pointer with an strdup()ed new string,
7419 * possibly freeing the old one. */
7434 int sethostname_idempotent(const char *s) {
7436 char buf[HOST_NAME_MAX + 1] = {};
7440 r = gethostname(buf, sizeof(buf));
7447 r = sethostname(s, strlen(s));
7454 int ptsname_malloc(int fd, char **ret) {
7467 if (ptsname_r(fd, c, l) == 0) {
7471 if (errno != ERANGE) {
7481 int openpt_in_namespace(pid_t pid, int flags) {
7482 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, rootfd = -1;
7483 _cleanup_close_pair_ int pair[2] = { -1, -1 };
7485 struct cmsghdr cmsghdr;
7486 uint8_t buf[CMSG_SPACE(sizeof(int))];
7488 struct msghdr mh = {
7489 .msg_control = &control,
7490 .msg_controllen = sizeof(control),
7492 struct cmsghdr *cmsg;
7499 r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &rootfd);
7503 if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
7513 pair[0] = safe_close(pair[0]);
7515 r = namespace_enter(pidnsfd, mntnsfd, -1, rootfd);
7517 _exit(EXIT_FAILURE);
7519 master = posix_openpt(flags);
7521 _exit(EXIT_FAILURE);
7523 cmsg = CMSG_FIRSTHDR(&mh);
7524 cmsg->cmsg_level = SOL_SOCKET;
7525 cmsg->cmsg_type = SCM_RIGHTS;
7526 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
7527 memcpy(CMSG_DATA(cmsg), &master, sizeof(int));
7529 mh.msg_controllen = cmsg->cmsg_len;
7531 if (sendmsg(pair[1], &mh, MSG_NOSIGNAL) < 0)
7532 _exit(EXIT_FAILURE);
7534 _exit(EXIT_SUCCESS);
7537 pair[1] = safe_close(pair[1]);
7539 r = wait_for_terminate(child, &si);
7542 if (si.si_code != CLD_EXITED || si.si_status != EXIT_SUCCESS)
7545 if (recvmsg(pair[0], &mh, MSG_NOSIGNAL|MSG_CMSG_CLOEXEC) < 0)
7548 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg))
7549 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
7553 fds = (int*) CMSG_DATA(cmsg);
7554 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
7557 close_many(fds, n_fds);
7567 ssize_t fgetxattrat_fake(int dirfd, const char *filename, const char *attribute, void *value, size_t size, int flags) {
7568 _cleanup_close_ int fd = -1;
7571 /* The kernel doesn't have a fgetxattrat() command, hence let's emulate one */
7573 fd = openat(dirfd, filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOATIME|(flags & AT_SYMLINK_NOFOLLOW ? O_NOFOLLOW : 0));
7577 l = fgetxattr(fd, attribute, value, size);
7584 static int parse_crtime(le64_t le, usec_t *usec) {
7590 if (u == 0 || u == (uint64_t) -1)
7597 int fd_getcrtime(int fd, usec_t *usec) {
7604 /* Until Linux gets a real concept of birthtime/creation time,
7605 * let's fake one with xattrs */
7607 n = fgetxattr(fd, "user.crtime_usec", &le, sizeof(le));
7610 if (n != sizeof(le))
7613 return parse_crtime(le, usec);
7616 int fd_getcrtime_at(int dirfd, const char *name, usec_t *usec, int flags) {
7620 n = fgetxattrat_fake(dirfd, name, "user.crtime_usec", &le, sizeof(le), flags);
7623 if (n != sizeof(le))
7626 return parse_crtime(le, usec);
7629 int path_getcrtime(const char *p, usec_t *usec) {
7636 n = getxattr(p, "user.crtime_usec", &le, sizeof(le));
7639 if (n != sizeof(le))
7642 return parse_crtime(le, usec);
7645 int fd_setcrtime(int fd, usec_t usec) {
7650 le = htole64((uint64_t) usec);
7651 if (fsetxattr(fd, "user.crtime_usec", &le, sizeof(le), 0) < 0)