1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
31 #include <sys/resource.h>
32 #include <linux/sched.h>
33 #include <sys/types.h>
37 #include <sys/ioctl.h>
39 #include <linux/tiocl.h>
42 #include <sys/inotify.h>
46 #include <sys/prctl.h>
47 #include <sys/utsname.h>
49 #include <netinet/ip.h>
53 #include <sys/capability.h>
55 #include <linux/rtc.h>
67 #include "exit-status.h"
71 char **saved_argv = NULL;
73 size_t page_size(void) {
74 static __thread size_t pgsz = 0;
77 if (_likely_(pgsz > 0))
80 assert_se((r = sysconf(_SC_PAGESIZE)) > 0);
87 bool streq_ptr(const char *a, const char *b) {
89 /* Like streq(), but tries to make sense of NULL pointers */
100 usec_t now(clockid_t clock_id) {
103 assert_se(clock_gettime(clock_id, &ts) == 0);
105 return timespec_load(&ts);
108 dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
111 ts->realtime = now(CLOCK_REALTIME);
112 ts->monotonic = now(CLOCK_MONOTONIC);
117 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
126 delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
128 ts->monotonic = now(CLOCK_MONOTONIC);
130 if ((int64_t) ts->monotonic > delta)
131 ts->monotonic -= delta;
139 usec_t timespec_load(const struct timespec *ts) {
143 (usec_t) ts->tv_sec * USEC_PER_SEC +
144 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
147 struct timespec *timespec_store(struct timespec *ts, usec_t u) {
150 ts->tv_sec = (time_t) (u / USEC_PER_SEC);
151 ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
156 usec_t timeval_load(const struct timeval *tv) {
160 (usec_t) tv->tv_sec * USEC_PER_SEC +
161 (usec_t) tv->tv_usec;
164 struct timeval *timeval_store(struct timeval *tv, usec_t u) {
167 tv->tv_sec = (time_t) (u / USEC_PER_SEC);
168 tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
173 bool endswith(const char *s, const char *postfix) {
180 pl = strlen(postfix);
188 return memcmp(s + sl - pl, postfix, pl) == 0;
191 bool startswith(const char *s, const char *prefix) {
206 return memcmp(s, prefix, pl) == 0;
209 bool startswith_no_case(const char *s, const char *prefix) {
225 for(i = 0; i < pl; ++i) {
226 if (tolower(s[i]) != tolower(prefix[i]))
233 bool first_word(const char *s, const char *word) {
248 if (memcmp(s, word, wl) != 0)
252 strchr(WHITESPACE, s[wl]);
255 int close_nointr(int fd) {
270 void close_nointr_nofail(int fd) {
271 int saved_errno = errno;
273 /* like close_nointr() but cannot fail, and guarantees errno
276 assert_se(close_nointr(fd) == 0);
281 void close_many(const int fds[], unsigned n_fd) {
284 for (i = 0; i < n_fd; i++)
285 close_nointr_nofail(fds[i]);
288 int parse_boolean(const char *v) {
291 if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
293 else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
299 int parse_pid(const char *s, pid_t* ret_pid) {
300 unsigned long ul = 0;
307 if ((r = safe_atolu(s, &ul)) < 0)
312 if ((unsigned long) pid != ul)
322 int parse_uid(const char *s, uid_t* ret_uid) {
323 unsigned long ul = 0;
330 if ((r = safe_atolu(s, &ul)) < 0)
335 if ((unsigned long) uid != ul)
342 int safe_atou(const char *s, unsigned *ret_u) {
350 l = strtoul(s, &x, 0);
352 if (!x || *x || errno)
353 return errno ? -errno : -EINVAL;
355 if ((unsigned long) (unsigned) l != l)
358 *ret_u = (unsigned) l;
362 int safe_atoi(const char *s, int *ret_i) {
370 l = strtol(s, &x, 0);
372 if (!x || *x || errno)
373 return errno ? -errno : -EINVAL;
375 if ((long) (int) l != l)
382 int safe_atollu(const char *s, long long unsigned *ret_llu) {
384 unsigned long long l;
390 l = strtoull(s, &x, 0);
392 if (!x || *x || errno)
393 return errno ? -errno : -EINVAL;
399 int safe_atolli(const char *s, long long int *ret_lli) {
407 l = strtoll(s, &x, 0);
409 if (!x || *x || errno)
410 return errno ? -errno : -EINVAL;
416 /* Split a string into words. */
417 char *split(const char *c, size_t *l, const char *separator, char **state) {
420 current = *state ? *state : (char*) c;
422 if (!*current || *c == 0)
425 current += strspn(current, separator);
426 *l = strcspn(current, separator);
429 return (char*) current;
432 /* Split a string into words, but consider strings enclosed in '' and
433 * "" as words even if they include spaces. */
434 char *split_quoted(const char *c, size_t *l, char **state) {
436 bool escaped = false;
438 current = *state ? *state : (char*) c;
440 if (!*current || *c == 0)
443 current += strspn(current, WHITESPACE);
445 if (*current == '\'') {
448 for (e = current; *e; e++) {
458 *state = *e == 0 ? e : e+1;
459 } else if (*current == '\"') {
462 for (e = current; *e; e++) {
472 *state = *e == 0 ? e : e+1;
474 for (e = current; *e; e++) {
479 else if (strchr(WHITESPACE, *e))
486 return (char*) current;
489 char **split_path_and_make_absolute(const char *p) {
493 if (!(l = strv_split(p, ":")))
496 if (!strv_path_make_absolute_cwd(l)) {
504 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
507 char fn[PATH_MAX], line[LINE_MAX], *p;
513 assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
516 if (!(f = fopen(fn, "re")))
519 if (!(fgets(line, sizeof(line), f))) {
520 r = feof(f) ? -EIO : -errno;
527 /* Let's skip the pid and comm fields. The latter is enclosed
528 * in () but does not escape any () in its value, so let's
529 * skip over it manually */
531 if (!(p = strrchr(line, ')')))
542 if ((long unsigned) (pid_t) ppid != ppid)
545 *_ppid = (pid_t) ppid;
550 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
553 char fn[PATH_MAX], line[LINE_MAX], *p;
558 assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
561 if (!(f = fopen(fn, "re")))
564 if (!(fgets(line, sizeof(line), f))) {
565 r = feof(f) ? -EIO : -errno;
572 /* Let's skip the pid and comm fields. The latter is enclosed
573 * in () but does not escape any () in its value, so let's
574 * skip over it manually */
576 if (!(p = strrchr(line, ')')))
597 "%*d " /* priority */
599 "%*d " /* num_threads */
600 "%*d " /* itrealvalue */
601 "%llu " /* starttime */,
608 int write_one_line_file(const char *fn, const char *line) {
615 if (!(f = fopen(fn, "we")))
619 if (fputs(line, f) < 0) {
624 if (!endswith(line, "\n"))
642 int fchmod_umask(int fd, mode_t m) {
647 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
653 int write_one_line_file_atomic(const char *fn, const char *line) {
661 r = fopen_temporary(fn, &f, &p);
665 fchmod_umask(fileno(f), 0644);
668 if (fputs(line, f) < 0) {
673 if (!endswith(line, "\n"))
684 if (rename(p, fn) < 0)
700 int read_one_line_file(const char *fn, char **line) {
703 char t[LINE_MAX], *c;
712 if (!fgets(t, sizeof(t), f)) {
738 int read_full_file(const char *fn, char **contents, size_t *size) {
745 if (!(f = fopen(fn, "re")))
748 if (fstat(fileno(f), &st) < 0) {
754 if (st.st_size > 4*1024*1024) {
759 n = st.st_size > 0 ? st.st_size : LINE_MAX;
766 if (!(t = realloc(buf, n+1))) {
772 k = fread(buf + l, 1, n - l, f);
787 if (n > 4*1024*1024) {
811 const char *separator, ...) {
814 char *contents = NULL, *p;
819 if ((r = read_full_file(fname, &contents, NULL)) < 0)
824 const char *key = NULL;
826 p += strspn(p, separator);
827 p += strspn(p, WHITESPACE);
832 if (!strchr(COMMENTS, *p)) {
836 va_start(ap, separator);
837 while ((key = va_arg(ap, char *))) {
841 value = va_arg(ap, char **);
844 if (strncmp(p, key, n) != 0 ||
849 n = strcspn(p, separator);
852 strchr(QUOTES, p[0]) &&
854 v = strndup(p+1, n-2);
865 /* return empty value strings as NULL */
882 p += strcspn(p, separator);
901 if (!(f = fopen(fname, "re")))
905 char l[LINE_MAX], *p, *u;
908 if (!fgets(l, sizeof(l), f)) {
921 if (strchr(COMMENTS, *p))
924 if (!(u = normalize_env_assignment(p))) {
925 log_error("Out of memory");
930 t = strv_append(m, u);
934 log_error("Out of memory");
957 int write_env_file(const char *fname, char **l) {
962 r = fopen_temporary(fname, &f, &p);
966 fchmod_umask(fileno(f), 0644);
982 if (rename(p, fname) < 0)
997 char *truncate_nl(char *s) {
1000 s[strcspn(s, NEWLINE)] = 0;
1004 int get_process_comm(pid_t pid, char **name) {
1010 r = read_one_line_file("/proc/self/comm", name);
1013 if (asprintf(&p, "/proc/%lu/comm", (unsigned long) pid) < 0)
1016 r = read_one_line_file(p, name);
1023 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
1030 assert(max_length > 0);
1034 f = fopen("/proc/self/cmdline", "re");
1037 if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
1047 r = new(char, max_length);
1055 while ((c = getc(f)) != EOF) {
1077 size_t n = MIN(left-1, 3U);
1078 memcpy(k, "...", n);
1085 /* Kernel threads have no argv[] */
1095 h = get_process_comm(pid, &t);
1099 r = join("[", t, "]", NULL);
1110 int is_kernel_thread(pid_t pid) {
1120 if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
1129 count = fread(&c, 1, 1, f);
1133 /* Kernel threads have an empty cmdline */
1136 return eof ? 1 : -errno;
1141 int get_process_exe(pid_t pid, char **name) {
1147 r = readlink_malloc("/proc/self/exe", name);
1150 if (asprintf(&p, "/proc/%lu/exe", (unsigned long) pid) < 0)
1153 r = readlink_malloc(p, name);
1160 int get_process_uid(pid_t pid, uid_t *uid) {
1170 if (asprintf(&p, "/proc/%lu/status", (unsigned long) pid) < 0)
1180 char line[LINE_MAX], *l;
1182 if (!fgets(line, sizeof(line), f)) {
1192 if (startswith(l, "Uid:")) {
1194 l += strspn(l, WHITESPACE);
1196 l[strcspn(l, WHITESPACE)] = 0;
1198 r = parse_uid(l, uid);
1211 char *strnappend(const char *s, const char *suffix, size_t b) {
1219 return strndup(suffix, b);
1229 if (!(r = new(char, a+b+1)))
1233 memcpy(r+a, suffix, b);
1239 char *strappend(const char *s, const char *suffix) {
1240 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
1243 int readlink_malloc(const char *p, char **r) {
1253 if (!(c = new(char, l)))
1256 if ((n = readlink(p, c, l-1)) < 0) {
1262 if ((size_t) n < l-1) {
1273 int readlink_and_make_absolute(const char *p, char **r) {
1280 if ((j = readlink_malloc(p, &target)) < 0)
1283 k = file_in_same_dir(p, target);
1293 int readlink_and_canonicalize(const char *p, char **r) {
1300 j = readlink_and_make_absolute(p, &t);
1304 s = canonicalize_file_name(t);
1311 path_kill_slashes(*r);
1316 int parent_of_path(const char *path, char **_r) {
1317 const char *e, *a = NULL, *b = NULL, *p;
1327 for (e = path; *e; e++) {
1329 if (!slash && *e == '/') {
1333 } else if (slash && *e != '/')
1348 r = strndup(path, p-path);
1358 char *file_name_from_path(const char *p) {
1363 if ((r = strrchr(p, '/')))
1369 bool path_is_absolute(const char *p) {
1375 bool is_path(const char *p) {
1377 return !!strchr(p, '/');
1380 char *path_make_absolute(const char *p, const char *prefix) {
1383 /* Makes every item in the list an absolute path by prepending
1384 * the prefix, if specified and necessary */
1386 if (path_is_absolute(p) || !prefix)
1389 return join(prefix, "/", p, NULL);
1392 char *path_make_absolute_cwd(const char *p) {
1397 /* Similar to path_make_absolute(), but prefixes with the
1398 * current working directory. */
1400 if (path_is_absolute(p))
1403 if (!(cwd = get_current_dir_name()))
1406 r = path_make_absolute(p, cwd);
1412 char **strv_path_make_absolute_cwd(char **l) {
1415 /* Goes through every item in the string list and makes it
1416 * absolute. This works in place and won't rollback any
1417 * changes on failure. */
1419 STRV_FOREACH(s, l) {
1422 if (!(t = path_make_absolute_cwd(*s)))
1432 char **strv_path_canonicalize(char **l) {
1435 bool enomem = false;
1437 if (strv_isempty(l))
1440 /* Goes through every item in the string list and canonicalize
1441 * the path. This works in place and won't rollback any
1442 * changes on failure. */
1444 STRV_FOREACH(s, l) {
1447 t = path_make_absolute_cwd(*s);
1456 u = canonicalize_file_name(t);
1460 if (errno == ENOMEM || !errno)
1477 char **strv_path_remove_empty(char **l) {
1483 for (f = t = l; *f; f++) {
1485 if (dir_is_empty(*f) > 0) {
1497 int reset_all_signal_handlers(void) {
1500 for (sig = 1; sig < _NSIG; sig++) {
1501 struct sigaction sa;
1503 if (sig == SIGKILL || sig == SIGSTOP)
1507 sa.sa_handler = SIG_DFL;
1508 sa.sa_flags = SA_RESTART;
1510 /* On Linux the first two RT signals are reserved by
1511 * glibc, and sigaction() will return EINVAL for them. */
1512 if ((sigaction(sig, &sa, NULL) < 0))
1513 if (errno != EINVAL)
1520 char *strstrip(char *s) {
1523 /* Drops trailing whitespace. Modifies the string in
1524 * place. Returns pointer to first non-space character */
1526 s += strspn(s, WHITESPACE);
1528 for (e = strchr(s, 0); e > s; e --)
1529 if (!strchr(WHITESPACE, e[-1]))
1537 char *delete_chars(char *s, const char *bad) {
1540 /* Drops all whitespace, regardless where in the string */
1542 for (f = s, t = s; *f; f++) {
1543 if (strchr(bad, *f))
1554 bool in_charset(const char *s, const char* charset) {
1560 for (i = s; *i; i++)
1561 if (!strchr(charset, *i))
1567 char *file_in_same_dir(const char *path, const char *filename) {
1574 /* This removes the last component of path and appends
1575 * filename, unless the latter is absolute anyway or the
1578 if (path_is_absolute(filename))
1579 return strdup(filename);
1581 if (!(e = strrchr(path, '/')))
1582 return strdup(filename);
1584 k = strlen(filename);
1585 if (!(r = new(char, e-path+1+k+1)))
1588 memcpy(r, path, e-path+1);
1589 memcpy(r+(e-path)+1, filename, k+1);
1594 int rmdir_parents(const char *path, const char *stop) {
1603 /* Skip trailing slashes */
1604 while (l > 0 && path[l-1] == '/')
1610 /* Skip last component */
1611 while (l > 0 && path[l-1] != '/')
1614 /* Skip trailing slashes */
1615 while (l > 0 && path[l-1] == '/')
1621 if (!(t = strndup(path, l)))
1624 if (path_startswith(stop, t)) {
1633 if (errno != ENOENT)
1641 char hexchar(int x) {
1642 static const char table[16] = "0123456789abcdef";
1644 return table[x & 15];
1647 int unhexchar(char c) {
1649 if (c >= '0' && c <= '9')
1652 if (c >= 'a' && c <= 'f')
1653 return c - 'a' + 10;
1655 if (c >= 'A' && c <= 'F')
1656 return c - 'A' + 10;
1661 char octchar(int x) {
1662 return '0' + (x & 7);
1665 int unoctchar(char c) {
1667 if (c >= '0' && c <= '7')
1673 char decchar(int x) {
1674 return '0' + (x % 10);
1677 int undecchar(char c) {
1679 if (c >= '0' && c <= '9')
1685 char *cescape(const char *s) {
1691 /* Does C style string escaping. */
1693 r = new(char, strlen(s)*4 + 1);
1697 for (f = s, t = r; *f; f++)
1743 /* For special chars we prefer octal over
1744 * hexadecimal encoding, simply because glib's
1745 * g_strescape() does the same */
1746 if ((*f < ' ') || (*f >= 127)) {
1748 *(t++) = octchar((unsigned char) *f >> 6);
1749 *(t++) = octchar((unsigned char) *f >> 3);
1750 *(t++) = octchar((unsigned char) *f);
1761 char *cunescape_length(const char *s, size_t length) {
1767 /* Undoes C style string escaping */
1769 r = new(char, length+1);
1773 for (f = s, t = r; f < s + length; f++) {
1816 /* This is an extension of the XDG syntax files */
1821 /* hexadecimal encoding */
1824 a = unhexchar(f[1]);
1825 b = unhexchar(f[2]);
1827 if (a < 0 || b < 0) {
1828 /* Invalid escape code, let's take it literal then */
1832 *(t++) = (char) ((a << 4) | b);
1847 /* octal encoding */
1850 a = unoctchar(f[0]);
1851 b = unoctchar(f[1]);
1852 c = unoctchar(f[2]);
1854 if (a < 0 || b < 0 || c < 0) {
1855 /* Invalid escape code, let's take it literal then */
1859 *(t++) = (char) ((a << 6) | (b << 3) | c);
1867 /* premature end of string.*/
1872 /* Invalid escape code, let's take it literal then */
1884 char *cunescape(const char *s) {
1885 return cunescape_length(s, strlen(s));
1888 char *xescape(const char *s, const char *bad) {
1892 /* Escapes all chars in bad, in addition to \ and all special
1893 * chars, in \xFF style escaping. May be reversed with
1896 if (!(r = new(char, strlen(s)*4+1)))
1899 for (f = s, t = r; *f; f++) {
1901 if ((*f < ' ') || (*f >= 127) ||
1902 (*f == '\\') || strchr(bad, *f)) {
1905 *(t++) = hexchar(*f >> 4);
1906 *(t++) = hexchar(*f);
1916 char *bus_path_escape(const char *s) {
1922 /* Escapes all chars that D-Bus' object path cannot deal
1923 * with. Can be reverse with bus_path_unescape() */
1925 if (!(r = new(char, strlen(s)*3+1)))
1928 for (f = s, t = r; *f; f++) {
1930 if (!(*f >= 'A' && *f <= 'Z') &&
1931 !(*f >= 'a' && *f <= 'z') &&
1932 !(*f >= '0' && *f <= '9')) {
1934 *(t++) = hexchar(*f >> 4);
1935 *(t++) = hexchar(*f);
1945 char *bus_path_unescape(const char *f) {
1950 if (!(r = strdup(f)))
1953 for (t = r; *f; f++) {
1958 if ((a = unhexchar(f[1])) < 0 ||
1959 (b = unhexchar(f[2])) < 0) {
1960 /* Invalid escape code, let's take it literal then */
1963 *(t++) = (char) ((a << 4) | b);
1975 char *path_kill_slashes(char *path) {
1979 /* Removes redundant inner and trailing slashes. Modifies the
1980 * passed string in-place.
1982 * ///foo///bar/ becomes /foo/bar
1985 for (f = path, t = path; *f; f++) {
2000 /* Special rule, if we are talking of the root directory, a
2001 trailing slash is good */
2003 if (t == path && slash)
2010 bool path_startswith(const char *path, const char *prefix) {
2014 if ((path[0] == '/') != (prefix[0] == '/'))
2020 path += strspn(path, "/");
2021 prefix += strspn(prefix, "/");
2029 a = strcspn(path, "/");
2030 b = strcspn(prefix, "/");
2035 if (memcmp(path, prefix, a) != 0)
2043 bool path_equal(const char *a, const char *b) {
2047 if ((a[0] == '/') != (b[0] == '/'))
2053 a += strspn(a, "/");
2054 b += strspn(b, "/");
2056 if (*a == 0 && *b == 0)
2059 if (*a == 0 || *b == 0)
2062 j = strcspn(a, "/");
2063 k = strcspn(b, "/");
2068 if (memcmp(a, b, j) != 0)
2076 char *ascii_strlower(char *t) {
2081 for (p = t; *p; p++)
2082 if (*p >= 'A' && *p <= 'Z')
2083 *p = *p - 'A' + 'a';
2088 bool ignore_file(const char *filename) {
2092 filename[0] == '.' ||
2093 streq(filename, "lost+found") ||
2094 streq(filename, "aquota.user") ||
2095 streq(filename, "aquota.group") ||
2096 endswith(filename, "~") ||
2097 endswith(filename, ".rpmnew") ||
2098 endswith(filename, ".rpmsave") ||
2099 endswith(filename, ".rpmorig") ||
2100 endswith(filename, ".dpkg-old") ||
2101 endswith(filename, ".dpkg-new") ||
2102 endswith(filename, ".swp");
2105 int fd_nonblock(int fd, bool nonblock) {
2110 if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
2114 flags |= O_NONBLOCK;
2116 flags &= ~O_NONBLOCK;
2118 if (fcntl(fd, F_SETFL, flags) < 0)
2124 int fd_cloexec(int fd, bool cloexec) {
2129 if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
2133 flags |= FD_CLOEXEC;
2135 flags &= ~FD_CLOEXEC;
2137 if (fcntl(fd, F_SETFD, flags) < 0)
2143 static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
2146 assert(n_fdset == 0 || fdset);
2148 for (i = 0; i < n_fdset; i++)
2155 int close_all_fds(const int except[], unsigned n_except) {
2160 assert(n_except == 0 || except);
2162 d = opendir("/proc/self/fd");
2167 /* When /proc isn't available (for example in chroots)
2168 * the fallback is brute forcing through the fd
2171 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
2172 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
2174 if (fd_in_set(fd, except, n_except))
2177 if (close_nointr(fd) < 0)
2178 if (errno != EBADF && r == 0)
2185 while ((de = readdir(d))) {
2188 if (ignore_file(de->d_name))
2191 if (safe_atoi(de->d_name, &fd) < 0)
2192 /* Let's better ignore this, just in case */
2201 if (fd_in_set(fd, except, n_except))
2204 if (close_nointr(fd) < 0) {
2205 /* Valgrind has its own FD and doesn't want to have it closed */
2206 if (errno != EBADF && r == 0)
2215 bool chars_intersect(const char *a, const char *b) {
2218 /* Returns true if any of the chars in a are in b. */
2219 for (p = a; *p; p++)
2226 char *format_timestamp(char *buf, size_t l, usec_t t) {
2236 sec = (time_t) (t / USEC_PER_SEC);
2238 if (strftime(buf, l, "%a, %d %b %Y %H:%M:%S %z", localtime_r(&sec, &tm)) <= 0)
2244 char *format_timestamp_pretty(char *buf, size_t l, usec_t t) {
2247 n = now(CLOCK_REALTIME);
2249 if (t <= 0 || t > n || t + USEC_PER_DAY*7 <= t)
2254 if (d >= USEC_PER_YEAR)
2255 snprintf(buf, l, "%llu years and %llu months ago",
2256 (unsigned long long) (d / USEC_PER_YEAR),
2257 (unsigned long long) ((d % USEC_PER_YEAR) / USEC_PER_MONTH));
2258 else if (d >= USEC_PER_MONTH)
2259 snprintf(buf, l, "%llu months and %llu days ago",
2260 (unsigned long long) (d / USEC_PER_MONTH),
2261 (unsigned long long) ((d % USEC_PER_MONTH) / USEC_PER_DAY));
2262 else if (d >= USEC_PER_WEEK)
2263 snprintf(buf, l, "%llu weeks and %llu days ago",
2264 (unsigned long long) (d / USEC_PER_WEEK),
2265 (unsigned long long) ((d % USEC_PER_WEEK) / USEC_PER_DAY));
2266 else if (d >= 2*USEC_PER_DAY)
2267 snprintf(buf, l, "%llu days ago", (unsigned long long) (d / USEC_PER_DAY));
2268 else if (d >= 25*USEC_PER_HOUR)
2269 snprintf(buf, l, "1 day and %lluh ago",
2270 (unsigned long long) ((d - USEC_PER_DAY) / USEC_PER_HOUR));
2271 else if (d >= 6*USEC_PER_HOUR)
2272 snprintf(buf, l, "%lluh ago",
2273 (unsigned long long) (d / USEC_PER_HOUR));
2274 else if (d >= USEC_PER_HOUR)
2275 snprintf(buf, l, "%lluh %llumin ago",
2276 (unsigned long long) (d / USEC_PER_HOUR),
2277 (unsigned long long) ((d % USEC_PER_HOUR) / USEC_PER_MINUTE));
2278 else if (d >= 5*USEC_PER_MINUTE)
2279 snprintf(buf, l, "%llumin ago",
2280 (unsigned long long) (d / USEC_PER_MINUTE));
2281 else if (d >= USEC_PER_MINUTE)
2282 snprintf(buf, l, "%llumin %llus ago",
2283 (unsigned long long) (d / USEC_PER_MINUTE),
2284 (unsigned long long) ((d % USEC_PER_MINUTE) / USEC_PER_SEC));
2285 else if (d >= USEC_PER_SEC)
2286 snprintf(buf, l, "%llus ago",
2287 (unsigned long long) (d / USEC_PER_SEC));
2288 else if (d >= USEC_PER_MSEC)
2289 snprintf(buf, l, "%llums ago",
2290 (unsigned long long) (d / USEC_PER_MSEC));
2292 snprintf(buf, l, "%lluus ago",
2293 (unsigned long long) d);
2295 snprintf(buf, l, "now");
2301 char *format_timespan(char *buf, size_t l, usec_t t) {
2302 static const struct {
2306 { "w", USEC_PER_WEEK },
2307 { "d", USEC_PER_DAY },
2308 { "h", USEC_PER_HOUR },
2309 { "min", USEC_PER_MINUTE },
2310 { "s", USEC_PER_SEC },
2311 { "ms", USEC_PER_MSEC },
2321 if (t == (usec_t) -1)
2325 snprintf(p, l, "0");
2330 /* The result of this function can be parsed with parse_usec */
2332 for (i = 0; i < ELEMENTSOF(table); i++) {
2336 if (t < table[i].usec)
2342 k = snprintf(p, l, "%s%llu%s", p > buf ? " " : "", (unsigned long long) (t / table[i].usec), table[i].suffix);
2343 n = MIN((size_t) k, l);
2356 bool fstype_is_network(const char *fstype) {
2357 static const char * const table[] = {
2369 for (i = 0; i < ELEMENTSOF(table); i++)
2370 if (streq(table[i], fstype))
2379 if ((fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC)) < 0)
2384 TIOCL_GETKMSGREDIRECT,
2388 if (ioctl(fd, TIOCLINUX, tiocl) < 0) {
2393 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
2396 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
2400 close_nointr_nofail(fd);
2404 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
2405 struct termios old_termios, new_termios;
2407 char line[LINE_MAX];
2412 if (tcgetattr(fileno(f), &old_termios) >= 0) {
2413 new_termios = old_termios;
2415 new_termios.c_lflag &= ~ICANON;
2416 new_termios.c_cc[VMIN] = 1;
2417 new_termios.c_cc[VTIME] = 0;
2419 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
2422 if (t != (usec_t) -1) {
2423 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
2424 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
2429 k = fread(&c, 1, 1, f);
2431 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
2437 *need_nl = c != '\n';
2444 if (t != (usec_t) -1)
2445 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
2448 if (!fgets(line, sizeof(line), f))
2453 if (strlen(line) != 1)
2463 int ask(char *ret, const char *replies, const char *text, ...) {
2470 on_tty = isatty(STDOUT_FILENO);
2476 bool need_nl = true;
2479 fputs(ANSI_HIGHLIGHT_ON, stdout);
2486 fputs(ANSI_HIGHLIGHT_OFF, stdout);
2490 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
2493 if (r == -EBADMSG) {
2494 puts("Bad input, please try again.");
2505 if (strchr(replies, c)) {
2510 puts("Read unexpected character, please try again.");
2514 int reset_terminal_fd(int fd, bool switch_to_text) {
2515 struct termios termios;
2518 /* Set terminal to some sane defaults */
2522 /* We leave locked terminal attributes untouched, so that
2523 * Plymouth may set whatever it wants to set, and we don't
2524 * interfere with that. */
2526 /* Disable exclusive mode, just in case */
2527 ioctl(fd, TIOCNXCL);
2529 /* Switch to text mode */
2531 ioctl(fd, KDSETMODE, KD_TEXT);
2533 /* Enable console unicode mode */
2534 ioctl(fd, KDSKBMODE, K_UNICODE);
2536 if (tcgetattr(fd, &termios) < 0) {
2541 /* We only reset the stuff that matters to the software. How
2542 * hardware is set up we don't touch assuming that somebody
2543 * else will do that for us */
2545 termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
2546 termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
2547 termios.c_oflag |= ONLCR;
2548 termios.c_cflag |= CREAD;
2549 termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
2551 termios.c_cc[VINTR] = 03; /* ^C */
2552 termios.c_cc[VQUIT] = 034; /* ^\ */
2553 termios.c_cc[VERASE] = 0177;
2554 termios.c_cc[VKILL] = 025; /* ^X */
2555 termios.c_cc[VEOF] = 04; /* ^D */
2556 termios.c_cc[VSTART] = 021; /* ^Q */
2557 termios.c_cc[VSTOP] = 023; /* ^S */
2558 termios.c_cc[VSUSP] = 032; /* ^Z */
2559 termios.c_cc[VLNEXT] = 026; /* ^V */
2560 termios.c_cc[VWERASE] = 027; /* ^W */
2561 termios.c_cc[VREPRINT] = 022; /* ^R */
2562 termios.c_cc[VEOL] = 0;
2563 termios.c_cc[VEOL2] = 0;
2565 termios.c_cc[VTIME] = 0;
2566 termios.c_cc[VMIN] = 1;
2568 if (tcsetattr(fd, TCSANOW, &termios) < 0)
2572 /* Just in case, flush all crap out */
2573 tcflush(fd, TCIOFLUSH);
2578 int reset_terminal(const char *name) {
2581 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2585 r = reset_terminal_fd(fd, true);
2586 close_nointr_nofail(fd);
2591 int open_terminal(const char *name, int mode) {
2596 * If a TTY is in the process of being closed opening it might
2597 * cause EIO. This is horribly awful, but unlikely to be
2598 * changed in the kernel. Hence we work around this problem by
2599 * retrying a couple of times.
2601 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
2605 if ((fd = open(name, mode)) >= 0)
2614 usleep(50 * USEC_PER_MSEC);
2621 if ((r = isatty(fd)) < 0) {
2622 close_nointr_nofail(fd);
2627 close_nointr_nofail(fd);
2634 int flush_fd(int fd) {
2635 struct pollfd pollfd;
2639 pollfd.events = POLLIN;
2646 if ((r = poll(&pollfd, 1, 0)) < 0) {
2657 if ((l = read(fd, buf, sizeof(buf))) < 0) {
2662 if (errno == EAGAIN)
2673 int acquire_terminal(const char *name, bool fail, bool force, bool ignore_tiocstty_eperm) {
2674 int fd = -1, notify = -1, r, wd = -1;
2678 /* We use inotify to be notified when the tty is closed. We
2679 * create the watch before checking if we can actually acquire
2680 * it, so that we don't lose any event.
2682 * Note: strictly speaking this actually watches for the
2683 * device being closed, it does *not* really watch whether a
2684 * tty loses its controlling process. However, unless some
2685 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2686 * its tty otherwise this will not become a problem. As long
2687 * as the administrator makes sure not configure any service
2688 * on the same tty as an untrusted user this should not be a
2689 * problem. (Which he probably should not do anyway.) */
2691 if (!fail && !force) {
2692 if ((notify = inotify_init1(IN_CLOEXEC)) < 0) {
2697 if ((wd = inotify_add_watch(notify, name, IN_CLOSE)) < 0) {
2705 if ((r = flush_fd(notify)) < 0)
2708 /* We pass here O_NOCTTY only so that we can check the return
2709 * value TIOCSCTTY and have a reliable way to figure out if we
2710 * successfully became the controlling process of the tty */
2711 if ((fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC)) < 0)
2714 /* First, try to get the tty */
2715 r = ioctl(fd, TIOCSCTTY, force);
2717 /* Sometimes it makes sense to ignore TIOCSCTTY
2718 * returning EPERM, i.e. when very likely we already
2719 * are have this controlling terminal. */
2720 if (r < 0 && errno == EPERM && ignore_tiocstty_eperm)
2723 if (r < 0 && (force || fail || errno != EPERM)) {
2733 assert(notify >= 0);
2736 uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
2738 struct inotify_event *e;
2740 if ((l = read(notify, inotify_buffer, sizeof(inotify_buffer))) < 0) {
2749 e = (struct inotify_event*) inotify_buffer;
2754 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2759 step = sizeof(struct inotify_event) + e->len;
2760 assert(step <= (size_t) l);
2762 e = (struct inotify_event*) ((uint8_t*) e + step);
2769 /* We close the tty fd here since if the old session
2770 * ended our handle will be dead. It's important that
2771 * we do this after sleeping, so that we don't enter
2772 * an endless loop. */
2773 close_nointr_nofail(fd);
2777 close_nointr_nofail(notify);
2779 r = reset_terminal_fd(fd, true);
2781 log_warning("Failed to reset terminal: %s", strerror(-r));
2787 close_nointr_nofail(fd);
2790 close_nointr_nofail(notify);
2795 int release_terminal(void) {
2797 struct sigaction sa_old, sa_new;
2799 if ((fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC)) < 0)
2802 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2803 * by our own TIOCNOTTY */
2806 sa_new.sa_handler = SIG_IGN;
2807 sa_new.sa_flags = SA_RESTART;
2808 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2810 if (ioctl(fd, TIOCNOTTY) < 0)
2813 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2815 close_nointr_nofail(fd);
2819 int sigaction_many(const struct sigaction *sa, ...) {
2824 while ((sig = va_arg(ap, int)) > 0)
2825 if (sigaction(sig, sa, NULL) < 0)
2832 int ignore_signals(int sig, ...) {
2833 struct sigaction sa;
2838 sa.sa_handler = SIG_IGN;
2839 sa.sa_flags = SA_RESTART;
2841 if (sigaction(sig, &sa, NULL) < 0)
2845 while ((sig = va_arg(ap, int)) > 0)
2846 if (sigaction(sig, &sa, NULL) < 0)
2853 int default_signals(int sig, ...) {
2854 struct sigaction sa;
2859 sa.sa_handler = SIG_DFL;
2860 sa.sa_flags = SA_RESTART;
2862 if (sigaction(sig, &sa, NULL) < 0)
2866 while ((sig = va_arg(ap, int)) > 0)
2867 if (sigaction(sig, &sa, NULL) < 0)
2874 int close_pipe(int p[]) {
2880 a = close_nointr(p[0]);
2885 b = close_nointr(p[1]);
2889 return a < 0 ? a : b;
2892 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2901 while (nbytes > 0) {
2904 if ((k = read(fd, p, nbytes)) <= 0) {
2906 if (k < 0 && errno == EINTR)
2909 if (k < 0 && errno == EAGAIN && do_poll) {
2910 struct pollfd pollfd;
2914 pollfd.events = POLLIN;
2916 if (poll(&pollfd, 1, -1) < 0) {
2920 return n > 0 ? n : -errno;
2923 if (pollfd.revents != POLLIN)
2924 return n > 0 ? n : -EIO;
2929 return n > 0 ? n : (k < 0 ? -errno : 0);
2940 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2949 while (nbytes > 0) {
2952 k = write(fd, p, nbytes);
2955 if (k < 0 && errno == EINTR)
2958 if (k < 0 && errno == EAGAIN && do_poll) {
2959 struct pollfd pollfd;
2963 pollfd.events = POLLOUT;
2965 if (poll(&pollfd, 1, -1) < 0) {
2969 return n > 0 ? n : -errno;
2972 if (pollfd.revents != POLLOUT)
2973 return n > 0 ? n : -EIO;
2978 return n > 0 ? n : (k < 0 ? -errno : 0);
2989 int path_is_mount_point(const char *t, bool allow_symlink) {
3000 if (errno == ENOENT)
3006 r = parent_of_path(t, &parent);
3010 r = lstat(parent, &b);
3016 return a.st_dev != b.st_dev;
3019 int parse_usec(const char *t, usec_t *usec) {
3020 static const struct {
3024 { "sec", USEC_PER_SEC },
3025 { "s", USEC_PER_SEC },
3026 { "min", USEC_PER_MINUTE },
3027 { "hr", USEC_PER_HOUR },
3028 { "h", USEC_PER_HOUR },
3029 { "d", USEC_PER_DAY },
3030 { "w", USEC_PER_WEEK },
3031 { "msec", USEC_PER_MSEC },
3032 { "ms", USEC_PER_MSEC },
3033 { "m", USEC_PER_MINUTE },
3036 { "", USEC_PER_SEC },
3052 l = strtoll(p, &e, 10);
3063 e += strspn(e, WHITESPACE);
3065 for (i = 0; i < ELEMENTSOF(table); i++)
3066 if (startswith(e, table[i].suffix)) {
3067 r += (usec_t) l * table[i].usec;
3068 p = e + strlen(table[i].suffix);
3072 if (i >= ELEMENTSOF(table))
3082 int parse_bytes(const char *t, off_t *bytes) {
3083 static const struct {
3089 { "M", 1024ULL*1024ULL },
3090 { "G", 1024ULL*1024ULL*1024ULL },
3091 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
3092 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3093 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3110 l = strtoll(p, &e, 10);
3121 e += strspn(e, WHITESPACE);
3123 for (i = 0; i < ELEMENTSOF(table); i++)
3124 if (startswith(e, table[i].suffix)) {
3125 r += (off_t) l * table[i].factor;
3126 p = e + strlen(table[i].suffix);
3130 if (i >= ELEMENTSOF(table))
3140 int make_stdio(int fd) {
3145 r = dup2(fd, STDIN_FILENO);
3146 s = dup2(fd, STDOUT_FILENO);
3147 t = dup2(fd, STDERR_FILENO);
3150 close_nointr_nofail(fd);
3152 if (r < 0 || s < 0 || t < 0)
3155 fd_cloexec(STDIN_FILENO, false);
3156 fd_cloexec(STDOUT_FILENO, false);
3157 fd_cloexec(STDERR_FILENO, false);
3162 int make_null_stdio(void) {
3165 if ((null_fd = open("/dev/null", O_RDWR|O_NOCTTY)) < 0)
3168 return make_stdio(null_fd);
3171 bool is_device_path(const char *path) {
3173 /* Returns true on paths that refer to a device, either in
3174 * sysfs or in /dev */
3177 path_startswith(path, "/dev/") ||
3178 path_startswith(path, "/sys/");
3181 int dir_is_empty(const char *path) {
3184 struct dirent buf, *de;
3186 if (!(d = opendir(path)))
3190 if ((r = readdir_r(d, &buf, &de)) > 0) {
3200 if (!ignore_file(de->d_name)) {
3210 unsigned long long random_ull(void) {
3215 if ((fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY)) < 0)
3218 r = loop_read(fd, &ull, sizeof(ull), true);
3219 close_nointr_nofail(fd);
3221 if (r != sizeof(ull))
3227 return random() * RAND_MAX + random();
3230 void rename_process(const char name[8]) {
3233 /* This is a like a poor man's setproctitle(). It changes the
3234 * comm field, argv[0], and also the glibc's internally used
3235 * name of the process. For the first one a limit of 16 chars
3236 * applies, to the second one usually one of 10 (i.e. length
3237 * of "/sbin/init"), to the third one one of 7 (i.e. length of
3238 * "systemd"). If you pass a longer string it will be
3241 prctl(PR_SET_NAME, name);
3243 if (program_invocation_name)
3244 strncpy(program_invocation_name, name, strlen(program_invocation_name));
3246 if (saved_argc > 0) {
3250 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
3252 for (i = 1; i < saved_argc; i++) {
3256 memset(saved_argv[i], 0, strlen(saved_argv[i]));
3261 void sigset_add_many(sigset_t *ss, ...) {
3268 while ((sig = va_arg(ap, int)) > 0)
3269 assert_se(sigaddset(ss, sig) == 0);
3273 char* gethostname_malloc(void) {
3276 assert_se(uname(&u) >= 0);
3279 return strdup(u.nodename);
3281 return strdup(u.sysname);
3284 char* getlogname_malloc(void) {
3288 struct passwd pwbuf, *pw = NULL;
3291 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
3296 /* Shortcut things to avoid NSS lookups */
3298 return strdup("root");
3300 if ((bufsize = sysconf(_SC_GETPW_R_SIZE_MAX)) <= 0)
3303 if (!(buf = malloc(bufsize)))
3306 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw) {
3307 name = strdup(pw->pw_name);
3314 if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
3320 int getttyname_malloc(int fd, char **r) {
3321 char path[PATH_MAX], *c;
3326 if ((k = ttyname_r(fd, path, sizeof(path))) != 0)
3331 if (!(c = strdup(startswith(path, "/dev/") ? path + 5 : path)))
3338 int getttyname_harder(int fd, char **r) {
3342 if ((k = getttyname_malloc(fd, &s)) < 0)
3345 if (streq(s, "tty")) {
3347 return get_ctty(0, NULL, r);
3354 int get_ctty_devnr(pid_t pid, dev_t *d) {
3356 char line[LINE_MAX], *p, *fn;
3357 unsigned long ttynr;
3360 if (asprintf(&fn, "/proc/%lu/stat", (unsigned long) (pid <= 0 ? getpid() : pid)) < 0)
3363 f = fopen(fn, "re");
3368 if (!fgets(line, sizeof(line), f)) {
3369 k = feof(f) ? -EIO : -errno;
3376 p = strrchr(line, ')');
3386 "%*d " /* session */
3395 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
3397 char fn[PATH_MAX], *s, *b, *p;
3402 k = get_ctty_devnr(pid, &devnr);
3406 snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
3409 if ((k = readlink_malloc(fn, &s)) < 0) {
3414 /* This is an ugly hack */
3415 if (major(devnr) == 136) {
3416 if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
3426 /* Probably something like the ptys which have no
3427 * symlink in /dev/char. Let's return something
3428 * vaguely useful. */
3430 if (!(b = strdup(fn + 5)))
3440 if (startswith(s, "/dev/"))
3442 else if (startswith(s, "../"))
3460 static int rm_rf_children(int fd, bool only_dirs, bool honour_sticky) {
3466 /* This returns the first error we run into, but nevertheless
3469 if (!(d = fdopendir(fd))) {
3470 close_nointr_nofail(fd);
3472 return errno == ENOENT ? 0 : -errno;
3476 struct dirent buf, *de;
3477 bool is_dir, keep_around = false;
3480 if ((r = readdir_r(d, &buf, &de)) != 0) {
3489 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
3492 if (de->d_type == DT_UNKNOWN) {
3495 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3496 if (ret == 0 && errno != ENOENT)
3503 (st.st_uid == 0 || st.st_uid == getuid()) &&
3504 (st.st_mode & S_ISVTX);
3506 is_dir = S_ISDIR(st.st_mode);
3509 if (honour_sticky) {
3512 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3513 if (ret == 0 && errno != ENOENT)
3519 (st.st_uid == 0 || st.st_uid == getuid()) &&
3520 (st.st_mode & S_ISVTX);
3523 is_dir = de->d_type == DT_DIR;
3529 subdir_fd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
3530 if (subdir_fd < 0) {
3531 if (ret == 0 && errno != ENOENT)
3536 if ((r = rm_rf_children(subdir_fd, only_dirs, honour_sticky)) < 0) {
3542 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3543 if (ret == 0 && errno != ENOENT)
3547 } else if (!only_dirs && !keep_around) {
3549 if (unlinkat(fd, de->d_name, 0) < 0) {
3550 if (ret == 0 && errno != ENOENT)
3561 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3567 if ((fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC)) < 0) {
3569 if (errno != ENOTDIR)
3572 if (delete_root && !only_dirs)
3573 if (unlink(path) < 0)
3579 r = rm_rf_children(fd, only_dirs, honour_sticky);
3583 if (honour_sticky && file_is_priv_sticky(path) > 0)
3586 if (rmdir(path) < 0 && errno != ENOENT) {
3595 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3598 /* Under the assumption that we are running privileged we
3599 * first change the access mode and only then hand out
3600 * ownership to avoid a window where access is too open. */
3602 if (mode != (mode_t) -1)
3603 if (chmod(path, mode) < 0)
3606 if (uid != (uid_t) -1 || gid != (gid_t) -1)
3607 if (chown(path, uid, gid) < 0)
3613 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3616 /* Under the assumption that we are running privileged we
3617 * first change the access mode and only then hand out
3618 * ownership to avoid a window where access is too open. */
3620 if (fchmod(fd, mode) < 0)
3623 if (fchown(fd, uid, gid) < 0)
3629 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3633 /* Allocates the cpuset in the right size */
3636 if (!(r = CPU_ALLOC(n)))
3639 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3640 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3650 if (errno != EINVAL)
3657 void status_vprintf(const char *status, bool ellipse, const char *format, va_list ap) {
3658 char *s = NULL, *spaces = NULL, *e;
3660 size_t emax, sl, left;
3661 struct iovec iovec[5];
3666 /* This independent of logging, as status messages are
3667 * optional and go exclusively to the console. */
3669 if (vasprintf(&s, format, ap) < 0)
3672 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3682 sl = 2 + 6 + 1; /* " [" status "]" */
3683 emax = (size_t) c > sl ? c - sl - 1 : 0;
3687 e = ellipsize(s, emax, 75);
3695 IOVEC_SET_STRING(iovec[n++], s);
3699 left = emax > sl ? emax - sl : 0;
3701 spaces = malloc(left);
3703 memset(spaces, ' ', left);
3704 iovec[n].iov_base = spaces;
3705 iovec[n].iov_len = left;
3712 IOVEC_SET_STRING(iovec[n++], " [");
3713 IOVEC_SET_STRING(iovec[n++], status);
3714 IOVEC_SET_STRING(iovec[n++], "]\n");
3716 IOVEC_SET_STRING(iovec[n++], "\n");
3718 writev(fd, iovec, n);
3725 close_nointr_nofail(fd);
3728 void status_printf(const char *status, bool ellipse, const char *format, ...) {
3733 va_start(ap, format);
3734 status_vprintf(status, ellipse, format, ap);
3738 void status_welcome(void) {
3739 char *pretty_name = NULL, *ansi_color = NULL;
3740 const char *const_pretty = NULL, *const_color = NULL;
3743 if ((r = parse_env_file("/etc/os-release", NEWLINE,
3744 "PRETTY_NAME", &pretty_name,
3745 "ANSI_COLOR", &ansi_color,
3749 log_warning("Failed to read /etc/os-release: %s", strerror(-r));
3752 if (!pretty_name && !const_pretty)
3753 const_pretty = "Linux";
3755 if (!ansi_color && !const_color)
3760 "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
3761 const_color ? const_color : ansi_color,
3762 const_pretty ? const_pretty : pretty_name);
3768 char *replace_env(const char *format, char **env) {
3775 const char *e, *word = format;
3780 for (e = format; *e; e ++) {
3791 if (!(k = strnappend(r, word, e-word-1)))
3800 } else if (*e == '$') {
3801 if (!(k = strnappend(r, word, e-word)))
3817 if (!(t = strv_env_get_with_length(env, word+2, e-word-2)))
3820 if (!(k = strappend(r, t)))
3833 if (!(k = strnappend(r, word, e-word)))
3844 char **replace_env_argv(char **argv, char **env) {
3846 unsigned k = 0, l = 0;
3848 l = strv_length(argv);
3850 if (!(r = new(char*, l+1)))
3853 STRV_FOREACH(i, argv) {
3855 /* If $FOO appears as single word, replace it by the split up variable */
3856 if ((*i)[0] == '$' && (*i)[1] != '{') {
3861 if ((e = strv_env_get(env, *i+1))) {
3863 if (!(m = strv_split_quoted(e))) {
3874 if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3883 memcpy(r + k, m, q * sizeof(char*));
3891 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3892 if (!(r[k++] = replace_env(*i, env))) {
3902 int fd_columns(int fd) {
3906 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3915 unsigned columns(void) {
3916 static __thread int parsed_columns = 0;
3919 if (_likely_(parsed_columns > 0))
3920 return parsed_columns;
3922 e = getenv("COLUMNS");
3924 parsed_columns = atoi(e);
3926 if (parsed_columns <= 0)
3927 parsed_columns = fd_columns(STDOUT_FILENO);
3929 if (parsed_columns <= 0)
3930 parsed_columns = 80;
3932 return parsed_columns;
3935 int fd_lines(int fd) {
3939 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3948 unsigned lines(void) {
3949 static __thread int parsed_lines = 0;
3952 if (_likely_(parsed_lines > 0))
3953 return parsed_lines;
3955 e = getenv("LINES");
3957 parsed_lines = atoi(e);
3959 if (parsed_lines <= 0)
3960 parsed_lines = fd_lines(STDOUT_FILENO);
3962 if (parsed_lines <= 0)
3965 return parsed_lines;
3968 int running_in_chroot(void) {
3974 /* Only works as root */
3976 if (stat("/proc/1/root", &a) < 0)
3979 if (stat("/", &b) < 0)
3983 a.st_dev != b.st_dev ||
3984 a.st_ino != b.st_ino;
3987 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3992 assert(percent <= 100);
3993 assert(new_length >= 3);
3995 if (old_length <= 3 || old_length <= new_length)
3996 return strndup(s, old_length);
3998 r = new0(char, new_length+1);
4002 x = (new_length * percent) / 100;
4004 if (x > new_length - 3)
4012 s + old_length - (new_length - x - 3),
4013 new_length - x - 3);
4018 char *ellipsize(const char *s, size_t length, unsigned percent) {
4019 return ellipsize_mem(s, strlen(s), length, percent);
4022 int touch(const char *path) {
4027 if ((fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644)) < 0)
4030 close_nointr_nofail(fd);
4034 char *unquote(const char *s, const char* quotes) {
4042 if (strchr(quotes, s[0]) && s[l-1] == s[0])
4043 return strndup(s+1, l-2);
4048 char *normalize_env_assignment(const char *s) {
4049 char *name, *value, *p, *r;
4054 if (!(r = strdup(s)))
4060 if (!(name = strndup(s, p - s)))
4063 if (!(p = strdup(p+1))) {
4068 value = unquote(strstrip(p), QUOTES);
4076 if (asprintf(&r, "%s=%s", name, value) < 0)
4085 int wait_for_terminate(pid_t pid, siginfo_t *status) {
4096 if (waitid(P_PID, pid, status, WEXITED) < 0) {
4108 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
4115 if ((r = wait_for_terminate(pid, &status)) < 0) {
4116 log_warning("Failed to wait for %s: %s", name, strerror(-r));
4120 if (status.si_code == CLD_EXITED) {
4121 if (status.si_status != 0) {
4122 log_warning("%s failed with error code %i.", name, status.si_status);
4123 return status.si_status;
4126 log_debug("%s succeeded.", name);
4129 } else if (status.si_code == CLD_KILLED ||
4130 status.si_code == CLD_DUMPED) {
4132 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
4136 log_warning("%s failed due to unknown reason.", name);
4141 _noreturn_ void freeze(void) {
4143 /* Make sure nobody waits for us on a socket anymore */
4144 close_all_fds(NULL, 0);
4152 bool null_or_empty(struct stat *st) {
4155 if (S_ISREG(st->st_mode) && st->st_size <= 0)
4158 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
4164 int null_or_empty_path(const char *fn) {
4169 if (stat(fn, &st) < 0)
4172 return null_or_empty(&st);
4175 DIR *xopendirat(int fd, const char *name, int flags) {
4179 if ((nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags)) < 0)
4182 if (!(d = fdopendir(nfd))) {
4183 close_nointr_nofail(nfd);
4190 int signal_from_string_try_harder(const char *s) {
4194 if ((signo = signal_from_string(s)) <= 0)
4195 if (startswith(s, "SIG"))
4196 return signal_from_string(s+3);
4201 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {
4207 if (!dual_timestamp_is_set(t))
4210 fprintf(f, "%s=%llu %llu\n",
4212 (unsigned long long) t->realtime,
4213 (unsigned long long) t->monotonic);
4216 void dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
4217 unsigned long long a, b;
4222 if (sscanf(value, "%lli %llu", &a, &b) != 2)
4223 log_debug("Failed to parse finish timestamp value %s", value);
4230 char *fstab_node_to_udev_node(const char *p) {
4234 /* FIXME: to follow udev's logic 100% we need to leave valid
4235 * UTF8 chars unescaped */
4237 if (startswith(p, "LABEL=")) {
4239 if (!(u = unquote(p+6, "\"\'")))
4242 t = xescape(u, "/ ");
4248 r = asprintf(&dn, "/dev/disk/by-label/%s", t);
4257 if (startswith(p, "UUID=")) {
4259 if (!(u = unquote(p+5, "\"\'")))
4262 t = xescape(u, "/ ");
4268 r = asprintf(&dn, "/dev/disk/by-uuid/%s", t);
4280 bool tty_is_vc(const char *tty) {
4283 if (startswith(tty, "/dev/"))
4286 return vtnr_from_tty(tty) >= 0;
4289 int vtnr_from_tty(const char *tty) {
4294 if (startswith(tty, "/dev/"))
4297 if (!startswith(tty, "tty") )
4300 if (tty[3] < '0' || tty[3] > '9')
4303 r = safe_atoi(tty+3, &i);
4307 if (i < 0 || i > 63)
4313 bool tty_is_vc_resolve(const char *tty) {
4314 char *active = NULL;
4319 if (startswith(tty, "/dev/"))
4322 /* Resolve where /dev/console is pointing to */
4323 if (streq(tty, "console"))
4324 if (read_one_line_file("/sys/class/tty/console/active", &active) >= 0) {
4325 /* If multiple log outputs are configured the
4326 * last one is what /dev/console points to */
4327 tty = strrchr(active, ' ');
4340 const char *default_term_for_tty(const char *tty) {
4343 return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt100";
4346 bool dirent_is_file(const struct dirent *de) {
4349 if (ignore_file(de->d_name))
4352 if (de->d_type != DT_REG &&
4353 de->d_type != DT_LNK &&
4354 de->d_type != DT_UNKNOWN)
4360 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4363 if (!dirent_is_file(de))
4366 return endswith(de->d_name, suffix);
4369 void execute_directory(const char *directory, DIR *d, char *argv[]) {
4372 Hashmap *pids = NULL;
4376 /* Executes all binaries in a directory in parallel and waits
4377 * until all they all finished. */
4380 if (!(_d = opendir(directory))) {
4382 if (errno == ENOENT)
4385 log_error("Failed to enumerate directory %s: %m", directory);
4392 if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
4393 log_error("Failed to allocate set.");
4397 while ((de = readdir(d))) {
4402 if (!dirent_is_file(de))
4405 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
4406 log_error("Out of memory");
4410 if ((pid = fork()) < 0) {
4411 log_error("Failed to fork: %m");
4430 log_error("Failed to execute %s: %m", path);
4431 _exit(EXIT_FAILURE);
4434 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
4436 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
4437 log_error("Failed to add PID to set: %s", strerror(-k));
4442 while (!hashmap_isempty(pids)) {
4443 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
4448 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
4453 log_error("waitid() failed: %m");
4457 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
4458 if (!is_clean_exit(si.si_code, si.si_status)) {
4459 if (si.si_code == CLD_EXITED)
4460 log_error("%s exited with exit status %i.", path, si.si_status);
4462 log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
4464 log_debug("%s exited successfully.", path);
4475 hashmap_free_free(pids);
4478 int kill_and_sigcont(pid_t pid, int sig) {
4481 r = kill(pid, sig) < 0 ? -errno : 0;
4489 bool nulstr_contains(const char*nulstr, const char *needle) {
4495 NULSTR_FOREACH(i, nulstr)
4496 if (streq(i, needle))
4502 bool plymouth_running(void) {
4503 return access("/run/plymouth/pid", F_OK) >= 0;
4506 void parse_syslog_priority(char **p, int *priority) {
4507 int a = 0, b = 0, c = 0;
4517 if (!strchr(*p, '>'))
4520 if ((*p)[2] == '>') {
4521 c = undecchar((*p)[1]);
4523 } else if ((*p)[3] == '>') {
4524 b = undecchar((*p)[1]);
4525 c = undecchar((*p)[2]);
4527 } else if ((*p)[4] == '>') {
4528 a = undecchar((*p)[1]);
4529 b = undecchar((*p)[2]);
4530 c = undecchar((*p)[3]);
4535 if (a < 0 || b < 0 || c < 0)
4538 *priority = a*100+b*10+c;
4542 void skip_syslog_pid(char **buf) {
4554 p += strspn(p, "0123456789");
4564 void skip_syslog_date(char **buf) {
4572 LETTER, LETTER, LETTER,
4574 SPACE_OR_NUMBER, NUMBER,
4576 SPACE_OR_NUMBER, NUMBER,
4578 SPACE_OR_NUMBER, NUMBER,
4580 SPACE_OR_NUMBER, NUMBER,
4592 for (i = 0; i < ELEMENTSOF(sequence); i++, p++) {
4597 switch (sequence[i]) {
4604 case SPACE_OR_NUMBER:
4611 if (*p < '0' || *p > '9')
4617 if (!(*p >= 'A' && *p <= 'Z') &&
4618 !(*p >= 'a' && *p <= 'z'))
4634 char* strshorten(char *s, size_t l) {
4643 static bool hostname_valid_char(char c) {
4645 (c >= 'a' && c <= 'z') ||
4646 (c >= 'A' && c <= 'Z') ||
4647 (c >= '0' && c <= '9') ||
4653 bool hostname_is_valid(const char *s) {
4659 for (p = s; *p; p++)
4660 if (!hostname_valid_char(*p))
4663 if (p-s > HOST_NAME_MAX)
4669 char* hostname_cleanup(char *s) {
4672 for (p = s, d = s; *p; p++)
4673 if ((*p >= 'a' && *p <= 'z') ||
4674 (*p >= 'A' && *p <= 'Z') ||
4675 (*p >= '0' && *p <= '9') ||
4683 strshorten(s, HOST_NAME_MAX);
4687 int pipe_eof(int fd) {
4688 struct pollfd pollfd;
4693 pollfd.events = POLLIN|POLLHUP;
4695 r = poll(&pollfd, 1, 0);
4702 return pollfd.revents & POLLHUP;
4705 int fd_wait_for_event(int fd, int event, usec_t t) {
4706 struct pollfd pollfd;
4711 pollfd.events = event;
4713 r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
4720 return pollfd.revents;
4723 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4734 t = new(char, strlen(path) + 1 + 6 + 1);
4738 fn = file_name_from_path(path);
4742 stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
4744 fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
4750 f = fdopen(fd, "we");
4763 int terminal_vhangup_fd(int fd) {
4766 if (ioctl(fd, TIOCVHANGUP) < 0)
4772 int terminal_vhangup(const char *name) {
4775 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4779 r = terminal_vhangup_fd(fd);
4780 close_nointr_nofail(fd);
4785 int vt_disallocate(const char *name) {
4789 /* Deallocate the VT if possible. If not possible
4790 * (i.e. because it is the active one), at least clear it
4791 * entirely (including the scrollback buffer) */
4793 if (!startswith(name, "/dev/"))
4796 if (!tty_is_vc(name)) {
4797 /* So this is not a VT. I guess we cannot deallocate
4798 * it then. But let's at least clear the screen */
4800 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4805 "\033[r" /* clear scrolling region */
4806 "\033[H" /* move home */
4807 "\033[2J", /* clear screen */
4809 close_nointr_nofail(fd);
4814 if (!startswith(name, "/dev/tty"))
4817 r = safe_atou(name+8, &u);
4824 /* Try to deallocate */
4825 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4829 r = ioctl(fd, VT_DISALLOCATE, u);
4830 close_nointr_nofail(fd);
4838 /* Couldn't deallocate, so let's clear it fully with
4840 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4845 "\033[r" /* clear scrolling region */
4846 "\033[H" /* move home */
4847 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4849 close_nointr_nofail(fd);
4854 static int files_add(Hashmap *h, const char *path, const char *suffix) {
4856 struct dirent buffer, *de;
4859 dir = opendir(path);
4861 if (errno == ENOENT)
4870 k = readdir_r(dir, &buffer, &de);
4879 if (!dirent_is_file_with_suffix(de, suffix))
4882 if (asprintf(&p, "%s/%s", path, de->d_name) < 0) {
4887 f = canonicalize_file_name(p);
4889 log_error("Failed to canonicalize file name '%s': %m", p);
4895 log_debug("found: %s\n", f);
4896 if (hashmap_put(h, file_name_from_path(f), f) <= 0)
4905 static int base_cmp(const void *a, const void *b) {
4906 const char *s1, *s2;
4908 s1 = *(char * const *)a;
4909 s2 = *(char * const *)b;
4910 return strcmp(file_name_from_path(s1), file_name_from_path(s2));
4913 int conf_files_list(char ***strv, const char *suffix, const char *dir, ...) {
4916 char **files = NULL;
4922 dirs = strv_new_ap(dir, ap);
4928 if (!strv_path_canonicalize(dirs)) {
4932 if (!strv_uniq(dirs)) {
4937 fh = hashmap_new(string_hash_func, string_compare_func);
4943 STRV_FOREACH(p, dirs) {
4944 if (files_add(fh, *p, suffix) < 0) {
4945 log_error("Failed to search for files.");
4951 files = hashmap_get_strv(fh);
4952 if (files == NULL) {
4953 log_error("Failed to compose list of files.");
4958 qsort(files, hashmap_size(fh), sizeof(char *), base_cmp);
4967 int hwclock_is_localtime(void) {
4972 * The third line of adjtime is "UTC" or "LOCAL" or nothing.
4978 f = fopen("/etc/adjtime", "re");
4980 char line[LINE_MAX];
4983 b = fgets(line, sizeof(line), f) &&
4984 fgets(line, sizeof(line), f) &&
4985 fgets(line, sizeof(line), f);
4994 local = streq(line, "LOCAL");
4996 } else if (errno != -ENOENT)
5002 int hwclock_apply_localtime_delta(int *min) {
5003 const struct timeval *tv_null = NULL;
5009 assert_se(clock_gettime(CLOCK_REALTIME, &ts) == 0);
5010 assert_se(tm = localtime(&ts.tv_sec));
5011 minuteswest = tm->tm_gmtoff / 60;
5013 tz.tz_minuteswest = -minuteswest;
5014 tz.tz_dsttime = 0; /* DST_NONE*/
5017 * If the hardware clock does not run in UTC, but in local time:
5018 * The very first time we set the kernel's timezone, it will warp
5019 * the clock so that it runs in UTC instead of local time.
5021 if (settimeofday(tv_null, &tz) < 0)
5028 int hwclock_reset_localtime_delta(void) {
5029 const struct timeval *tv_null = NULL;
5032 tz.tz_minuteswest = 0;
5033 tz.tz_dsttime = 0; /* DST_NONE*/
5035 if (settimeofday(tv_null, &tz) < 0)
5041 int rtc_open(int flags) {
5045 /* First, we try to make use of the /dev/rtc symlink. If that
5046 * doesn't exist, we open the first RTC which has hctosys=1
5047 * set. If we don't find any we just take the first RTC that
5050 fd = open("/dev/rtc", flags);
5054 d = opendir("/sys/class/rtc");
5060 struct dirent buf, *de;
5063 r = readdir_r(d, &buf, &de);
5070 if (ignore_file(de->d_name))
5073 p = join("/sys/class/rtc/", de->d_name, "/hctosys", NULL);
5079 r = read_one_line_file(p, &v);
5085 r = parse_boolean(v);
5091 p = strappend("/dev/", de->d_name);
5092 fd = open(p, flags);
5105 fd = open("/dev/rtc0", flags);
5112 int hwclock_get_time(struct tm *tm) {
5118 fd = rtc_open(O_RDONLY|O_CLOEXEC);
5122 /* This leaves the timezone fields of struct tm
5124 if (ioctl(fd, RTC_RD_TIME, tm) < 0)
5127 /* We don't now daylight saving, so we reset this in order not
5128 * to confused mktime(). */
5131 close_nointr_nofail(fd);
5136 int hwclock_set_time(const struct tm *tm) {
5142 fd = rtc_open(O_RDONLY|O_CLOEXEC);
5146 if (ioctl(fd, RTC_SET_TIME, tm) < 0)
5149 close_nointr_nofail(fd);
5154 int copy_file(const char *from, const char *to) {
5160 fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
5164 fdt = open(to, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC|O_NOCTTY, 0644);
5166 close_nointr_nofail(fdf);
5174 n = read(fdf, buf, sizeof(buf));
5178 close_nointr_nofail(fdf);
5189 k = loop_write(fdt, buf, n, false);
5191 r = k < 0 ? k : (errno ? -errno : -EIO);
5193 close_nointr_nofail(fdf);
5201 close_nointr_nofail(fdf);
5202 r = close_nointr(fdt);
5212 int symlink_or_copy(const char *from, const char *to) {
5213 char *pf = NULL, *pt = NULL;
5220 if (parent_of_path(from, &pf) < 0 ||
5221 parent_of_path(to, &pt) < 0) {
5226 if (stat(pf, &a) < 0 ||
5232 if (a.st_dev != b.st_dev) {
5236 return copy_file(from, to);
5239 if (symlink(from, to) < 0) {
5253 int symlink_or_copy_atomic(const char *from, const char *to) {
5257 unsigned long long ull;
5264 t = new(char, strlen(to) + 1 + 16 + 1);
5268 fn = file_name_from_path(to);
5272 x = stpcpy(t+k+1, fn);
5275 for (i = 0; i < 16; i++) {
5276 *(x++) = hexchar(ull & 0xF);
5282 r = symlink_or_copy(from, t);
5289 if (rename(t, to) < 0) {
5300 bool display_is_local(const char *display) {
5304 display[0] == ':' &&
5305 display[1] >= '0' &&
5309 int socket_from_display(const char *display, char **path) {
5316 if (!display_is_local(display))
5319 k = strspn(display+1, "0123456789");
5321 f = new(char, sizeof("/tmp/.X11-unix/X") + k);
5325 c = stpcpy(f, "/tmp/.X11-unix/X");
5326 memcpy(c, display+1, k);
5334 int get_user_creds(const char **username, uid_t *uid, gid_t *gid, const char **home) {
5341 /* We enforce some special rules for uid=0: in order to avoid
5342 * NSS lookups for root we hardcode its data. */
5344 if (streq(*username, "root") || streq(*username, "0")) {
5358 if (parse_uid(*username, &u) >= 0) {
5362 /* If there are multiple users with the same id, make
5363 * sure to leave $USER to the configured value instead
5364 * of the first occurrence in the database. However if
5365 * the uid was configured by a numeric uid, then let's
5366 * pick the real username from /etc/passwd. */
5368 *username = p->pw_name;
5371 p = getpwnam(*username);
5375 return errno != 0 ? -errno : -ESRCH;
5389 int get_group_creds(const char **groupname, gid_t *gid) {
5395 /* We enforce some special rules for gid=0: in order to avoid
5396 * NSS lookups for root we hardcode its data. */
5398 if (streq(*groupname, "root") || streq(*groupname, "0")) {
5399 *groupname = "root";
5407 if (parse_gid(*groupname, &id) >= 0) {
5412 *groupname = g->gr_name;
5415 g = getgrnam(*groupname);
5419 return errno != 0 ? -errno : -ESRCH;
5427 int in_group(const char *name) {
5429 int ngroups_max, r, i;
5431 r = get_group_creds(&name, &gid);
5435 if (getgid() == gid)
5438 if (getegid() == gid)
5441 ngroups_max = sysconf(_SC_NGROUPS_MAX);
5442 assert(ngroups_max > 0);
5444 gids = alloca(sizeof(gid_t) * ngroups_max);
5446 r = getgroups(ngroups_max, gids);
5450 for (i = 0; i < r; i++)
5457 int glob_exists(const char *path) {
5465 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
5467 if (k == GLOB_NOMATCH)
5469 else if (k == GLOB_NOSPACE)
5472 r = !strv_isempty(g.gl_pathv);
5474 r = errno ? -errno : -EIO;
5481 int dirent_ensure_type(DIR *d, struct dirent *de) {
5487 if (de->d_type != DT_UNKNOWN)
5490 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
5494 S_ISREG(st.st_mode) ? DT_REG :
5495 S_ISDIR(st.st_mode) ? DT_DIR :
5496 S_ISLNK(st.st_mode) ? DT_LNK :
5497 S_ISFIFO(st.st_mode) ? DT_FIFO :
5498 S_ISSOCK(st.st_mode) ? DT_SOCK :
5499 S_ISCHR(st.st_mode) ? DT_CHR :
5500 S_ISBLK(st.st_mode) ? DT_BLK :
5506 int in_search_path(const char *path, char **search) {
5510 r = parent_of_path(path, &parent);
5516 STRV_FOREACH(i, search) {
5517 if (path_equal(parent, *i)) {
5528 int get_files_in_directory(const char *path, char ***list) {
5536 /* Returns all files in a directory in *list, and the number
5537 * of files as return value. If list is NULL returns only the
5545 struct dirent buffer, *de;
5548 k = readdir_r(d, &buffer, &de);
5557 dirent_ensure_type(d, de);
5559 if (!dirent_is_file(de))
5563 if ((unsigned) r >= n) {
5567 t = realloc(l, sizeof(char*) * n);
5576 assert((unsigned) r < n);
5578 l[r] = strdup(de->d_name);
5602 char *join(const char *x, ...) {
5615 t = va_arg(ap, const char *);
5638 t = va_arg(ap, const char *);
5652 bool is_main_thread(void) {
5653 static __thread int cached = 0;
5655 if (_unlikely_(cached == 0))
5656 cached = getpid() == gettid() ? 1 : -1;
5661 int block_get_whole_disk(dev_t d, dev_t *ret) {
5668 /* If it has a queue this is good enough for us */
5669 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
5672 r = access(p, F_OK);
5680 /* If it is a partition find the originating device */
5681 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
5684 r = access(p, F_OK);
5690 /* Get parent dev_t */
5691 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
5694 r = read_one_line_file(p, &s);
5700 r = sscanf(s, "%u:%u", &m, &n);
5706 /* Only return this if it is really good enough for us. */
5707 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
5710 r = access(p, F_OK);
5714 *ret = makedev(m, n);
5721 int file_is_priv_sticky(const char *p) {
5726 if (lstat(p, &st) < 0)
5730 (st.st_uid == 0 || st.st_uid == getuid()) &&
5731 (st.st_mode & S_ISVTX);
5734 static const char *const ioprio_class_table[] = {
5735 [IOPRIO_CLASS_NONE] = "none",
5736 [IOPRIO_CLASS_RT] = "realtime",
5737 [IOPRIO_CLASS_BE] = "best-effort",
5738 [IOPRIO_CLASS_IDLE] = "idle"
5741 DEFINE_STRING_TABLE_LOOKUP(ioprio_class, int);
5743 static const char *const sigchld_code_table[] = {
5744 [CLD_EXITED] = "exited",
5745 [CLD_KILLED] = "killed",
5746 [CLD_DUMPED] = "dumped",
5747 [CLD_TRAPPED] = "trapped",
5748 [CLD_STOPPED] = "stopped",
5749 [CLD_CONTINUED] = "continued",
5752 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
5754 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
5755 [LOG_FAC(LOG_KERN)] = "kern",
5756 [LOG_FAC(LOG_USER)] = "user",
5757 [LOG_FAC(LOG_MAIL)] = "mail",
5758 [LOG_FAC(LOG_DAEMON)] = "daemon",
5759 [LOG_FAC(LOG_AUTH)] = "auth",
5760 [LOG_FAC(LOG_SYSLOG)] = "syslog",
5761 [LOG_FAC(LOG_LPR)] = "lpr",
5762 [LOG_FAC(LOG_NEWS)] = "news",
5763 [LOG_FAC(LOG_UUCP)] = "uucp",
5764 [LOG_FAC(LOG_CRON)] = "cron",
5765 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5766 [LOG_FAC(LOG_FTP)] = "ftp",
5767 [LOG_FAC(LOG_LOCAL0)] = "local0",
5768 [LOG_FAC(LOG_LOCAL1)] = "local1",
5769 [LOG_FAC(LOG_LOCAL2)] = "local2",
5770 [LOG_FAC(LOG_LOCAL3)] = "local3",
5771 [LOG_FAC(LOG_LOCAL4)] = "local4",
5772 [LOG_FAC(LOG_LOCAL5)] = "local5",
5773 [LOG_FAC(LOG_LOCAL6)] = "local6",
5774 [LOG_FAC(LOG_LOCAL7)] = "local7"
5777 DEFINE_STRING_TABLE_LOOKUP(log_facility_unshifted, int);
5779 static const char *const log_level_table[] = {
5780 [LOG_EMERG] = "emerg",
5781 [LOG_ALERT] = "alert",
5782 [LOG_CRIT] = "crit",
5784 [LOG_WARNING] = "warning",
5785 [LOG_NOTICE] = "notice",
5786 [LOG_INFO] = "info",
5787 [LOG_DEBUG] = "debug"
5790 DEFINE_STRING_TABLE_LOOKUP(log_level, int);
5792 static const char* const sched_policy_table[] = {
5793 [SCHED_OTHER] = "other",
5794 [SCHED_BATCH] = "batch",
5795 [SCHED_IDLE] = "idle",
5796 [SCHED_FIFO] = "fifo",
5800 DEFINE_STRING_TABLE_LOOKUP(sched_policy, int);
5802 static const char* const rlimit_table[] = {
5803 [RLIMIT_CPU] = "LimitCPU",
5804 [RLIMIT_FSIZE] = "LimitFSIZE",
5805 [RLIMIT_DATA] = "LimitDATA",
5806 [RLIMIT_STACK] = "LimitSTACK",
5807 [RLIMIT_CORE] = "LimitCORE",
5808 [RLIMIT_RSS] = "LimitRSS",
5809 [RLIMIT_NOFILE] = "LimitNOFILE",
5810 [RLIMIT_AS] = "LimitAS",
5811 [RLIMIT_NPROC] = "LimitNPROC",
5812 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5813 [RLIMIT_LOCKS] = "LimitLOCKS",
5814 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5815 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5816 [RLIMIT_NICE] = "LimitNICE",
5817 [RLIMIT_RTPRIO] = "LimitRTPRIO",
5818 [RLIMIT_RTTIME] = "LimitRTTIME"
5821 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5823 static const char* const ip_tos_table[] = {
5824 [IPTOS_LOWDELAY] = "low-delay",
5825 [IPTOS_THROUGHPUT] = "throughput",
5826 [IPTOS_RELIABILITY] = "reliability",
5827 [IPTOS_LOWCOST] = "low-cost",
5830 DEFINE_STRING_TABLE_LOOKUP(ip_tos, int);
5832 static const char *const __signal_table[] = {
5849 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
5860 [SIGVTALRM] = "VTALRM",
5862 [SIGWINCH] = "WINCH",
5868 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5870 const char *signal_to_string(int signo) {
5871 static __thread char buf[12];
5874 name = __signal_to_string(signo);
5878 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5879 snprintf(buf, sizeof(buf) - 1, "RTMIN+%d", signo - SIGRTMIN);
5881 snprintf(buf, sizeof(buf) - 1, "%d", signo);
5886 int signal_from_string(const char *s) {
5891 signo =__signal_from_string(s);
5895 if (startswith(s, "RTMIN+")) {
5899 if (safe_atou(s, &u) >= 0) {
5900 signo = (int) u + offset;
5901 if (signo > 0 && signo < _NSIG)
5907 bool kexec_loaded(void) {
5908 bool loaded = false;
5911 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5919 int strdup_or_null(const char *a, char **b) {
5937 int prot_from_flags(int flags) {
5939 switch (flags & O_ACCMODE) {
5948 return PROT_READ|PROT_WRITE;
5955 char *format_bytes(char *buf, size_t l, off_t t) {
5958 static const struct {
5962 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5963 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5964 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5965 { "G", 1024ULL*1024ULL*1024ULL },
5966 { "M", 1024ULL*1024ULL },
5970 for (i = 0; i < ELEMENTSOF(table); i++) {
5972 if (t >= table[i].factor) {
5975 (unsigned long long) (t / table[i].factor),
5976 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5983 snprintf(buf, l, "%lluB", (unsigned long long) t);
5991 void* memdup(const void *p, size_t l) {
6004 int fd_inc_sndbuf(int fd, size_t n) {
6006 socklen_t l = sizeof(value);
6008 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
6010 l == sizeof(value) &&
6011 (size_t) value >= n*2)
6015 r = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value));
6022 int fd_inc_rcvbuf(int fd, size_t n) {
6024 socklen_t l = sizeof(value);
6026 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
6028 l == sizeof(value) &&
6029 (size_t) value >= n*2)
6033 r = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
6040 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
6041 pid_t parent_pid, agent_pid;
6043 bool stdout_is_tty, stderr_is_tty;
6051 parent_pid = getpid();
6053 /* Spawns a temporary TTY agent, making sure it goes away when
6060 if (agent_pid != 0) {
6067 * Make sure the agent goes away when the parent dies */
6068 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
6069 _exit(EXIT_FAILURE);
6071 /* Check whether our parent died before we were able
6072 * to set the death signal */
6073 if (getppid() != parent_pid)
6074 _exit(EXIT_SUCCESS);
6076 /* Don't leak fds to the agent */
6077 close_all_fds(except, n_except);
6079 stdout_is_tty = isatty(STDOUT_FILENO);
6080 stderr_is_tty = isatty(STDERR_FILENO);
6082 if (!stdout_is_tty || !stderr_is_tty) {
6083 /* Detach from stdout/stderr. and reopen
6084 * /dev/tty for them. This is important to
6085 * ensure that when systemctl is started via
6086 * popen() or a similar call that expects to
6087 * read EOF we actually do generate EOF and
6088 * not delay this indefinitely by because we
6089 * keep an unused copy of stdin around. */
6090 fd = open("/dev/tty", O_WRONLY);
6092 log_error("Failed to open /dev/tty: %m");
6093 _exit(EXIT_FAILURE);
6097 dup2(fd, STDOUT_FILENO);
6100 dup2(fd, STDERR_FILENO);
6106 /* Count arguments */
6108 for (n = 0; va_arg(ap, char*); n++)
6113 l = alloca(sizeof(char *) * (n + 1));
6115 /* Fill in arguments */
6117 for (i = 0; i <= n; i++)
6118 l[i] = va_arg(ap, char*);
6122 _exit(EXIT_FAILURE);
6125 int setrlimit_closest(int resource, const struct rlimit *rlim) {
6126 struct rlimit highest, fixed;
6130 if (setrlimit(resource, rlim) >= 0)
6136 /* So we failed to set the desired setrlimit, then let's try
6137 * to get as close as we can */
6138 assert_se(getrlimit(resource, &highest) == 0);
6140 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
6141 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
6143 if (setrlimit(resource, &fixed) < 0)