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>
58 #include <linux/magic.h>
71 #include "path-util.h"
72 #include "exit-status.h"
78 char **saved_argv = NULL;
80 static volatile unsigned cached_columns = 0;
81 static volatile unsigned cached_lines = 0;
83 size_t page_size(void) {
84 static __thread size_t pgsz = 0;
87 if (_likely_(pgsz > 0))
90 r = sysconf(_SC_PAGESIZE);
97 bool streq_ptr(const char *a, const char *b) {
99 /* Like streq(), but tries to make sense of NULL pointers */
110 char* endswith(const char *s, const char *postfix) {
117 pl = strlen(postfix);
120 return (char*) s + sl;
125 if (memcmp(s + sl - pl, postfix, pl) != 0)
128 return (char*) s + sl - pl;
131 bool first_word(const char *s, const char *word) {
146 if (memcmp(s, word, wl) != 0)
150 strchr(WHITESPACE, s[wl]);
153 int close_nointr(int fd) {
159 /* Just ignore EINTR; a retry loop is the wrong
160 * thing to do on Linux.
162 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
163 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
164 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
165 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
167 if (_unlikely_(r < 0 && errno == EINTR))
175 void close_nointr_nofail(int fd) {
178 /* like close_nointr() but cannot fail, and guarantees errno
181 assert_se(close_nointr(fd) == 0);
184 void close_many(const int fds[], unsigned n_fd) {
187 assert(fds || n_fd <= 0);
189 for (i = 0; i < n_fd; i++)
190 close_nointr_nofail(fds[i]);
193 int unlink_noerrno(const char *path) {
204 int parse_boolean(const char *v) {
207 if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
209 else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
215 int parse_pid(const char *s, pid_t* ret_pid) {
216 unsigned long ul = 0;
223 r = safe_atolu(s, &ul);
229 if ((unsigned long) pid != ul)
239 int parse_uid(const char *s, uid_t* ret_uid) {
240 unsigned long ul = 0;
247 r = safe_atolu(s, &ul);
253 if ((unsigned long) uid != ul)
260 int safe_atou(const char *s, unsigned *ret_u) {
268 l = strtoul(s, &x, 0);
270 if (!x || x == s || *x || errno)
271 return errno > 0 ? -errno : -EINVAL;
273 if ((unsigned long) (unsigned) l != l)
276 *ret_u = (unsigned) l;
280 int safe_atoi(const char *s, int *ret_i) {
288 l = strtol(s, &x, 0);
290 if (!x || x == s || *x || errno)
291 return errno > 0 ? -errno : -EINVAL;
293 if ((long) (int) l != l)
300 int safe_atollu(const char *s, long long unsigned *ret_llu) {
302 unsigned long long l;
308 l = strtoull(s, &x, 0);
310 if (!x || x == s || *x || errno)
311 return errno ? -errno : -EINVAL;
317 int safe_atolli(const char *s, long long int *ret_lli) {
325 l = strtoll(s, &x, 0);
327 if (!x || x == s || *x || errno)
328 return errno ? -errno : -EINVAL;
334 int safe_atod(const char *s, double *ret_d) {
341 RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
346 if (!x || x == s || *x || errno)
347 return errno ? -errno : -EINVAL;
353 /* Split a string into words. */
354 char *split(const char *c, size_t *l, const char *separator, char **state) {
357 current = *state ? *state : (char*) c;
359 if (!*current || *c == 0)
362 current += strspn(current, separator);
363 *l = strcspn(current, separator);
366 return (char*) current;
369 /* Split a string into words, but consider strings enclosed in '' and
370 * "" as words even if they include spaces. */
371 char *split_quoted(const char *c, size_t *l, char **state) {
373 bool escaped = false;
375 current = *state ? *state : (char*) c;
377 if (!*current || *c == 0)
380 current += strspn(current, WHITESPACE);
382 if (*current == '\'') {
385 for (e = current; *e; e++) {
395 *state = *e == 0 ? e : e+1;
396 } else if (*current == '\"') {
399 for (e = current; *e; e++) {
409 *state = *e == 0 ? e : e+1;
411 for (e = current; *e; e++) {
416 else if (strchr(WHITESPACE, *e))
423 return (char*) current;
426 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
428 _cleanup_fclose_ FILE *f = NULL;
441 p = procfs_file_alloca(pid, "stat");
446 if (!fgets(line, sizeof(line), f)) {
447 r = feof(f) ? -EIO : -errno;
451 /* Let's skip the pid and comm fields. The latter is enclosed
452 * in () but does not escape any () in its value, so let's
453 * skip over it manually */
455 p = strrchr(line, ')');
467 if ((long unsigned) (pid_t) ppid != ppid)
470 *_ppid = (pid_t) ppid;
475 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
476 _cleanup_fclose_ FILE *f = NULL;
484 p = "/proc/self/stat";
486 p = procfs_file_alloca(pid, "stat");
492 if (!fgets(line, sizeof(line), f)) {
499 /* Let's skip the pid and comm fields. The latter is enclosed
500 * in () but does not escape any () in its value, so let's
501 * skip over it manually */
503 p = strrchr(line, ')');
525 "%*d " /* priority */
527 "%*d " /* num_threads */
528 "%*d " /* itrealvalue */
529 "%llu " /* starttime */,
536 int fchmod_umask(int fd, mode_t m) {
541 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
547 char *truncate_nl(char *s) {
550 s[strcspn(s, NEWLINE)] = 0;
554 int get_process_comm(pid_t pid, char **name) {
561 p = "/proc/self/comm";
563 p = procfs_file_alloca(pid, "comm");
565 return read_one_line_file(p, name);
568 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
569 _cleanup_fclose_ FILE *f = NULL;
578 p = "/proc/self/cmdline";
580 p = procfs_file_alloca(pid, "cmdline");
586 if (max_length == 0) {
587 size_t len = 0, allocated = 0;
589 while ((c = getc(f)) != EOF) {
591 if (!GREEDY_REALLOC(r, allocated, len+2)) {
596 r[len++] = isprint(c) ? c : ' ';
606 r = new(char, max_length);
612 while ((c = getc(f)) != EOF) {
634 size_t n = MIN(left-1, 3U);
641 /* Kernel threads have no argv[] */
642 if (r == NULL || r[0] == 0) {
651 h = get_process_comm(pid, &t);
655 r = strjoin("[", t, "]", NULL);
666 int is_kernel_thread(pid_t pid) {
678 p = procfs_file_alloca(pid, "cmdline");
683 count = fread(&c, 1, 1, f);
687 /* Kernel threads have an empty cmdline */
690 return eof ? 1 : -errno;
695 int get_process_capeff(pid_t pid, char **capeff) {
702 p = "/proc/self/status";
704 p = procfs_file_alloca(pid, "status");
706 return get_status_field(p, "\nCapEff:", capeff);
709 int get_process_exe(pid_t pid, char **name) {
718 p = "/proc/self/exe";
720 p = procfs_file_alloca(pid, "exe");
722 r = readlink_malloc(p, name);
726 d = endswith(*name, " (deleted)");
733 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
734 _cleanup_fclose_ FILE *f = NULL;
744 p = procfs_file_alloca(pid, "status");
749 FOREACH_LINE(line, f, return -errno) {
754 if (startswith(l, field)) {
756 l += strspn(l, WHITESPACE);
758 l[strcspn(l, WHITESPACE)] = 0;
760 return parse_uid(l, uid);
767 int get_process_uid(pid_t pid, uid_t *uid) {
768 return get_process_id(pid, "Uid:", uid);
771 int get_process_gid(pid_t pid, gid_t *gid) {
772 assert_cc(sizeof(uid_t) == sizeof(gid_t));
773 return get_process_id(pid, "Gid:", gid);
776 char *strnappend(const char *s, const char *suffix, size_t b) {
784 return strndup(suffix, b);
793 if (b > ((size_t) -1) - a)
796 r = new(char, a+b+1);
801 memcpy(r+a, suffix, b);
807 char *strappend(const char *s, const char *suffix) {
808 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
811 int readlink_malloc(const char *p, char **r) {
821 if (!(c = new(char, l)))
824 if ((n = readlink(p, c, l-1)) < 0) {
830 if ((size_t) n < l-1) {
841 int readlink_and_make_absolute(const char *p, char **r) {
842 _cleanup_free_ char *target = NULL;
849 j = readlink_malloc(p, &target);
853 k = file_in_same_dir(p, target);
861 int readlink_and_canonicalize(const char *p, char **r) {
868 j = readlink_and_make_absolute(p, &t);
872 s = canonicalize_file_name(t);
879 path_kill_slashes(*r);
884 int reset_all_signal_handlers(void) {
887 for (sig = 1; sig < _NSIG; sig++) {
888 struct sigaction sa = {
889 .sa_handler = SIG_DFL,
890 .sa_flags = SA_RESTART,
893 if (sig == SIGKILL || sig == SIGSTOP)
896 /* On Linux the first two RT signals are reserved by
897 * glibc, and sigaction() will return EINVAL for them. */
898 if ((sigaction(sig, &sa, NULL) < 0))
906 char *strstrip(char *s) {
909 /* Drops trailing whitespace. Modifies the string in
910 * place. Returns pointer to first non-space character */
912 s += strspn(s, WHITESPACE);
914 for (e = strchr(s, 0); e > s; e --)
915 if (!strchr(WHITESPACE, e[-1]))
923 char *delete_chars(char *s, const char *bad) {
926 /* Drops all whitespace, regardless where in the string */
928 for (f = s, t = s; *f; f++) {
940 bool in_charset(const char *s, const char* charset) {
947 if (!strchr(charset, *i))
953 char *file_in_same_dir(const char *path, const char *filename) {
960 /* This removes the last component of path and appends
961 * filename, unless the latter is absolute anyway or the
964 if (path_is_absolute(filename))
965 return strdup(filename);
967 if (!(e = strrchr(path, '/')))
968 return strdup(filename);
970 k = strlen(filename);
971 if (!(r = new(char, e-path+1+k+1)))
974 memcpy(r, path, e-path+1);
975 memcpy(r+(e-path)+1, filename, k+1);
980 int rmdir_parents(const char *path, const char *stop) {
989 /* Skip trailing slashes */
990 while (l > 0 && path[l-1] == '/')
996 /* Skip last component */
997 while (l > 0 && path[l-1] != '/')
1000 /* Skip trailing slashes */
1001 while (l > 0 && path[l-1] == '/')
1007 if (!(t = strndup(path, l)))
1010 if (path_startswith(stop, t)) {
1019 if (errno != ENOENT)
1026 char hexchar(int x) {
1027 static const char table[16] = "0123456789abcdef";
1029 return table[x & 15];
1032 int unhexchar(char c) {
1034 if (c >= '0' && c <= '9')
1037 if (c >= 'a' && c <= 'f')
1038 return c - 'a' + 10;
1040 if (c >= 'A' && c <= 'F')
1041 return c - 'A' + 10;
1046 char *hexmem(const void *p, size_t l) {
1050 z = r = malloc(l * 2 + 1);
1054 for (x = p; x < (const uint8_t*) p + l; x++) {
1055 *(z++) = hexchar(*x >> 4);
1056 *(z++) = hexchar(*x & 15);
1063 void *unhexmem(const char *p, size_t l) {
1069 z = r = malloc((l + 1) / 2 + 1);
1073 for (x = p; x < p + l; x += 2) {
1076 a = unhexchar(x[0]);
1078 b = unhexchar(x[1]);
1082 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1089 char octchar(int x) {
1090 return '0' + (x & 7);
1093 int unoctchar(char c) {
1095 if (c >= '0' && c <= '7')
1101 char decchar(int x) {
1102 return '0' + (x % 10);
1105 int undecchar(char c) {
1107 if (c >= '0' && c <= '9')
1113 char *cescape(const char *s) {
1119 /* Does C style string escaping. */
1121 r = new(char, strlen(s)*4 + 1);
1125 for (f = s, t = r; *f; f++)
1171 /* For special chars we prefer octal over
1172 * hexadecimal encoding, simply because glib's
1173 * g_strescape() does the same */
1174 if ((*f < ' ') || (*f >= 127)) {
1176 *(t++) = octchar((unsigned char) *f >> 6);
1177 *(t++) = octchar((unsigned char) *f >> 3);
1178 *(t++) = octchar((unsigned char) *f);
1189 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1196 /* Undoes C style string escaping, and optionally prefixes it. */
1198 pl = prefix ? strlen(prefix) : 0;
1200 r = new(char, pl+length+1);
1205 memcpy(r, prefix, pl);
1207 for (f = s, t = r + pl; f < s + length; f++) {
1250 /* This is an extension of the XDG syntax files */
1255 /* hexadecimal encoding */
1258 a = unhexchar(f[1]);
1259 b = unhexchar(f[2]);
1261 if (a < 0 || b < 0) {
1262 /* Invalid escape code, let's take it literal then */
1266 *(t++) = (char) ((a << 4) | b);
1281 /* octal encoding */
1284 a = unoctchar(f[0]);
1285 b = unoctchar(f[1]);
1286 c = unoctchar(f[2]);
1288 if (a < 0 || b < 0 || c < 0) {
1289 /* Invalid escape code, let's take it literal then */
1293 *(t++) = (char) ((a << 6) | (b << 3) | c);
1301 /* premature end of string.*/
1306 /* Invalid escape code, let's take it literal then */
1318 char *cunescape_length(const char *s, size_t length) {
1319 return cunescape_length_with_prefix(s, length, NULL);
1322 char *cunescape(const char *s) {
1325 return cunescape_length(s, strlen(s));
1328 char *xescape(const char *s, const char *bad) {
1332 /* Escapes all chars in bad, in addition to \ and all special
1333 * chars, in \xFF style escaping. May be reversed with
1336 r = new(char, strlen(s) * 4 + 1);
1340 for (f = s, t = r; *f; f++) {
1342 if ((*f < ' ') || (*f >= 127) ||
1343 (*f == '\\') || strchr(bad, *f)) {
1346 *(t++) = hexchar(*f >> 4);
1347 *(t++) = hexchar(*f);
1357 char *bus_path_escape(const char *s) {
1363 /* Escapes all chars that D-Bus' object path cannot deal
1364 * with. Can be reverse with bus_path_unescape(). We special
1365 * case the empty string. */
1370 r = new(char, strlen(s)*3 + 1);
1374 for (f = s, t = r; *f; f++) {
1376 /* Escape everything that is not a-zA-Z0-9. We also
1377 * escape 0-9 if it's the first character */
1379 if (!(*f >= 'A' && *f <= 'Z') &&
1380 !(*f >= 'a' && *f <= 'z') &&
1381 !(f > s && *f >= '0' && *f <= '9')) {
1383 *(t++) = hexchar(*f >> 4);
1384 *(t++) = hexchar(*f);
1394 char *bus_path_unescape(const char *f) {
1399 /* Special case for the empty string */
1403 r = new(char, strlen(f) + 1);
1407 for (t = r; *f; f++) {
1412 if ((a = unhexchar(f[1])) < 0 ||
1413 (b = unhexchar(f[2])) < 0) {
1414 /* Invalid escape code, let's take it literal then */
1417 *(t++) = (char) ((a << 4) | b);
1429 char *ascii_strlower(char *t) {
1434 for (p = t; *p; p++)
1435 if (*p >= 'A' && *p <= 'Z')
1436 *p = *p - 'A' + 'a';
1441 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1445 filename[0] == '.' ||
1446 streq(filename, "lost+found") ||
1447 streq(filename, "aquota.user") ||
1448 streq(filename, "aquota.group") ||
1449 endswith(filename, ".rpmnew") ||
1450 endswith(filename, ".rpmsave") ||
1451 endswith(filename, ".rpmorig") ||
1452 endswith(filename, ".dpkg-old") ||
1453 endswith(filename, ".dpkg-new") ||
1454 endswith(filename, ".swp");
1457 bool ignore_file(const char *filename) {
1460 if (endswith(filename, "~"))
1463 return ignore_file_allow_backup(filename);
1466 int fd_nonblock(int fd, bool nonblock) {
1471 if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1475 flags |= O_NONBLOCK;
1477 flags &= ~O_NONBLOCK;
1479 if (fcntl(fd, F_SETFL, flags) < 0)
1485 int fd_cloexec(int fd, bool cloexec) {
1490 if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1494 flags |= FD_CLOEXEC;
1496 flags &= ~FD_CLOEXEC;
1498 if (fcntl(fd, F_SETFD, flags) < 0)
1504 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1507 assert(n_fdset == 0 || fdset);
1509 for (i = 0; i < n_fdset; i++)
1516 int close_all_fds(const int except[], unsigned n_except) {
1521 assert(n_except == 0 || except);
1523 d = opendir("/proc/self/fd");
1528 /* When /proc isn't available (for example in chroots)
1529 * the fallback is brute forcing through the fd
1532 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1533 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1535 if (fd_in_set(fd, except, n_except))
1538 if (close_nointr(fd) < 0)
1539 if (errno != EBADF && r == 0)
1546 while ((de = readdir(d))) {
1549 if (ignore_file(de->d_name))
1552 if (safe_atoi(de->d_name, &fd) < 0)
1553 /* Let's better ignore this, just in case */
1562 if (fd_in_set(fd, except, n_except))
1565 if (close_nointr(fd) < 0) {
1566 /* Valgrind has its own FD and doesn't want to have it closed */
1567 if (errno != EBADF && r == 0)
1576 bool chars_intersect(const char *a, const char *b) {
1579 /* Returns true if any of the chars in a are in b. */
1580 for (p = a; *p; p++)
1587 bool fstype_is_network(const char *fstype) {
1588 static const char table[] =
1598 return nulstr_contains(table, fstype);
1602 _cleanup_close_ int fd;
1604 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1610 TIOCL_GETKMSGREDIRECT,
1614 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1617 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1620 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1626 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1627 struct termios old_termios, new_termios;
1629 char line[LINE_MAX];
1634 if (tcgetattr(fileno(f), &old_termios) >= 0) {
1635 new_termios = old_termios;
1637 new_termios.c_lflag &= ~ICANON;
1638 new_termios.c_cc[VMIN] = 1;
1639 new_termios.c_cc[VTIME] = 0;
1641 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1644 if (t != (usec_t) -1) {
1645 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1646 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1651 k = fread(&c, 1, 1, f);
1653 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1659 *need_nl = c != '\n';
1666 if (t != (usec_t) -1)
1667 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1670 if (!fgets(line, sizeof(line), f))
1675 if (strlen(line) != 1)
1685 int ask(char *ret, const char *replies, const char *text, ...) {
1695 bool need_nl = true;
1698 fputs(ANSI_HIGHLIGHT_ON, stdout);
1705 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1709 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1712 if (r == -EBADMSG) {
1713 puts("Bad input, please try again.");
1724 if (strchr(replies, c)) {
1729 puts("Read unexpected character, please try again.");
1733 int reset_terminal_fd(int fd, bool switch_to_text) {
1734 struct termios termios;
1737 /* Set terminal to some sane defaults */
1741 /* We leave locked terminal attributes untouched, so that
1742 * Plymouth may set whatever it wants to set, and we don't
1743 * interfere with that. */
1745 /* Disable exclusive mode, just in case */
1746 ioctl(fd, TIOCNXCL);
1748 /* Switch to text mode */
1750 ioctl(fd, KDSETMODE, KD_TEXT);
1752 /* Enable console unicode mode */
1753 ioctl(fd, KDSKBMODE, K_UNICODE);
1755 if (tcgetattr(fd, &termios) < 0) {
1760 /* We only reset the stuff that matters to the software. How
1761 * hardware is set up we don't touch assuming that somebody
1762 * else will do that for us */
1764 termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1765 termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1766 termios.c_oflag |= ONLCR;
1767 termios.c_cflag |= CREAD;
1768 termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1770 termios.c_cc[VINTR] = 03; /* ^C */
1771 termios.c_cc[VQUIT] = 034; /* ^\ */
1772 termios.c_cc[VERASE] = 0177;
1773 termios.c_cc[VKILL] = 025; /* ^X */
1774 termios.c_cc[VEOF] = 04; /* ^D */
1775 termios.c_cc[VSTART] = 021; /* ^Q */
1776 termios.c_cc[VSTOP] = 023; /* ^S */
1777 termios.c_cc[VSUSP] = 032; /* ^Z */
1778 termios.c_cc[VLNEXT] = 026; /* ^V */
1779 termios.c_cc[VWERASE] = 027; /* ^W */
1780 termios.c_cc[VREPRINT] = 022; /* ^R */
1781 termios.c_cc[VEOL] = 0;
1782 termios.c_cc[VEOL2] = 0;
1784 termios.c_cc[VTIME] = 0;
1785 termios.c_cc[VMIN] = 1;
1787 if (tcsetattr(fd, TCSANOW, &termios) < 0)
1791 /* Just in case, flush all crap out */
1792 tcflush(fd, TCIOFLUSH);
1797 int reset_terminal(const char *name) {
1800 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1804 r = reset_terminal_fd(fd, true);
1805 close_nointr_nofail(fd);
1810 int open_terminal(const char *name, int mode) {
1815 * If a TTY is in the process of being closed opening it might
1816 * cause EIO. This is horribly awful, but unlikely to be
1817 * changed in the kernel. Hence we work around this problem by
1818 * retrying a couple of times.
1820 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1823 assert(!(mode & O_CREAT));
1826 fd = open(name, mode, 0);
1833 /* Max 1s in total */
1837 usleep(50 * USEC_PER_MSEC);
1846 close_nointr_nofail(fd);
1851 close_nointr_nofail(fd);
1858 int flush_fd(int fd) {
1859 struct pollfd pollfd = {
1869 r = poll(&pollfd, 1, 0);
1879 l = read(fd, buf, sizeof(buf));
1885 if (errno == EAGAIN)
1894 int acquire_terminal(
1898 bool ignore_tiocstty_eperm,
1901 int fd = -1, notify = -1, r = 0, wd = -1;
1906 /* We use inotify to be notified when the tty is closed. We
1907 * create the watch before checking if we can actually acquire
1908 * it, so that we don't lose any event.
1910 * Note: strictly speaking this actually watches for the
1911 * device being closed, it does *not* really watch whether a
1912 * tty loses its controlling process. However, unless some
1913 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1914 * its tty otherwise this will not become a problem. As long
1915 * as the administrator makes sure not configure any service
1916 * on the same tty as an untrusted user this should not be a
1917 * problem. (Which he probably should not do anyway.) */
1919 if (timeout != (usec_t) -1)
1920 ts = now(CLOCK_MONOTONIC);
1922 if (!fail && !force) {
1923 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1929 wd = inotify_add_watch(notify, name, IN_CLOSE);
1937 struct sigaction sa_old, sa_new = {
1938 .sa_handler = SIG_IGN,
1939 .sa_flags = SA_RESTART,
1943 r = flush_fd(notify);
1948 /* We pass here O_NOCTTY only so that we can check the return
1949 * value TIOCSCTTY and have a reliable way to figure out if we
1950 * successfully became the controlling process of the tty */
1951 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1955 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1956 * if we already own the tty. */
1957 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1959 /* First, try to get the tty */
1960 if (ioctl(fd, TIOCSCTTY, force) < 0)
1963 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1965 /* Sometimes it makes sense to ignore TIOCSCTTY
1966 * returning EPERM, i.e. when very likely we already
1967 * are have this controlling terminal. */
1968 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1971 if (r < 0 && (force || fail || r != -EPERM)) {
1980 assert(notify >= 0);
1983 uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1985 struct inotify_event *e;
1987 if (timeout != (usec_t) -1) {
1990 n = now(CLOCK_MONOTONIC);
1991 if (ts + timeout < n) {
1996 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2006 l = read(notify, inotify_buffer, sizeof(inotify_buffer));
2009 if (errno == EINTR || errno == EAGAIN)
2016 e = (struct inotify_event*) inotify_buffer;
2021 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2026 step = sizeof(struct inotify_event) + e->len;
2027 assert(step <= (size_t) l);
2029 e = (struct inotify_event*) ((uint8_t*) e + step);
2036 /* We close the tty fd here since if the old session
2037 * ended our handle will be dead. It's important that
2038 * we do this after sleeping, so that we don't enter
2039 * an endless loop. */
2040 close_nointr_nofail(fd);
2044 close_nointr_nofail(notify);
2046 r = reset_terminal_fd(fd, true);
2048 log_warning("Failed to reset terminal: %s", strerror(-r));
2054 close_nointr_nofail(fd);
2057 close_nointr_nofail(notify);
2062 int release_terminal(void) {
2064 struct sigaction sa_old, sa_new = {
2065 .sa_handler = SIG_IGN,
2066 .sa_flags = SA_RESTART,
2068 _cleanup_close_ int fd;
2070 fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2074 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2075 * by our own TIOCNOTTY */
2076 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2078 if (ioctl(fd, TIOCNOTTY) < 0)
2081 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2086 int sigaction_many(const struct sigaction *sa, ...) {
2091 while ((sig = va_arg(ap, int)) > 0)
2092 if (sigaction(sig, sa, NULL) < 0)
2099 int ignore_signals(int sig, ...) {
2100 struct sigaction sa = {
2101 .sa_handler = SIG_IGN,
2102 .sa_flags = SA_RESTART,
2108 if (sigaction(sig, &sa, NULL) < 0)
2112 while ((sig = va_arg(ap, int)) > 0)
2113 if (sigaction(sig, &sa, NULL) < 0)
2120 int default_signals(int sig, ...) {
2121 struct sigaction sa = {
2122 .sa_handler = SIG_DFL,
2123 .sa_flags = SA_RESTART,
2128 if (sigaction(sig, &sa, NULL) < 0)
2132 while ((sig = va_arg(ap, int)) > 0)
2133 if (sigaction(sig, &sa, NULL) < 0)
2140 int close_pipe(int p[]) {
2146 a = close_nointr(p[0]);
2151 b = close_nointr(p[1]);
2155 return a < 0 ? a : b;
2158 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2167 while (nbytes > 0) {
2170 if ((k = read(fd, p, nbytes)) <= 0) {
2172 if (k < 0 && errno == EINTR)
2175 if (k < 0 && errno == EAGAIN && do_poll) {
2176 struct pollfd pollfd = {
2181 if (poll(&pollfd, 1, -1) < 0) {
2185 return n > 0 ? n : -errno;
2188 if (pollfd.revents != POLLIN)
2189 return n > 0 ? n : -EIO;
2194 return n > 0 ? n : (k < 0 ? -errno : 0);
2205 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2214 while (nbytes > 0) {
2217 k = write(fd, p, nbytes);
2220 if (k < 0 && errno == EINTR)
2223 if (k < 0 && errno == EAGAIN && do_poll) {
2224 struct pollfd pollfd = {
2229 if (poll(&pollfd, 1, -1) < 0) {
2233 return n > 0 ? n : -errno;
2236 if (pollfd.revents != POLLOUT)
2237 return n > 0 ? n : -EIO;
2242 return n > 0 ? n : (k < 0 ? -errno : 0);
2253 int parse_bytes(const char *t, off_t *bytes) {
2254 static const struct {
2256 unsigned long long factor;
2260 { "M", 1024ULL*1024ULL },
2261 { "G", 1024ULL*1024ULL*1024ULL },
2262 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2263 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2264 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2269 unsigned long long r = 0;
2281 l = strtoll(p, &e, 10);
2292 e += strspn(e, WHITESPACE);
2294 for (i = 0; i < ELEMENTSOF(table); i++)
2295 if (startswith(e, table[i].suffix)) {
2296 unsigned long long tmp;
2297 if ((unsigned long long) l > ULLONG_MAX / table[i].factor)
2299 tmp = l * table[i].factor;
2300 if (tmp > ULLONG_MAX - r)
2304 if ((unsigned long long) (off_t) r != r)
2307 p = e + strlen(table[i].suffix);
2311 if (i >= ELEMENTSOF(table))
2321 int make_stdio(int fd) {
2326 r = dup3(fd, STDIN_FILENO, 0);
2327 s = dup3(fd, STDOUT_FILENO, 0);
2328 t = dup3(fd, STDERR_FILENO, 0);
2331 close_nointr_nofail(fd);
2333 if (r < 0 || s < 0 || t < 0)
2336 /* We rely here that the new fd has O_CLOEXEC not set */
2341 int make_null_stdio(void) {
2344 null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2348 return make_stdio(null_fd);
2351 bool is_device_path(const char *path) {
2353 /* Returns true on paths that refer to a device, either in
2354 * sysfs or in /dev */
2357 path_startswith(path, "/dev/") ||
2358 path_startswith(path, "/sys/");
2361 int dir_is_empty(const char *path) {
2362 _cleanup_closedir_ DIR *d;
2371 union dirent_storage buf;
2373 r = readdir_r(d, &buf.de, &de);
2380 if (!ignore_file(de->d_name))
2385 char* dirname_malloc(const char *path) {
2386 char *d, *dir, *dir2;
2403 unsigned long long random_ull(void) {
2404 _cleanup_close_ int fd;
2408 fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2412 r = loop_read(fd, &ull, sizeof(ull), true);
2413 if (r != sizeof(ull))
2419 return random() * RAND_MAX + random();
2422 void rename_process(const char name[8]) {
2425 /* This is a like a poor man's setproctitle(). It changes the
2426 * comm field, argv[0], and also the glibc's internally used
2427 * name of the process. For the first one a limit of 16 chars
2428 * applies, to the second one usually one of 10 (i.e. length
2429 * of "/sbin/init"), to the third one one of 7 (i.e. length of
2430 * "systemd"). If you pass a longer string it will be
2433 prctl(PR_SET_NAME, name);
2435 if (program_invocation_name)
2436 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2438 if (saved_argc > 0) {
2442 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2444 for (i = 1; i < saved_argc; i++) {
2448 memset(saved_argv[i], 0, strlen(saved_argv[i]));
2453 void sigset_add_many(sigset_t *ss, ...) {
2460 while ((sig = va_arg(ap, int)) > 0)
2461 assert_se(sigaddset(ss, sig) == 0);
2465 char* gethostname_malloc(void) {
2468 assert_se(uname(&u) >= 0);
2470 if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2471 return strdup(u.nodename);
2473 return strdup(u.sysname);
2476 bool hostname_is_set(void) {
2479 assert_se(uname(&u) >= 0);
2481 return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2484 static char *lookup_uid(uid_t uid) {
2487 _cleanup_free_ char *buf = NULL;
2488 struct passwd pwbuf, *pw = NULL;
2490 /* Shortcut things to avoid NSS lookups */
2492 return strdup("root");
2494 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2498 buf = malloc(bufsize);
2502 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2503 return strdup(pw->pw_name);
2505 if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
2511 char* getlogname_malloc(void) {
2515 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2520 return lookup_uid(uid);
2523 char *getusername_malloc(void) {
2530 return lookup_uid(getuid());
2533 int getttyname_malloc(int fd, char **r) {
2534 char path[PATH_MAX], *c;
2539 k = ttyname_r(fd, path, sizeof(path));
2545 c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2553 int getttyname_harder(int fd, char **r) {
2557 k = getttyname_malloc(fd, &s);
2561 if (streq(s, "tty")) {
2563 return get_ctty(0, NULL, r);
2570 int get_ctty_devnr(pid_t pid, dev_t *d) {
2571 _cleanup_fclose_ FILE *f = NULL;
2572 char line[LINE_MAX], *p;
2573 unsigned long ttynr;
2581 fn = "/proc/self/stat";
2583 fn = procfs_file_alloca(pid, "stat");
2585 f = fopen(fn, "re");
2589 if (!fgets(line, sizeof(line), f)) {
2590 k = feof(f) ? -EIO : -errno;
2594 p = strrchr(line, ')');
2604 "%*d " /* session */
2609 if (major(ttynr) == 0 && minor(ttynr) == 0)
2616 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2618 char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *s, *b, *p;
2623 k = get_ctty_devnr(pid, &devnr);
2627 snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2629 k = readlink_malloc(fn, &s);
2635 /* This is an ugly hack */
2636 if (major(devnr) == 136) {
2637 if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
2647 /* Probably something like the ptys which have no
2648 * symlink in /dev/char. Let's return something
2649 * vaguely useful. */
2662 if (startswith(s, "/dev/"))
2664 else if (startswith(s, "../"))
2682 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2688 /* This returns the first error we run into, but nevertheless
2689 * tries to go on. This closes the passed fd. */
2693 close_nointr_nofail(fd);
2695 return errno == ENOENT ? 0 : -errno;
2700 union dirent_storage buf;
2701 bool is_dir, keep_around;
2705 r = readdir_r(d, &buf.de, &de);
2706 if (r != 0 && ret == 0) {
2714 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2717 if (de->d_type == DT_UNKNOWN ||
2719 (de->d_type == DT_DIR && root_dev)) {
2720 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2721 if (ret == 0 && errno != ENOENT)
2726 is_dir = S_ISDIR(st.st_mode);
2729 (st.st_uid == 0 || st.st_uid == getuid()) &&
2730 (st.st_mode & S_ISVTX);
2732 is_dir = de->d_type == DT_DIR;
2733 keep_around = false;
2739 /* if root_dev is set, remove subdirectories only, if device is same as dir */
2740 if (root_dev && st.st_dev != root_dev->st_dev)
2743 subdir_fd = openat(fd, de->d_name,
2744 O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2745 if (subdir_fd < 0) {
2746 if (ret == 0 && errno != ENOENT)
2751 r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2752 if (r < 0 && ret == 0)
2756 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2757 if (ret == 0 && errno != ENOENT)
2761 } else if (!only_dirs && !keep_around) {
2763 if (unlinkat(fd, de->d_name, 0) < 0) {
2764 if (ret == 0 && errno != ENOENT)
2775 _pure_ static int is_temporary_fs(struct statfs *s) {
2778 F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2779 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2782 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2787 if (fstatfs(fd, &s) < 0) {
2788 close_nointr_nofail(fd);
2792 /* We refuse to clean disk file systems with this call. This
2793 * is extra paranoia just to be sure we never ever remove
2795 if (!is_temporary_fs(&s)) {
2796 log_error("Attempted to remove disk file system, and we can't allow that.");
2797 close_nointr_nofail(fd);
2801 return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2804 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2810 /* We refuse to clean the root file system with this
2811 * call. This is extra paranoia to never cause a really
2812 * seriously broken system. */
2813 if (path_equal(path, "/")) {
2814 log_error("Attempted to remove entire root file system, and we can't allow that.");
2818 fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2821 if (errno != ENOTDIR)
2825 if (statfs(path, &s) < 0)
2828 if (!is_temporary_fs(&s)) {
2829 log_error("Attempted to remove disk file system, and we can't allow that.");
2834 if (delete_root && !only_dirs)
2835 if (unlink(path) < 0 && errno != ENOENT)
2842 if (fstatfs(fd, &s) < 0) {
2843 close_nointr_nofail(fd);
2847 if (!is_temporary_fs(&s)) {
2848 log_error("Attempted to remove disk file system, and we can't allow that.");
2849 close_nointr_nofail(fd);
2854 r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2857 if (honour_sticky && file_is_priv_sticky(path) > 0)
2860 if (rmdir(path) < 0 && errno != ENOENT) {
2869 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2870 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2873 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2874 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2877 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2880 /* Under the assumption that we are running privileged we
2881 * first change the access mode and only then hand out
2882 * ownership to avoid a window where access is too open. */
2884 if (mode != (mode_t) -1)
2885 if (chmod(path, mode) < 0)
2888 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2889 if (chown(path, uid, gid) < 0)
2895 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2898 /* Under the assumption that we are running privileged we
2899 * first change the access mode and only then hand out
2900 * ownership to avoid a window where access is too open. */
2902 if (fchmod(fd, mode) < 0)
2905 if (fchown(fd, uid, gid) < 0)
2911 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2915 /* Allocates the cpuset in the right size */
2918 if (!(r = CPU_ALLOC(n)))
2921 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2922 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2932 if (errno != EINVAL)
2939 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2940 static const char status_indent[] = " "; /* "[" STATUS "] " */
2941 _cleanup_free_ char *s = NULL;
2942 _cleanup_close_ int fd = -1;
2943 struct iovec iovec[6] = {};
2945 static bool prev_ephemeral;
2949 /* This is independent of logging, as status messages are
2950 * optional and go exclusively to the console. */
2952 if (vasprintf(&s, format, ap) < 0)
2955 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2968 sl = status ? sizeof(status_indent)-1 : 0;
2974 e = ellipsize(s, emax, 75);
2982 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2983 prev_ephemeral = ephemeral;
2986 if (!isempty(status)) {
2987 IOVEC_SET_STRING(iovec[n++], "[");
2988 IOVEC_SET_STRING(iovec[n++], status);
2989 IOVEC_SET_STRING(iovec[n++], "] ");
2991 IOVEC_SET_STRING(iovec[n++], status_indent);
2994 IOVEC_SET_STRING(iovec[n++], s);
2996 IOVEC_SET_STRING(iovec[n++], "\n");
2998 if (writev(fd, iovec, n) < 0)
3004 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3010 va_start(ap, format);
3011 r = status_vprintf(status, ellipse, ephemeral, format, ap);
3017 int status_welcome(void) {
3019 _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
3021 r = parse_env_file("/etc/os-release", NEWLINE,
3022 "PRETTY_NAME", &pretty_name,
3023 "ANSI_COLOR", &ansi_color,
3025 if (r < 0 && r != -ENOENT)
3026 log_warning("Failed to read /etc/os-release: %s", strerror(-r));
3028 return status_printf(NULL, false, false,
3029 "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
3030 isempty(ansi_color) ? "1" : ansi_color,
3031 isempty(pretty_name) ? "Linux" : pretty_name);
3034 char *replace_env(const char *format, char **env) {
3041 const char *e, *word = format;
3046 for (e = format; *e; e ++) {
3057 if (!(k = strnappend(r, word, e-word-1)))
3066 } else if (*e == '$') {
3067 if (!(k = strnappend(r, word, e-word)))
3083 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3085 k = strappend(r, t);
3099 if (!(k = strnappend(r, word, e-word)))
3110 char **replace_env_argv(char **argv, char **env) {
3112 unsigned k = 0, l = 0;
3114 l = strv_length(argv);
3116 if (!(r = new(char*, l+1)))
3119 STRV_FOREACH(i, argv) {
3121 /* If $FOO appears as single word, replace it by the split up variable */
3122 if ((*i)[0] == '$' && (*i)[1] != '{') {
3127 e = strv_env_get(env, *i+1);
3130 if (!(m = strv_split_quoted(e))) {
3141 if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3150 memcpy(r + k, m, q * sizeof(char*));
3158 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3159 if (!(r[k++] = replace_env(*i, env))) {
3169 int fd_columns(int fd) {
3170 struct winsize ws = {};
3172 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3181 unsigned columns(void) {
3185 if (_likely_(cached_columns > 0))
3186 return cached_columns;
3189 e = getenv("COLUMNS");
3194 c = fd_columns(STDOUT_FILENO);
3203 int fd_lines(int fd) {
3204 struct winsize ws = {};
3206 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3215 unsigned lines(void) {
3219 if (_likely_(cached_lines > 0))
3220 return cached_lines;
3223 e = getenv("LINES");
3228 l = fd_lines(STDOUT_FILENO);
3234 return cached_lines;
3237 /* intended to be used as a SIGWINCH sighandler */
3238 void columns_lines_cache_reset(int signum) {
3244 static int cached_on_tty = -1;
3246 if (_unlikely_(cached_on_tty < 0))
3247 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3249 return cached_on_tty;
3252 int running_in_chroot(void) {
3253 struct stat a = {}, b = {};
3255 /* Only works as root */
3256 if (stat("/proc/1/root", &a) < 0)
3259 if (stat("/", &b) < 0)
3263 a.st_dev != b.st_dev ||
3264 a.st_ino != b.st_ino;
3267 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3272 assert(percent <= 100);
3273 assert(new_length >= 3);
3275 if (old_length <= 3 || old_length <= new_length)
3276 return strndup(s, old_length);
3278 r = new0(char, new_length+1);
3282 x = (new_length * percent) / 100;
3284 if (x > new_length - 3)
3292 s + old_length - (new_length - x - 3),
3293 new_length - x - 3);
3298 char *ellipsize(const char *s, size_t length, unsigned percent) {
3299 return ellipsize_mem(s, strlen(s), length, percent);
3302 int touch(const char *path) {
3307 /* This just opens the file for writing, ensuring it
3308 * exists. It doesn't call utimensat() the way /usr/bin/touch
3311 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3315 close_nointr_nofail(fd);
3319 char *unquote(const char *s, const char* quotes) {
3323 /* This is rather stupid, simply removes the heading and
3324 * trailing quotes if there is one. Doesn't care about
3325 * escaping or anything. We should make this smarter one
3332 if (strchr(quotes, s[0]) && s[l-1] == s[0])
3333 return strndup(s+1, l-2);
3338 char *normalize_env_assignment(const char *s) {
3339 _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3342 eq = strchr(s, '=');
3354 memmove(r, t, strlen(t) + 1);
3358 name = strndup(s, eq - s);
3366 value = unquote(strstrip(p), QUOTES);
3370 if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3376 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3387 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3399 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3406 r = wait_for_terminate(pid, &status);
3408 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3412 if (status.si_code == CLD_EXITED) {
3413 if (status.si_status != 0) {
3414 log_warning("%s failed with error code %i.", name, status.si_status);
3415 return status.si_status;
3418 log_debug("%s succeeded.", name);
3421 } else if (status.si_code == CLD_KILLED ||
3422 status.si_code == CLD_DUMPED) {
3424 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3428 log_warning("%s failed due to unknown reason.", name);
3432 _noreturn_ void freeze(void) {
3434 /* Make sure nobody waits for us on a socket anymore */
3435 close_all_fds(NULL, 0);
3443 bool null_or_empty(struct stat *st) {
3446 if (S_ISREG(st->st_mode) && st->st_size <= 0)
3449 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3455 int null_or_empty_path(const char *fn) {
3460 if (stat(fn, &st) < 0)
3463 return null_or_empty(&st);
3466 DIR *xopendirat(int fd, const char *name, int flags) {
3470 assert(!(flags & O_CREAT));
3472 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3478 close_nointr_nofail(nfd);
3485 int signal_from_string_try_harder(const char *s) {
3489 signo = signal_from_string(s);
3491 if (startswith(s, "SIG"))
3492 return signal_from_string(s+3);
3497 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3501 /* FIXME: to follow udev's logic 100% we need to leave valid
3502 * UTF8 chars unescaped */
3504 u = unquote(tagvalue, "\"\'");
3508 t = xescape(u, "/ ");
3514 r = asprintf(&dn, "/dev/disk/by-%s/%s", by, t);
3523 char *fstab_node_to_udev_node(const char *p) {
3526 if (startswith(p, "LABEL="))
3527 return tag_to_udev_node(p+6, "label");
3529 if (startswith(p, "UUID="))
3530 return tag_to_udev_node(p+5, "uuid");
3532 if (startswith(p, "PARTUUID="))
3533 return tag_to_udev_node(p+9, "partuuid");
3535 if (startswith(p, "PARTLABEL="))
3536 return tag_to_udev_node(p+10, "partlabel");
3541 bool tty_is_vc(const char *tty) {
3544 if (startswith(tty, "/dev/"))
3547 return vtnr_from_tty(tty) >= 0;
3550 bool tty_is_console(const char *tty) {
3553 if (startswith(tty, "/dev/"))
3556 return streq(tty, "console");
3559 int vtnr_from_tty(const char *tty) {
3564 if (startswith(tty, "/dev/"))
3567 if (!startswith(tty, "tty") )
3570 if (tty[3] < '0' || tty[3] > '9')
3573 r = safe_atoi(tty+3, &i);
3577 if (i < 0 || i > 63)
3583 char *resolve_dev_console(char **active) {
3586 /* Resolve where /dev/console is pointing to, if /sys is actually ours
3587 * (i.e. not read-only-mounted which is a sign for container setups) */
3589 if (path_is_read_only_fs("/sys") > 0)
3592 if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3595 /* If multiple log outputs are configured the last one is what
3596 * /dev/console points to */
3597 tty = strrchr(*active, ' ');
3606 bool tty_is_vc_resolve(const char *tty) {
3607 char *active = NULL;
3612 if (startswith(tty, "/dev/"))
3615 if (streq(tty, "console")) {
3616 tty = resolve_dev_console(&active);
3627 const char *default_term_for_tty(const char *tty) {
3630 return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3633 bool dirent_is_file(const struct dirent *de) {
3636 if (ignore_file(de->d_name))
3639 if (de->d_type != DT_REG &&
3640 de->d_type != DT_LNK &&
3641 de->d_type != DT_UNKNOWN)
3647 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3650 if (de->d_type != DT_REG &&
3651 de->d_type != DT_LNK &&
3652 de->d_type != DT_UNKNOWN)
3655 if (ignore_file_allow_backup(de->d_name))
3658 return endswith(de->d_name, suffix);
3661 void execute_directory(const char *directory, DIR *d, char *argv[]) {
3664 Hashmap *pids = NULL;
3668 /* Executes all binaries in a directory in parallel and
3669 * waits for them to finish. */
3672 if (!(_d = opendir(directory))) {
3674 if (errno == ENOENT)
3677 log_error("Failed to enumerate directory %s: %m", directory);
3684 if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
3685 log_error("Failed to allocate set.");
3689 while ((de = readdir(d))) {
3694 if (!dirent_is_file(de))
3697 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3702 if ((pid = fork()) < 0) {
3703 log_error("Failed to fork: %m");
3721 log_error("Failed to execute %s: %m", path);
3722 _exit(EXIT_FAILURE);
3725 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
3727 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
3728 log_error("Failed to add PID to set: %s", strerror(-k));
3733 while (!hashmap_isempty(pids)) {
3734 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
3738 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
3743 log_error("waitid() failed: %m");
3747 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
3748 if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
3749 if (si.si_code == CLD_EXITED)
3750 log_error("%s exited with exit status %i.", path, si.si_status);
3752 log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
3754 log_debug("%s exited successfully.", path);
3765 hashmap_free_free(pids);
3768 int kill_and_sigcont(pid_t pid, int sig) {
3771 r = kill(pid, sig) < 0 ? -errno : 0;
3779 bool nulstr_contains(const char*nulstr, const char *needle) {
3785 NULSTR_FOREACH(i, nulstr)
3786 if (streq(i, needle))
3792 bool plymouth_running(void) {
3793 return access("/run/plymouth/pid", F_OK) >= 0;
3796 char* strshorten(char *s, size_t l) {
3805 static bool hostname_valid_char(char c) {
3807 (c >= 'a' && c <= 'z') ||
3808 (c >= 'A' && c <= 'Z') ||
3809 (c >= '0' && c <= '9') ||
3815 bool hostname_is_valid(const char *s) {
3822 for (p = s, dot = true; *p; p++) {
3829 if (!hostname_valid_char(*p))
3839 if (p-s > HOST_NAME_MAX)
3845 char* hostname_cleanup(char *s, bool lowercase) {
3849 for (p = s, d = s, dot = true; *p; p++) {
3856 } else if (hostname_valid_char(*p)) {
3857 *(d++) = lowercase ? tolower(*p) : *p;
3868 strshorten(s, HOST_NAME_MAX);
3873 int pipe_eof(int fd) {
3875 struct pollfd pollfd = {
3877 .events = POLLIN|POLLHUP,
3880 r = poll(&pollfd, 1, 0);
3887 return pollfd.revents & POLLHUP;
3890 int fd_wait_for_event(int fd, int event, usec_t t) {
3892 struct pollfd pollfd = {
3897 r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
3904 return pollfd.revents;
3907 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3918 t = new(char, strlen(path) + 1 + 6 + 1);
3922 fn = path_get_file_name(path);
3926 stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
3928 fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
3934 f = fdopen(fd, "we");
3947 int terminal_vhangup_fd(int fd) {
3950 if (ioctl(fd, TIOCVHANGUP) < 0)
3956 int terminal_vhangup(const char *name) {
3959 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
3963 r = terminal_vhangup_fd(fd);
3964 close_nointr_nofail(fd);
3969 int vt_disallocate(const char *name) {
3973 /* Deallocate the VT if possible. If not possible
3974 * (i.e. because it is the active one), at least clear it
3975 * entirely (including the scrollback buffer) */
3977 if (!startswith(name, "/dev/"))
3980 if (!tty_is_vc(name)) {
3981 /* So this is not a VT. I guess we cannot deallocate
3982 * it then. But let's at least clear the screen */
3984 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
3989 "\033[r" /* clear scrolling region */
3990 "\033[H" /* move home */
3991 "\033[2J", /* clear screen */
3993 close_nointr_nofail(fd);
3998 if (!startswith(name, "/dev/tty"))
4001 r = safe_atou(name+8, &u);
4008 /* Try to deallocate */
4009 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4013 r = ioctl(fd, VT_DISALLOCATE, u);
4014 close_nointr_nofail(fd);
4022 /* Couldn't deallocate, so let's clear it fully with
4024 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4029 "\033[r" /* clear scrolling region */
4030 "\033[H" /* move home */
4031 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4033 close_nointr_nofail(fd);
4038 int copy_file(const char *from, const char *to) {
4044 fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4048 fdt = open(to, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC|O_NOCTTY, 0644);
4050 close_nointr_nofail(fdf);
4058 n = read(fdf, buf, sizeof(buf));
4062 close_nointr_nofail(fdf);
4073 k = loop_write(fdt, buf, n, false);
4075 r = k < 0 ? k : (errno ? -errno : -EIO);
4077 close_nointr_nofail(fdf);
4085 close_nointr_nofail(fdf);
4086 r = close_nointr(fdt);
4096 int symlink_atomic(const char *from, const char *to) {
4098 _cleanup_free_ char *t;
4101 unsigned long long ull;
4108 t = new(char, strlen(to) + 1 + 16 + 1);
4112 fn = path_get_file_name(to);
4116 x = stpcpy(t+k+1, fn);
4119 for (i = 0; i < 16; i++) {
4120 *(x++) = hexchar(ull & 0xF);
4126 if (symlink(from, t) < 0)
4129 if (rename(t, to) < 0) {
4138 bool display_is_local(const char *display) {
4142 display[0] == ':' &&
4143 display[1] >= '0' &&
4147 int socket_from_display(const char *display, char **path) {
4154 if (!display_is_local(display))
4157 k = strspn(display+1, "0123456789");
4159 f = new(char, sizeof("/tmp/.X11-unix/X") + k);
4163 c = stpcpy(f, "/tmp/.X11-unix/X");
4164 memcpy(c, display+1, k);
4173 const char **username,
4174 uid_t *uid, gid_t *gid,
4176 const char **shell) {
4184 /* We enforce some special rules for uid=0: in order to avoid
4185 * NSS lookups for root we hardcode its data. */
4187 if (streq(*username, "root") || streq(*username, "0")) {
4205 if (parse_uid(*username, &u) >= 0) {
4209 /* If there are multiple users with the same id, make
4210 * sure to leave $USER to the configured value instead
4211 * of the first occurrence in the database. However if
4212 * the uid was configured by a numeric uid, then let's
4213 * pick the real username from /etc/passwd. */
4215 *username = p->pw_name;
4218 p = getpwnam(*username);
4222 return errno > 0 ? -errno : -ESRCH;
4234 *shell = p->pw_shell;
4239 char* uid_to_name(uid_t uid) {
4244 return strdup("root");
4248 return strdup(p->pw_name);
4250 if (asprintf(&r, "%lu", (unsigned long) uid) < 0)
4256 char* gid_to_name(gid_t gid) {
4261 return strdup("root");
4265 return strdup(p->gr_name);
4267 if (asprintf(&r, "%lu", (unsigned long) gid) < 0)
4273 int get_group_creds(const char **groupname, gid_t *gid) {
4279 /* We enforce some special rules for gid=0: in order to avoid
4280 * NSS lookups for root we hardcode its data. */
4282 if (streq(*groupname, "root") || streq(*groupname, "0")) {
4283 *groupname = "root";
4291 if (parse_gid(*groupname, &id) >= 0) {
4296 *groupname = g->gr_name;
4299 g = getgrnam(*groupname);
4303 return errno > 0 ? -errno : -ESRCH;
4311 int in_gid(gid_t gid) {
4313 int ngroups_max, r, i;
4315 if (getgid() == gid)
4318 if (getegid() == gid)
4321 ngroups_max = sysconf(_SC_NGROUPS_MAX);
4322 assert(ngroups_max > 0);
4324 gids = alloca(sizeof(gid_t) * ngroups_max);
4326 r = getgroups(ngroups_max, gids);
4330 for (i = 0; i < r; i++)
4337 int in_group(const char *name) {
4341 r = get_group_creds(&name, &gid);
4348 int glob_exists(const char *path) {
4349 _cleanup_globfree_ glob_t g = {};
4355 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4357 if (k == GLOB_NOMATCH)
4359 else if (k == GLOB_NOSPACE)
4362 return !strv_isempty(g.gl_pathv);
4364 return errno ? -errno : -EIO;
4367 int glob_extend(char ***strv, const char *path) {
4368 _cleanup_globfree_ glob_t g = {};
4373 k = glob(optarg, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4375 if (k == GLOB_NOMATCH)
4377 else if (k == GLOB_NOSPACE)
4379 else if (k != 0 || strv_isempty(g.gl_pathv))
4380 return errno ? -errno : -EIO;
4382 STRV_FOREACH(p, g.gl_pathv) {
4383 k = strv_extend(strv, *p);
4391 int dirent_ensure_type(DIR *d, struct dirent *de) {
4397 if (de->d_type != DT_UNKNOWN)
4400 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4404 S_ISREG(st.st_mode) ? DT_REG :
4405 S_ISDIR(st.st_mode) ? DT_DIR :
4406 S_ISLNK(st.st_mode) ? DT_LNK :
4407 S_ISFIFO(st.st_mode) ? DT_FIFO :
4408 S_ISSOCK(st.st_mode) ? DT_SOCK :
4409 S_ISCHR(st.st_mode) ? DT_CHR :
4410 S_ISBLK(st.st_mode) ? DT_BLK :
4416 int in_search_path(const char *path, char **search) {
4420 r = path_get_parent(path, &parent);
4426 STRV_FOREACH(i, search) {
4427 if (path_equal(parent, *i)) {
4438 int get_files_in_directory(const char *path, char ***list) {
4446 /* Returns all files in a directory in *list, and the number
4447 * of files as return value. If list is NULL returns only the
4456 union dirent_storage buf;
4459 k = readdir_r(d, &buf.de, &de);
4468 dirent_ensure_type(d, de);
4470 if (!dirent_is_file(de))
4474 if ((unsigned) r >= n) {
4478 t = realloc(l, sizeof(char*) * n);
4487 assert((unsigned) r < n);
4489 l[r] = strdup(de->d_name);
4513 char *strjoin(const char *x, ...) {
4527 t = va_arg(ap, const char *);
4532 if (n > ((size_t) -1) - l) {
4556 t = va_arg(ap, const char *);
4570 bool is_main_thread(void) {
4571 static __thread int cached = 0;
4573 if (_unlikely_(cached == 0))
4574 cached = getpid() == gettid() ? 1 : -1;
4579 int block_get_whole_disk(dev_t d, dev_t *ret) {
4586 /* If it has a queue this is good enough for us */
4587 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4590 r = access(p, F_OK);
4598 /* If it is a partition find the originating device */
4599 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4602 r = access(p, F_OK);
4608 /* Get parent dev_t */
4609 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4612 r = read_one_line_file(p, &s);
4618 r = sscanf(s, "%u:%u", &m, &n);
4624 /* Only return this if it is really good enough for us. */
4625 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4628 r = access(p, F_OK);
4632 *ret = makedev(m, n);
4639 int file_is_priv_sticky(const char *p) {
4644 if (lstat(p, &st) < 0)
4648 (st.st_uid == 0 || st.st_uid == getuid()) &&
4649 (st.st_mode & S_ISVTX);
4652 static const char *const ioprio_class_table[] = {
4653 [IOPRIO_CLASS_NONE] = "none",
4654 [IOPRIO_CLASS_RT] = "realtime",
4655 [IOPRIO_CLASS_BE] = "best-effort",
4656 [IOPRIO_CLASS_IDLE] = "idle"
4659 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4661 static const char *const sigchld_code_table[] = {
4662 [CLD_EXITED] = "exited",
4663 [CLD_KILLED] = "killed",
4664 [CLD_DUMPED] = "dumped",
4665 [CLD_TRAPPED] = "trapped",
4666 [CLD_STOPPED] = "stopped",
4667 [CLD_CONTINUED] = "continued",
4670 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4672 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4673 [LOG_FAC(LOG_KERN)] = "kern",
4674 [LOG_FAC(LOG_USER)] = "user",
4675 [LOG_FAC(LOG_MAIL)] = "mail",
4676 [LOG_FAC(LOG_DAEMON)] = "daemon",
4677 [LOG_FAC(LOG_AUTH)] = "auth",
4678 [LOG_FAC(LOG_SYSLOG)] = "syslog",
4679 [LOG_FAC(LOG_LPR)] = "lpr",
4680 [LOG_FAC(LOG_NEWS)] = "news",
4681 [LOG_FAC(LOG_UUCP)] = "uucp",
4682 [LOG_FAC(LOG_CRON)] = "cron",
4683 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4684 [LOG_FAC(LOG_FTP)] = "ftp",
4685 [LOG_FAC(LOG_LOCAL0)] = "local0",
4686 [LOG_FAC(LOG_LOCAL1)] = "local1",
4687 [LOG_FAC(LOG_LOCAL2)] = "local2",
4688 [LOG_FAC(LOG_LOCAL3)] = "local3",
4689 [LOG_FAC(LOG_LOCAL4)] = "local4",
4690 [LOG_FAC(LOG_LOCAL5)] = "local5",
4691 [LOG_FAC(LOG_LOCAL6)] = "local6",
4692 [LOG_FAC(LOG_LOCAL7)] = "local7"
4695 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4697 static const char *const log_level_table[] = {
4698 [LOG_EMERG] = "emerg",
4699 [LOG_ALERT] = "alert",
4700 [LOG_CRIT] = "crit",
4702 [LOG_WARNING] = "warning",
4703 [LOG_NOTICE] = "notice",
4704 [LOG_INFO] = "info",
4705 [LOG_DEBUG] = "debug"
4708 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
4710 static const char* const sched_policy_table[] = {
4711 [SCHED_OTHER] = "other",
4712 [SCHED_BATCH] = "batch",
4713 [SCHED_IDLE] = "idle",
4714 [SCHED_FIFO] = "fifo",
4718 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
4720 static const char* const rlimit_table[] = {
4721 [RLIMIT_CPU] = "LimitCPU",
4722 [RLIMIT_FSIZE] = "LimitFSIZE",
4723 [RLIMIT_DATA] = "LimitDATA",
4724 [RLIMIT_STACK] = "LimitSTACK",
4725 [RLIMIT_CORE] = "LimitCORE",
4726 [RLIMIT_RSS] = "LimitRSS",
4727 [RLIMIT_NOFILE] = "LimitNOFILE",
4728 [RLIMIT_AS] = "LimitAS",
4729 [RLIMIT_NPROC] = "LimitNPROC",
4730 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
4731 [RLIMIT_LOCKS] = "LimitLOCKS",
4732 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
4733 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
4734 [RLIMIT_NICE] = "LimitNICE",
4735 [RLIMIT_RTPRIO] = "LimitRTPRIO",
4736 [RLIMIT_RTTIME] = "LimitRTTIME"
4739 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
4741 static const char* const ip_tos_table[] = {
4742 [IPTOS_LOWDELAY] = "low-delay",
4743 [IPTOS_THROUGHPUT] = "throughput",
4744 [IPTOS_RELIABILITY] = "reliability",
4745 [IPTOS_LOWCOST] = "low-cost",
4748 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
4750 static const char *const __signal_table[] = {
4767 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
4778 [SIGVTALRM] = "VTALRM",
4780 [SIGWINCH] = "WINCH",
4786 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
4788 const char *signal_to_string(int signo) {
4789 static __thread char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
4792 name = __signal_to_string(signo);
4796 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
4797 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
4799 snprintf(buf, sizeof(buf), "%d", signo);
4804 int signal_from_string(const char *s) {
4809 signo = __signal_from_string(s);
4813 if (startswith(s, "RTMIN+")) {
4817 if (safe_atou(s, &u) >= 0) {
4818 signo = (int) u + offset;
4819 if (signo > 0 && signo < _NSIG)
4825 bool kexec_loaded(void) {
4826 bool loaded = false;
4829 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
4837 int strdup_or_null(const char *a, char **b) {
4855 int prot_from_flags(int flags) {
4857 switch (flags & O_ACCMODE) {
4866 return PROT_READ|PROT_WRITE;
4873 char *format_bytes(char *buf, size_t l, off_t t) {
4876 static const struct {
4880 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4881 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4882 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
4883 { "G", 1024ULL*1024ULL*1024ULL },
4884 { "M", 1024ULL*1024ULL },
4888 for (i = 0; i < ELEMENTSOF(table); i++) {
4890 if (t >= table[i].factor) {
4893 (unsigned long long) (t / table[i].factor),
4894 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
4901 snprintf(buf, l, "%lluB", (unsigned long long) t);
4909 void* memdup(const void *p, size_t l) {
4922 int fd_inc_sndbuf(int fd, size_t n) {
4924 socklen_t l = sizeof(value);
4926 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
4928 l == sizeof(value) &&
4929 (size_t) value >= n*2)
4933 r = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value));
4940 int fd_inc_rcvbuf(int fd, size_t n) {
4942 socklen_t l = sizeof(value);
4944 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
4946 l == sizeof(value) &&
4947 (size_t) value >= n*2)
4951 r = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
4958 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
4959 pid_t parent_pid, agent_pid;
4961 bool stdout_is_tty, stderr_is_tty;
4969 parent_pid = getpid();
4971 /* Spawns a temporary TTY agent, making sure it goes away when
4978 if (agent_pid != 0) {
4985 * Make sure the agent goes away when the parent dies */
4986 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
4987 _exit(EXIT_FAILURE);
4989 /* Check whether our parent died before we were able
4990 * to set the death signal */
4991 if (getppid() != parent_pid)
4992 _exit(EXIT_SUCCESS);
4994 /* Don't leak fds to the agent */
4995 close_all_fds(except, n_except);
4997 stdout_is_tty = isatty(STDOUT_FILENO);
4998 stderr_is_tty = isatty(STDERR_FILENO);
5000 if (!stdout_is_tty || !stderr_is_tty) {
5001 /* Detach from stdout/stderr. and reopen
5002 * /dev/tty for them. This is important to
5003 * ensure that when systemctl is started via
5004 * popen() or a similar call that expects to
5005 * read EOF we actually do generate EOF and
5006 * not delay this indefinitely by because we
5007 * keep an unused copy of stdin around. */
5008 fd = open("/dev/tty", O_WRONLY);
5010 log_error("Failed to open /dev/tty: %m");
5011 _exit(EXIT_FAILURE);
5015 dup2(fd, STDOUT_FILENO);
5018 dup2(fd, STDERR_FILENO);
5024 /* Count arguments */
5026 for (n = 0; va_arg(ap, char*); n++)
5031 l = alloca(sizeof(char *) * (n + 1));
5033 /* Fill in arguments */
5035 for (i = 0; i <= n; i++)
5036 l[i] = va_arg(ap, char*);
5040 _exit(EXIT_FAILURE);
5043 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5044 struct rlimit highest, fixed;
5048 if (setrlimit(resource, rlim) >= 0)
5054 /* So we failed to set the desired setrlimit, then let's try
5055 * to get as close as we can */
5056 assert_se(getrlimit(resource, &highest) == 0);
5058 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5059 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5061 if (setrlimit(resource, &fixed) < 0)
5067 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5068 _cleanup_fclose_ FILE *f = NULL;
5080 path = "/proc/self/environ";
5082 path = procfs_file_alloca(pid, "environ");
5084 f = fopen(path, "re");
5092 char line[LINE_MAX];
5095 for (i = 0; i < sizeof(line)-1; i++) {
5099 if (_unlikely_(c == EOF)) {
5109 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5110 value = strdup(line + l + 1);
5124 bool is_valid_documentation_url(const char *url) {
5127 if (startswith(url, "http://") && url[7])
5130 if (startswith(url, "https://") && url[8])
5133 if (startswith(url, "file:") && url[5])
5136 if (startswith(url, "info:") && url[5])
5139 if (startswith(url, "man:") && url[4])
5145 bool in_initrd(void) {
5146 static __thread int saved = -1;
5152 /* We make two checks here:
5154 * 1. the flag file /etc/initrd-release must exist
5155 * 2. the root file system must be a memory file system
5157 * The second check is extra paranoia, since misdetecting an
5158 * initrd can have bad bad consequences due the initrd
5159 * emptying when transititioning to the main systemd.
5162 saved = access("/etc/initrd-release", F_OK) >= 0 &&
5163 statfs("/", &s) >= 0 &&
5164 is_temporary_fs(&s);
5169 void warn_melody(void) {
5170 _cleanup_close_ int fd = -1;
5172 fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5176 /* Yeah, this is synchronous. Kinda sucks. But well... */
5178 ioctl(fd, KIOCSOUND, (int)(1193180/440));
5179 usleep(125*USEC_PER_MSEC);
5181 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5182 usleep(125*USEC_PER_MSEC);
5184 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5185 usleep(125*USEC_PER_MSEC);
5187 ioctl(fd, KIOCSOUND, 0);
5190 int make_console_stdio(void) {
5193 /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5195 fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5197 log_error("Failed to acquire terminal: %s", strerror(-fd));
5203 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5210 int get_home_dir(char **_h) {
5218 /* Take the user specified one */
5229 /* Hardcode home directory for root to avoid NSS */
5232 h = strdup("/root");
5240 /* Check the database... */
5244 return errno > 0 ? -errno : -ESRCH;
5246 if (!path_is_absolute(p->pw_dir))
5249 h = strdup(p->pw_dir);
5257 bool filename_is_safe(const char *p) {
5271 if (strlen(p) > FILENAME_MAX)
5277 bool string_is_safe(const char *p) {
5282 for (t = p; *t; t++) {
5283 if (*t > 0 && *t < ' ')
5286 if (strchr("\\\"\'", *t))
5294 * Check if a string contains control characters.
5295 * Spaces and tabs are not considered control characters.
5297 bool string_has_cc(const char *p) {
5302 for (t = p; *t; t++)
5303 if (*t > 0 && *t < ' ' && *t != '\t')
5309 bool path_is_safe(const char *p) {
5314 if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5317 if (strlen(p) > PATH_MAX)
5320 /* The following two checks are not really dangerous, but hey, they still are confusing */
5321 if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5324 if (strstr(p, "//"))
5330 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5331 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5332 int (*compar) (const void *, const void *, void *), void *arg) {
5341 p = (void *)(((const char *) base) + (idx * size));
5342 comparison = compar(key, p, arg);
5345 else if (comparison > 0)
5353 bool is_locale_utf8(void) {
5355 static int cached_answer = -1;
5357 if (cached_answer >= 0)
5360 if (!setlocale(LC_ALL, "")) {
5361 cached_answer = true;
5365 set = nl_langinfo(CODESET);
5367 cached_answer = true;
5371 if(streq(set, "UTF-8")) {
5372 cached_answer = true;
5376 /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5377 * unset and everything can do to UTF-8 nowadays. */
5378 set = setlocale(LC_CTYPE, NULL);
5380 cached_answer = true;
5384 /* Check result, but ignore the result if C was set
5388 !getenv("LC_ALL") &&
5389 !getenv("LC_CTYPE") &&
5393 return (bool) cached_answer;
5396 const char *draw_special_char(DrawSpecialChar ch) {
5397 static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5399 [DRAW_TREE_VERT] = "\342\224\202 ", /* │ */
5400 [DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
5401 [DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
5402 [DRAW_TREE_SPACE] = " ", /* */
5403 [DRAW_TRIANGULAR_BULLET] = "\342\200\243 ", /* ‣ */
5405 /* ASCII fallback */ {
5406 [DRAW_TREE_VERT] = "| ",
5407 [DRAW_TREE_BRANCH] = "|-",
5408 [DRAW_TREE_RIGHT] = "`-",
5409 [DRAW_TREE_SPACE] = " ",
5410 [DRAW_TRIANGULAR_BULLET] = "> ",
5414 return draw_table[!is_locale_utf8()][ch];
5417 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5420 size_t l, old_len, new_len;
5426 old_len = strlen(old_string);
5427 new_len = strlen(new_string);
5440 if (!startswith(f, old_string)) {
5446 nl = l - old_len + new_len;
5447 a = realloc(r, nl + 1);
5455 t = stpcpy(t, new_string);
5467 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5468 const char *i, *begin = NULL;
5473 } state = STATE_OTHER;
5475 size_t osz = 0, isz;
5481 /* Strips ANSI color and replaces TABs by 8 spaces */
5483 isz = _isz ? *_isz : strlen(*ibuf);
5485 f = open_memstream(&obuf, &osz);
5489 for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5494 if (i >= *ibuf + isz) /* EOT */
5496 else if (*i == '\x1B')
5497 state = STATE_ESCAPE;
5498 else if (*i == '\t')
5505 if (i >= *ibuf + isz) { /* EOT */
5508 } else if (*i == '[') {
5509 state = STATE_BRACKET;
5514 state = STATE_OTHER;
5521 if (i >= *ibuf + isz || /* EOT */
5522 (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5525 state = STATE_OTHER;
5527 } else if (*i == 'm')
5528 state = STATE_OTHER;
5550 int on_ac_power(void) {
5551 bool found_offline = false, found_online = false;
5552 _cleanup_closedir_ DIR *d = NULL;
5554 d = opendir("/sys/class/power_supply");
5560 union dirent_storage buf;
5561 _cleanup_close_ int fd = -1, device = -1;
5566 k = readdir_r(d, &buf.de, &de);
5573 if (ignore_file(de->d_name))
5576 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5578 if (errno == ENOENT || errno == ENOTDIR)
5584 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5586 if (errno == ENOENT)
5592 n = read(fd, contents, sizeof(contents));
5596 if (n != 6 || memcmp(contents, "Mains\n", 6))
5599 close_nointr_nofail(fd);
5600 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5602 if (errno == ENOENT)
5608 n = read(fd, contents, sizeof(contents));
5612 if (n != 2 || contents[1] != '\n')
5615 if (contents[0] == '1') {
5616 found_online = true;
5618 } else if (contents[0] == '0')
5619 found_offline = true;
5624 return found_online || !found_offline;
5627 static int search_and_fopen_internal(const char *path, const char *mode, char **search, FILE **_f) {
5634 if (!path_strv_canonicalize_uniq(search))
5637 STRV_FOREACH(i, search) {
5638 _cleanup_free_ char *p = NULL;
5641 p = strjoin(*i, "/", path, NULL);
5651 if (errno != ENOENT)
5658 int search_and_fopen(const char *path, const char *mode, const char **search, FILE **_f) {
5659 _cleanup_strv_free_ char **copy = NULL;
5665 if (path_is_absolute(path)) {
5668 f = fopen(path, mode);
5677 copy = strv_copy((char**) search);
5681 return search_and_fopen_internal(path, mode, copy, _f);
5684 int search_and_fopen_nulstr(const char *path, const char *mode, const char *search, FILE **_f) {
5685 _cleanup_strv_free_ char **s = NULL;
5687 if (path_is_absolute(path)) {
5690 f = fopen(path, mode);
5699 s = strv_split_nulstr(search);
5703 return search_and_fopen_internal(path, mode, s, _f);
5706 int create_tmp_dir(char template[], char** dir_name) {
5708 char *d = NULL, *dt;
5712 RUN_WITH_UMASK(0077) {
5713 d = mkdtemp(template);
5716 log_error("Can't create directory %s: %m", template);
5720 dt = strjoin(d, "/tmp", NULL);
5726 RUN_WITH_UMASK(0000) {
5727 r = mkdir(dt, 0777);
5730 log_error("Can't create directory %s: %m", dt);
5734 log_debug("Created temporary directory %s", dt);
5736 r = chmod(dt, 0777 | S_ISVTX);
5738 log_error("Failed to chmod %s: %m", dt);
5742 log_debug("Set sticky bit on %s", dt);
5756 char *strextend(char **x, ...) {
5763 l = f = *x ? strlen(*x) : 0;
5770 t = va_arg(ap, const char *);
5775 if (n > ((size_t) -1) - l) {
5784 r = realloc(*x, l+1);
5794 t = va_arg(ap, const char *);
5808 char *strrep(const char *s, unsigned n) {
5816 p = r = malloc(l * n + 1);
5820 for (i = 0; i < n; i++)
5827 void* greedy_realloc(void **p, size_t *allocated, size_t need) {
5831 if (*allocated >= need)
5834 a = MAX(64u, need * 2);
5844 bool id128_is_valid(const char *s) {
5850 /* Simple formatted 128bit hex string */
5852 for (i = 0; i < l; i++) {
5855 if (!(c >= '0' && c <= '9') &&
5856 !(c >= 'a' && c <= 'z') &&
5857 !(c >= 'A' && c <= 'Z'))
5861 } else if (l == 36) {
5863 /* Formatted UUID */
5865 for (i = 0; i < l; i++) {
5868 if ((i == 8 || i == 13 || i == 18 || i == 23)) {
5872 if (!(c >= '0' && c <= '9') &&
5873 !(c >= 'a' && c <= 'z') &&
5874 !(c >= 'A' && c <= 'Z'))
5885 void parse_user_at_host(char *arg, char **user, char **host) {
5890 *host = strchr(arg, '@');
5899 int split_pair(const char *s, const char *sep, char **l, char **r) {
5914 a = strndup(s, x - s);
5918 b = strdup(x + strlen(sep));