1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
31 #include <sys/resource.h>
32 #include <linux/sched.h>
33 #include <sys/types.h>
37 #include <sys/ioctl.h>
39 #include <linux/tiocl.h>
44 #include <sys/prctl.h>
45 #include <sys/utsname.h>
47 #include <netinet/ip.h>
56 #include <sys/mount.h>
57 #include <linux/magic.h>
61 #include <sys/personality.h>
62 #include <sys/xattr.h>
66 #ifdef HAVE_SYS_AUXV_H
78 #include "path-util.h"
79 #include "exit-status.h"
83 #include "device-nodes.h"
88 #include "sparse-endian.h"
91 char **saved_argv = NULL;
93 static volatile unsigned cached_columns = 0;
94 static volatile unsigned cached_lines = 0;
96 size_t page_size(void) {
97 static thread_local size_t pgsz = 0;
100 if (_likely_(pgsz > 0))
103 r = sysconf(_SC_PAGESIZE);
110 bool streq_ptr(const char *a, const char *b) {
112 /* Like streq(), but tries to make sense of NULL pointers */
123 char* endswith(const char *s, const char *postfix) {
130 pl = strlen(postfix);
133 return (char*) s + sl;
138 if (memcmp(s + sl - pl, postfix, pl) != 0)
141 return (char*) s + sl - pl;
144 char* first_word(const char *s, const char *word) {
151 /* Checks if the string starts with the specified word, either
152 * followed by NUL or by whitespace. Returns a pointer to the
153 * NUL or the first character after the whitespace. */
164 if (memcmp(s, word, wl) != 0)
171 if (!strchr(WHITESPACE, *p))
174 p += strspn(p, WHITESPACE);
178 static size_t cescape_char(char c, char *buf) {
179 char * buf_old = buf;
225 /* For special chars we prefer octal over
226 * hexadecimal encoding, simply because glib's
227 * g_strescape() does the same */
228 if ((c < ' ') || (c >= 127)) {
230 *(buf++) = octchar((unsigned char) c >> 6);
231 *(buf++) = octchar((unsigned char) c >> 3);
232 *(buf++) = octchar((unsigned char) c);
238 return buf - buf_old;
241 int close_nointr(int fd) {
248 * Just ignore EINTR; a retry loop is the wrong thing to do on
251 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
252 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
253 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
254 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
262 int safe_close(int fd) {
265 * Like close_nointr() but cannot fail. Guarantees errno is
266 * unchanged. Is a NOP with negative fds passed, and returns
267 * -1, so that it can be used in this syntax:
269 * fd = safe_close(fd);
275 /* The kernel might return pretty much any error code
276 * via close(), but the fd will be closed anyway. The
277 * only condition we want to check for here is whether
278 * the fd was invalid at all... */
280 assert_se(close_nointr(fd) != -EBADF);
286 void close_many(const int fds[], unsigned n_fd) {
289 assert(fds || n_fd <= 0);
291 for (i = 0; i < n_fd; i++)
295 int unlink_noerrno(const char *path) {
306 int parse_boolean(const char *v) {
309 if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
311 else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
317 int parse_pid(const char *s, pid_t* ret_pid) {
318 unsigned long ul = 0;
325 r = safe_atolu(s, &ul);
331 if ((unsigned long) pid != ul)
341 int parse_uid(const char *s, uid_t* ret_uid) {
342 unsigned long ul = 0;
349 r = safe_atolu(s, &ul);
355 if ((unsigned long) uid != ul)
358 /* Some libc APIs use UID_INVALID as special placeholder */
359 if (uid == (uid_t) 0xFFFFFFFF)
362 /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
363 if (uid == (uid_t) 0xFFFF)
370 int safe_atou(const char *s, unsigned *ret_u) {
378 l = strtoul(s, &x, 0);
380 if (!x || x == s || *x || errno)
381 return errno > 0 ? -errno : -EINVAL;
383 if ((unsigned long) (unsigned) l != l)
386 *ret_u = (unsigned) l;
390 int safe_atoi(const char *s, int *ret_i) {
398 l = strtol(s, &x, 0);
400 if (!x || x == s || *x || errno)
401 return errno > 0 ? -errno : -EINVAL;
403 if ((long) (int) l != l)
410 int safe_atou8(const char *s, uint8_t *ret) {
418 l = strtoul(s, &x, 0);
420 if (!x || x == s || *x || errno)
421 return errno > 0 ? -errno : -EINVAL;
423 if ((unsigned long) (uint8_t) l != l)
430 int safe_atou16(const char *s, uint16_t *ret) {
438 l = strtoul(s, &x, 0);
440 if (!x || x == s || *x || errno)
441 return errno > 0 ? -errno : -EINVAL;
443 if ((unsigned long) (uint16_t) l != l)
450 int safe_atoi16(const char *s, int16_t *ret) {
458 l = strtol(s, &x, 0);
460 if (!x || x == s || *x || errno)
461 return errno > 0 ? -errno : -EINVAL;
463 if ((long) (int16_t) l != l)
470 int safe_atollu(const char *s, long long unsigned *ret_llu) {
472 unsigned long long l;
478 l = strtoull(s, &x, 0);
480 if (!x || x == s || *x || errno)
481 return errno ? -errno : -EINVAL;
487 int safe_atolli(const char *s, long long int *ret_lli) {
495 l = strtoll(s, &x, 0);
497 if (!x || x == s || *x || errno)
498 return errno ? -errno : -EINVAL;
504 int safe_atod(const char *s, double *ret_d) {
511 RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
516 if (!x || x == s || *x || errno)
517 return errno ? -errno : -EINVAL;
523 static size_t strcspn_escaped(const char *s, const char *reject) {
524 bool escaped = false;
527 for (n=0; s[n]; n++) {
530 else if (s[n] == '\\')
532 else if (strchr(reject, s[n]))
536 /* if s ends in \, return index of previous char */
540 /* Split a string into words. */
541 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
547 assert(**state == '\0');
551 current += strspn(current, separator);
557 if (quoted && strchr("\'\"", *current)) {
558 char quotechars[2] = {*current, '\0'};
560 *l = strcspn_escaped(current + 1, quotechars);
561 if (current[*l + 1] == '\0' ||
562 (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
563 /* right quote missing or garbage at the end */
567 assert(current[*l + 1] == quotechars[0]);
568 *state = current++ + *l + 2;
570 *l = strcspn_escaped(current, separator);
571 if (current[*l] && !strchr(separator, current[*l])) {
572 /* unfinished escape */
576 *state = current + *l;
578 *l = strcspn(current, separator);
579 *state = current + *l;
585 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
587 _cleanup_free_ char *line = NULL;
599 p = procfs_file_alloca(pid, "stat");
600 r = read_one_line_file(p, &line);
604 /* Let's skip the pid and comm fields. The latter is enclosed
605 * in () but does not escape any () in its value, so let's
606 * skip over it manually */
608 p = strrchr(line, ')');
620 if ((long unsigned) (pid_t) ppid != ppid)
623 *_ppid = (pid_t) ppid;
628 int fchmod_umask(int fd, mode_t m) {
633 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
639 char *truncate_nl(char *s) {
642 s[strcspn(s, NEWLINE)] = 0;
646 int get_process_state(pid_t pid) {
650 _cleanup_free_ char *line = NULL;
654 p = procfs_file_alloca(pid, "stat");
655 r = read_one_line_file(p, &line);
659 p = strrchr(line, ')');
665 if (sscanf(p, " %c", &state) != 1)
668 return (unsigned char) state;
671 int get_process_comm(pid_t pid, char **name) {
678 p = procfs_file_alloca(pid, "comm");
680 r = read_one_line_file(p, name);
687 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
688 _cleanup_fclose_ FILE *f = NULL;
696 p = procfs_file_alloca(pid, "cmdline");
702 if (max_length == 0) {
703 size_t len = 0, allocated = 0;
705 while ((c = getc(f)) != EOF) {
707 if (!GREEDY_REALLOC(r, allocated, len+2)) {
712 r[len++] = isprint(c) ? c : ' ';
722 r = new(char, max_length);
728 while ((c = getc(f)) != EOF) {
750 size_t n = MIN(left-1, 3U);
757 /* Kernel threads have no argv[] */
759 _cleanup_free_ char *t = NULL;
767 h = get_process_comm(pid, &t);
771 r = strjoin("[", t, "]", NULL);
780 int is_kernel_thread(pid_t pid) {
792 p = procfs_file_alloca(pid, "cmdline");
797 count = fread(&c, 1, 1, f);
801 /* Kernel threads have an empty cmdline */
804 return eof ? 1 : -errno;
809 int get_process_capeff(pid_t pid, char **capeff) {
815 p = procfs_file_alloca(pid, "status");
817 return get_status_field(p, "\nCapEff:", capeff);
820 static int get_process_link_contents(const char *proc_file, char **name) {
826 r = readlink_malloc(proc_file, name);
828 return r == -ENOENT ? -ESRCH : r;
833 int get_process_exe(pid_t pid, char **name) {
840 p = procfs_file_alloca(pid, "exe");
841 r = get_process_link_contents(p, name);
845 d = endswith(*name, " (deleted)");
852 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
853 _cleanup_fclose_ FILE *f = NULL;
863 p = procfs_file_alloca(pid, "status");
868 FOREACH_LINE(line, f, return -errno) {
873 if (startswith(l, field)) {
875 l += strspn(l, WHITESPACE);
877 l[strcspn(l, WHITESPACE)] = 0;
879 return parse_uid(l, uid);
886 int get_process_uid(pid_t pid, uid_t *uid) {
887 return get_process_id(pid, "Uid:", uid);
890 int get_process_gid(pid_t pid, gid_t *gid) {
891 assert_cc(sizeof(uid_t) == sizeof(gid_t));
892 return get_process_id(pid, "Gid:", gid);
895 int get_process_cwd(pid_t pid, char **cwd) {
900 p = procfs_file_alloca(pid, "cwd");
902 return get_process_link_contents(p, cwd);
905 int get_process_root(pid_t pid, char **root) {
910 p = procfs_file_alloca(pid, "root");
912 return get_process_link_contents(p, root);
915 int get_process_environ(pid_t pid, char **env) {
916 _cleanup_fclose_ FILE *f = NULL;
917 _cleanup_free_ char *outcome = NULL;
920 size_t allocated = 0, sz = 0;
925 p = procfs_file_alloca(pid, "environ");
931 while ((c = fgetc(f)) != EOF) {
932 if (!GREEDY_REALLOC(outcome, allocated, sz + 5))
936 outcome[sz++] = '\n';
938 sz += cescape_char(c, outcome + sz);
948 char *strnappend(const char *s, const char *suffix, size_t b) {
956 return strndup(suffix, b);
965 if (b > ((size_t) -1) - a)
968 r = new(char, a+b+1);
973 memcpy(r+a, suffix, b);
979 char *strappend(const char *s, const char *suffix) {
980 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
983 int readlinkat_malloc(int fd, const char *p, char **ret) {
998 n = readlinkat(fd, p, c, l-1);
1005 if ((size_t) n < l-1) {
1016 int readlink_malloc(const char *p, char **ret) {
1017 return readlinkat_malloc(AT_FDCWD, p, ret);
1020 int readlink_value(const char *p, char **ret) {
1021 _cleanup_free_ char *link = NULL;
1025 r = readlink_malloc(p, &link);
1029 value = basename(link);
1033 value = strdup(value);
1042 int readlink_and_make_absolute(const char *p, char **r) {
1043 _cleanup_free_ char *target = NULL;
1050 j = readlink_malloc(p, &target);
1054 k = file_in_same_dir(p, target);
1062 int readlink_and_canonicalize(const char *p, char **r) {
1069 j = readlink_and_make_absolute(p, &t);
1073 s = canonicalize_file_name(t);
1080 path_kill_slashes(*r);
1085 int reset_all_signal_handlers(void) {
1088 for (sig = 1; sig < _NSIG; sig++) {
1089 struct sigaction sa = {
1090 .sa_handler = SIG_DFL,
1091 .sa_flags = SA_RESTART,
1094 /* These two cannot be caught... */
1095 if (sig == SIGKILL || sig == SIGSTOP)
1098 /* On Linux the first two RT signals are reserved by
1099 * glibc, and sigaction() will return EINVAL for them. */
1100 if ((sigaction(sig, &sa, NULL) < 0))
1101 if (errno != EINVAL && r == 0)
1108 int reset_signal_mask(void) {
1111 if (sigemptyset(&ss) < 0)
1114 if (sigprocmask(SIG_SETMASK, &ss, NULL) < 0)
1120 char *strstrip(char *s) {
1123 /* Drops trailing whitespace. Modifies the string in
1124 * place. Returns pointer to first non-space character */
1126 s += strspn(s, WHITESPACE);
1128 for (e = strchr(s, 0); e > s; e --)
1129 if (!strchr(WHITESPACE, e[-1]))
1137 char *delete_chars(char *s, const char *bad) {
1140 /* Drops all whitespace, regardless where in the string */
1142 for (f = s, t = s; *f; f++) {
1143 if (strchr(bad, *f))
1154 char *file_in_same_dir(const char *path, const char *filename) {
1161 /* This removes the last component of path and appends
1162 * filename, unless the latter is absolute anyway or the
1165 if (path_is_absolute(filename))
1166 return strdup(filename);
1168 e = strrchr(path, '/');
1170 return strdup(filename);
1172 k = strlen(filename);
1173 ret = new(char, (e + 1 - path) + k + 1);
1177 memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);
1181 int rmdir_parents(const char *path, const char *stop) {
1190 /* Skip trailing slashes */
1191 while (l > 0 && path[l-1] == '/')
1197 /* Skip last component */
1198 while (l > 0 && path[l-1] != '/')
1201 /* Skip trailing slashes */
1202 while (l > 0 && path[l-1] == '/')
1208 if (!(t = strndup(path, l)))
1211 if (path_startswith(stop, t)) {
1220 if (errno != ENOENT)
1227 char hexchar(int x) {
1228 static const char table[16] = "0123456789abcdef";
1230 return table[x & 15];
1233 int unhexchar(char c) {
1235 if (c >= '0' && c <= '9')
1238 if (c >= 'a' && c <= 'f')
1239 return c - 'a' + 10;
1241 if (c >= 'A' && c <= 'F')
1242 return c - 'A' + 10;
1247 char *hexmem(const void *p, size_t l) {
1251 z = r = malloc(l * 2 + 1);
1255 for (x = p; x < (const uint8_t*) p + l; x++) {
1256 *(z++) = hexchar(*x >> 4);
1257 *(z++) = hexchar(*x & 15);
1264 void *unhexmem(const char *p, size_t l) {
1270 z = r = malloc((l + 1) / 2 + 1);
1274 for (x = p; x < p + l; x += 2) {
1277 a = unhexchar(x[0]);
1279 b = unhexchar(x[1]);
1283 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1290 char octchar(int x) {
1291 return '0' + (x & 7);
1294 int unoctchar(char c) {
1296 if (c >= '0' && c <= '7')
1302 char decchar(int x) {
1303 return '0' + (x % 10);
1306 int undecchar(char c) {
1308 if (c >= '0' && c <= '9')
1314 char *cescape(const char *s) {
1320 /* Does C style string escaping. */
1322 r = new(char, strlen(s)*4 + 1);
1326 for (f = s, t = r; *f; f++)
1327 t += cescape_char(*f, t);
1334 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1341 /* Undoes C style string escaping, and optionally prefixes it. */
1343 pl = prefix ? strlen(prefix) : 0;
1345 r = new(char, pl+length+1);
1350 memcpy(r, prefix, pl);
1352 for (f = s, t = r + pl; f < s + length; f++) {
1395 /* This is an extension of the XDG syntax files */
1400 /* hexadecimal encoding */
1403 a = unhexchar(f[1]);
1404 b = unhexchar(f[2]);
1406 if (a < 0 || b < 0 || (a == 0 && b == 0)) {
1407 /* Invalid escape code, let's take it literal then */
1411 *(t++) = (char) ((a << 4) | b);
1426 /* octal encoding */
1429 a = unoctchar(f[0]);
1430 b = unoctchar(f[1]);
1431 c = unoctchar(f[2]);
1433 if (a < 0 || b < 0 || c < 0 || (a == 0 && b == 0 && c == 0)) {
1434 /* Invalid escape code, let's take it literal then */
1438 *(t++) = (char) ((a << 6) | (b << 3) | c);
1446 /* premature end of string. */
1451 /* Invalid escape code, let's take it literal then */
1463 char *cunescape_length(const char *s, size_t length) {
1464 return cunescape_length_with_prefix(s, length, NULL);
1467 char *cunescape(const char *s) {
1470 return cunescape_length(s, strlen(s));
1473 char *xescape(const char *s, const char *bad) {
1477 /* Escapes all chars in bad, in addition to \ and all special
1478 * chars, in \xFF style escaping. May be reversed with
1481 r = new(char, strlen(s) * 4 + 1);
1485 for (f = s, t = r; *f; f++) {
1487 if ((*f < ' ') || (*f >= 127) ||
1488 (*f == '\\') || strchr(bad, *f)) {
1491 *(t++) = hexchar(*f >> 4);
1492 *(t++) = hexchar(*f);
1502 char *ascii_strlower(char *t) {
1507 for (p = t; *p; p++)
1508 if (*p >= 'A' && *p <= 'Z')
1509 *p = *p - 'A' + 'a';
1514 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1518 filename[0] == '.' ||
1519 streq(filename, "lost+found") ||
1520 streq(filename, "aquota.user") ||
1521 streq(filename, "aquota.group") ||
1522 endswith(filename, ".rpmnew") ||
1523 endswith(filename, ".rpmsave") ||
1524 endswith(filename, ".rpmorig") ||
1525 endswith(filename, ".dpkg-old") ||
1526 endswith(filename, ".dpkg-new") ||
1527 endswith(filename, ".dpkg-tmp") ||
1528 endswith(filename, ".swp");
1531 bool hidden_file(const char *filename) {
1534 if (endswith(filename, "~"))
1537 return hidden_file_allow_backup(filename);
1540 int fd_nonblock(int fd, bool nonblock) {
1545 flags = fcntl(fd, F_GETFL, 0);
1550 nflags = flags | O_NONBLOCK;
1552 nflags = flags & ~O_NONBLOCK;
1554 if (nflags == flags)
1557 if (fcntl(fd, F_SETFL, nflags) < 0)
1563 int fd_cloexec(int fd, bool cloexec) {
1568 flags = fcntl(fd, F_GETFD, 0);
1573 nflags = flags | FD_CLOEXEC;
1575 nflags = flags & ~FD_CLOEXEC;
1577 if (nflags == flags)
1580 if (fcntl(fd, F_SETFD, nflags) < 0)
1586 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1589 assert(n_fdset == 0 || fdset);
1591 for (i = 0; i < n_fdset; i++)
1598 int close_all_fds(const int except[], unsigned n_except) {
1599 _cleanup_closedir_ DIR *d = NULL;
1603 assert(n_except == 0 || except);
1605 d = opendir("/proc/self/fd");
1610 /* When /proc isn't available (for example in chroots)
1611 * the fallback is brute forcing through the fd
1614 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1615 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1617 if (fd_in_set(fd, except, n_except))
1620 if (close_nointr(fd) < 0)
1621 if (errno != EBADF && r == 0)
1628 while ((de = readdir(d))) {
1631 if (hidden_file(de->d_name))
1634 if (safe_atoi(de->d_name, &fd) < 0)
1635 /* Let's better ignore this, just in case */
1644 if (fd_in_set(fd, except, n_except))
1647 if (close_nointr(fd) < 0) {
1648 /* Valgrind has its own FD and doesn't want to have it closed */
1649 if (errno != EBADF && r == 0)
1657 bool chars_intersect(const char *a, const char *b) {
1660 /* Returns true if any of the chars in a are in b. */
1661 for (p = a; *p; p++)
1668 bool fstype_is_network(const char *fstype) {
1669 static const char table[] =
1683 x = startswith(fstype, "fuse.");
1687 return nulstr_contains(table, fstype);
1691 _cleanup_close_ int fd;
1693 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1699 TIOCL_GETKMSGREDIRECT,
1703 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1706 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1709 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1715 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1716 struct termios old_termios, new_termios;
1717 char c, line[LINE_MAX];
1722 if (tcgetattr(fileno(f), &old_termios) >= 0) {
1723 new_termios = old_termios;
1725 new_termios.c_lflag &= ~ICANON;
1726 new_termios.c_cc[VMIN] = 1;
1727 new_termios.c_cc[VTIME] = 0;
1729 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1732 if (t != USEC_INFINITY) {
1733 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1734 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1739 k = fread(&c, 1, 1, f);
1741 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1747 *need_nl = c != '\n';
1754 if (t != USEC_INFINITY) {
1755 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1760 if (!fgets(line, sizeof(line), f))
1761 return errno ? -errno : -EIO;
1765 if (strlen(line) != 1)
1775 int ask_char(char *ret, const char *replies, const char *text, ...) {
1785 bool need_nl = true;
1788 fputs(ANSI_HIGHLIGHT_ON, stdout);
1795 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1799 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1802 if (r == -EBADMSG) {
1803 puts("Bad input, please try again.");
1814 if (strchr(replies, c)) {
1819 puts("Read unexpected character, please try again.");
1823 int ask_string(char **ret, const char *text, ...) {
1828 char line[LINE_MAX];
1832 fputs(ANSI_HIGHLIGHT_ON, stdout);
1839 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1844 if (!fgets(line, sizeof(line), stdin))
1845 return errno ? -errno : -EIO;
1847 if (!endswith(line, "\n"))
1866 int reset_terminal_fd(int fd, bool switch_to_text) {
1867 struct termios termios;
1870 /* Set terminal to some sane defaults */
1874 /* We leave locked terminal attributes untouched, so that
1875 * Plymouth may set whatever it wants to set, and we don't
1876 * interfere with that. */
1878 /* Disable exclusive mode, just in case */
1879 ioctl(fd, TIOCNXCL);
1881 /* Switch to text mode */
1883 ioctl(fd, KDSETMODE, KD_TEXT);
1885 /* Enable console unicode mode */
1886 ioctl(fd, KDSKBMODE, K_UNICODE);
1888 if (tcgetattr(fd, &termios) < 0) {
1893 /* We only reset the stuff that matters to the software. How
1894 * hardware is set up we don't touch assuming that somebody
1895 * else will do that for us */
1897 termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1898 termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1899 termios.c_oflag |= ONLCR;
1900 termios.c_cflag |= CREAD;
1901 termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1903 termios.c_cc[VINTR] = 03; /* ^C */
1904 termios.c_cc[VQUIT] = 034; /* ^\ */
1905 termios.c_cc[VERASE] = 0177;
1906 termios.c_cc[VKILL] = 025; /* ^X */
1907 termios.c_cc[VEOF] = 04; /* ^D */
1908 termios.c_cc[VSTART] = 021; /* ^Q */
1909 termios.c_cc[VSTOP] = 023; /* ^S */
1910 termios.c_cc[VSUSP] = 032; /* ^Z */
1911 termios.c_cc[VLNEXT] = 026; /* ^V */
1912 termios.c_cc[VWERASE] = 027; /* ^W */
1913 termios.c_cc[VREPRINT] = 022; /* ^R */
1914 termios.c_cc[VEOL] = 0;
1915 termios.c_cc[VEOL2] = 0;
1917 termios.c_cc[VTIME] = 0;
1918 termios.c_cc[VMIN] = 1;
1920 if (tcsetattr(fd, TCSANOW, &termios) < 0)
1924 /* Just in case, flush all crap out */
1925 tcflush(fd, TCIOFLUSH);
1930 int reset_terminal(const char *name) {
1931 _cleanup_close_ int fd = -1;
1933 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1937 return reset_terminal_fd(fd, true);
1940 int open_terminal(const char *name, int mode) {
1945 * If a TTY is in the process of being closed opening it might
1946 * cause EIO. This is horribly awful, but unlikely to be
1947 * changed in the kernel. Hence we work around this problem by
1948 * retrying a couple of times.
1950 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1953 assert(!(mode & O_CREAT));
1956 fd = open(name, mode, 0);
1963 /* Max 1s in total */
1967 usleep(50 * USEC_PER_MSEC);
1985 int flush_fd(int fd) {
1986 struct pollfd pollfd = {
1996 r = poll(&pollfd, 1, 0);
2006 l = read(fd, buf, sizeof(buf));
2012 if (errno == EAGAIN)
2021 int acquire_terminal(
2025 bool ignore_tiocstty_eperm,
2028 int fd = -1, notify = -1, r = 0, wd = -1;
2033 /* We use inotify to be notified when the tty is closed. We
2034 * create the watch before checking if we can actually acquire
2035 * it, so that we don't lose any event.
2037 * Note: strictly speaking this actually watches for the
2038 * device being closed, it does *not* really watch whether a
2039 * tty loses its controlling process. However, unless some
2040 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2041 * its tty otherwise this will not become a problem. As long
2042 * as the administrator makes sure not configure any service
2043 * on the same tty as an untrusted user this should not be a
2044 * problem. (Which he probably should not do anyway.) */
2046 if (timeout != USEC_INFINITY)
2047 ts = now(CLOCK_MONOTONIC);
2049 if (!fail && !force) {
2050 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
2056 wd = inotify_add_watch(notify, name, IN_CLOSE);
2064 struct sigaction sa_old, sa_new = {
2065 .sa_handler = SIG_IGN,
2066 .sa_flags = SA_RESTART,
2070 r = flush_fd(notify);
2075 /* We pass here O_NOCTTY only so that we can check the return
2076 * value TIOCSCTTY and have a reliable way to figure out if we
2077 * successfully became the controlling process of the tty */
2078 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2082 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2083 * if we already own the tty. */
2084 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2086 /* First, try to get the tty */
2087 if (ioctl(fd, TIOCSCTTY, force) < 0)
2090 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2092 /* Sometimes it makes sense to ignore TIOCSCTTY
2093 * returning EPERM, i.e. when very likely we already
2094 * are have this controlling terminal. */
2095 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
2098 if (r < 0 && (force || fail || r != -EPERM)) {
2107 assert(notify >= 0);
2110 union inotify_event_buffer buffer;
2111 struct inotify_event *e;
2114 if (timeout != USEC_INFINITY) {
2117 n = now(CLOCK_MONOTONIC);
2118 if (ts + timeout < n) {
2123 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2133 l = read(notify, &buffer, sizeof(buffer));
2135 if (errno == EINTR || errno == EAGAIN)
2142 FOREACH_INOTIFY_EVENT(e, buffer, l) {
2143 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2152 /* We close the tty fd here since if the old session
2153 * ended our handle will be dead. It's important that
2154 * we do this after sleeping, so that we don't enter
2155 * an endless loop. */
2156 fd = safe_close(fd);
2161 r = reset_terminal_fd(fd, true);
2163 log_warning_errno(r, "Failed to reset terminal: %m");
2174 int release_terminal(void) {
2175 static const struct sigaction sa_new = {
2176 .sa_handler = SIG_IGN,
2177 .sa_flags = SA_RESTART,
2180 _cleanup_close_ int fd = -1;
2181 struct sigaction sa_old;
2184 fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2188 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2189 * by our own TIOCNOTTY */
2190 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2192 if (ioctl(fd, TIOCNOTTY) < 0)
2195 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2200 int sigaction_many(const struct sigaction *sa, ...) {
2205 while ((sig = va_arg(ap, int)) > 0)
2206 if (sigaction(sig, sa, NULL) < 0)
2213 int ignore_signals(int sig, ...) {
2214 struct sigaction sa = {
2215 .sa_handler = SIG_IGN,
2216 .sa_flags = SA_RESTART,
2221 if (sigaction(sig, &sa, NULL) < 0)
2225 while ((sig = va_arg(ap, int)) > 0)
2226 if (sigaction(sig, &sa, NULL) < 0)
2233 int default_signals(int sig, ...) {
2234 struct sigaction sa = {
2235 .sa_handler = SIG_DFL,
2236 .sa_flags = SA_RESTART,
2241 if (sigaction(sig, &sa, NULL) < 0)
2245 while ((sig = va_arg(ap, int)) > 0)
2246 if (sigaction(sig, &sa, NULL) < 0)
2253 void safe_close_pair(int p[]) {
2257 /* Special case pairs which use the same fd in both
2259 p[0] = p[1] = safe_close(p[0]);
2263 p[0] = safe_close(p[0]);
2264 p[1] = safe_close(p[1]);
2267 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2274 while (nbytes > 0) {
2277 k = read(fd, p, nbytes);
2282 if (errno == EAGAIN && do_poll) {
2284 /* We knowingly ignore any return value here,
2285 * and expect that any error/EOF is reported
2288 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2292 return n > 0 ? n : -errno;
2306 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2307 const uint8_t *p = buf;
2314 while (nbytes > 0) {
2317 k = write(fd, p, nbytes);
2322 if (errno == EAGAIN && do_poll) {
2323 /* We knowingly ignore any return value here,
2324 * and expect that any error/EOF is reported
2327 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2334 if (k == 0) /* Can't really happen */
2344 int parse_size(const char *t, off_t base, off_t *size) {
2346 /* Soo, sometimes we want to parse IEC binary suffxies, and
2347 * sometimes SI decimal suffixes. This function can parse
2348 * both. Which one is the right way depends on the
2349 * context. Wikipedia suggests that SI is customary for
2350 * hardrware metrics and network speeds, while IEC is
2351 * customary for most data sizes used by software and volatile
2352 * (RAM) memory. Hence be careful which one you pick!
2354 * In either case we use just K, M, G as suffix, and not Ki,
2355 * Mi, Gi or so (as IEC would suggest). That's because that's
2356 * frickin' ugly. But this means you really need to make sure
2357 * to document which base you are parsing when you use this
2362 unsigned long long factor;
2365 static const struct table iec[] = {
2366 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2367 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2368 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2369 { "G", 1024ULL*1024ULL*1024ULL },
2370 { "M", 1024ULL*1024ULL },
2376 static const struct table si[] = {
2377 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2378 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2379 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2380 { "G", 1000ULL*1000ULL*1000ULL },
2381 { "M", 1000ULL*1000ULL },
2387 const struct table *table;
2389 unsigned long long r = 0;
2390 unsigned n_entries, start_pos = 0;
2393 assert(base == 1000 || base == 1024);
2398 n_entries = ELEMENTSOF(si);
2401 n_entries = ELEMENTSOF(iec);
2407 unsigned long long l2;
2413 l = strtoll(p, &e, 10);
2426 if (*e >= '0' && *e <= '9') {
2429 /* strotoull itself would accept space/+/- */
2430 l2 = strtoull(e, &e2, 10);
2432 if (errno == ERANGE)
2435 /* Ignore failure. E.g. 10.M is valid */
2442 e += strspn(e, WHITESPACE);
2444 for (i = start_pos; i < n_entries; i++)
2445 if (startswith(e, table[i].suffix)) {
2446 unsigned long long tmp;
2447 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2449 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2450 if (tmp > ULLONG_MAX - r)
2454 if ((unsigned long long) (off_t) r != r)
2457 p = e + strlen(table[i].suffix);
2473 int make_stdio(int fd) {
2478 r = dup2(fd, STDIN_FILENO);
2479 s = dup2(fd, STDOUT_FILENO);
2480 t = dup2(fd, STDERR_FILENO);
2485 if (r < 0 || s < 0 || t < 0)
2488 /* Explicitly unset O_CLOEXEC, since if fd was < 3, then
2489 * dup2() was a NOP and the bit hence possibly set. */
2490 fd_cloexec(STDIN_FILENO, false);
2491 fd_cloexec(STDOUT_FILENO, false);
2492 fd_cloexec(STDERR_FILENO, false);
2497 int make_null_stdio(void) {
2500 null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2504 return make_stdio(null_fd);
2507 bool is_device_path(const char *path) {
2509 /* Returns true on paths that refer to a device, either in
2510 * sysfs or in /dev */
2513 path_startswith(path, "/dev/") ||
2514 path_startswith(path, "/sys/");
2517 int dir_is_empty(const char *path) {
2518 _cleanup_closedir_ DIR *d;
2529 if (!de && errno != 0)
2535 if (!hidden_file(de->d_name))
2540 char* dirname_malloc(const char *path) {
2541 char *d, *dir, *dir2;
2558 int dev_urandom(void *p, size_t n) {
2559 static int have_syscall = -1;
2563 /* Gathers some randomness from the kernel. This call will
2564 * never block, and will always return some data from the
2565 * kernel, regardless if the random pool is fully initialized
2566 * or not. It thus makes no guarantee for the quality of the
2567 * returned entropy, but is good enough for or usual usecases
2568 * of seeding the hash functions for hashtable */
2570 /* Use the getrandom() syscall unless we know we don't have
2571 * it, or when the requested size is too large for it. */
2572 if (have_syscall != 0 || (size_t) (int) n != n) {
2573 r = getrandom(p, n, GRND_NONBLOCK);
2575 have_syscall = true;
2580 if (errno == ENOSYS)
2581 /* we lack the syscall, continue with
2582 * reading from /dev/urandom */
2583 have_syscall = false;
2584 else if (errno == EAGAIN)
2585 /* not enough entropy for now. Let's
2586 * remember to use the syscall the
2587 * next time, again, but also read
2588 * from /dev/urandom for now, which
2589 * doesn't care about the current
2590 * amount of entropy. */
2591 have_syscall = true;
2595 /* too short read? */
2599 fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2601 return errno == ENOENT ? -ENOSYS : -errno;
2603 k = loop_read(fd, p, n, true);
2608 if ((size_t) k != n)
2614 void initialize_srand(void) {
2615 static bool srand_called = false;
2617 #ifdef HAVE_SYS_AUXV_H
2626 #ifdef HAVE_SYS_AUXV_H
2627 /* The kernel provides us with a bit of entropy in auxv, so
2628 * let's try to make use of that to seed the pseudo-random
2629 * generator. It's better than nothing... */
2631 auxv = (void*) getauxval(AT_RANDOM);
2633 x ^= *(unsigned*) auxv;
2636 x ^= (unsigned) now(CLOCK_REALTIME);
2637 x ^= (unsigned) gettid();
2640 srand_called = true;
2643 void random_bytes(void *p, size_t n) {
2647 r = dev_urandom(p, n);
2651 /* If some idiot made /dev/urandom unavailable to us, he'll
2652 * get a PRNG instead. */
2656 for (q = p; q < (uint8_t*) p + n; q ++)
2660 void rename_process(const char name[8]) {
2663 /* This is a like a poor man's setproctitle(). It changes the
2664 * comm field, argv[0], and also the glibc's internally used
2665 * name of the process. For the first one a limit of 16 chars
2666 * applies, to the second one usually one of 10 (i.e. length
2667 * of "/sbin/init"), to the third one one of 7 (i.e. length of
2668 * "systemd"). If you pass a longer string it will be
2671 prctl(PR_SET_NAME, name);
2673 if (program_invocation_name)
2674 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2676 if (saved_argc > 0) {
2680 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2682 for (i = 1; i < saved_argc; i++) {
2686 memzero(saved_argv[i], strlen(saved_argv[i]));
2691 void sigset_add_many(sigset_t *ss, ...) {
2698 while ((sig = va_arg(ap, int)) > 0)
2699 assert_se(sigaddset(ss, sig) == 0);
2703 int sigprocmask_many(int how, ...) {
2708 assert_se(sigemptyset(&ss) == 0);
2711 while ((sig = va_arg(ap, int)) > 0)
2712 assert_se(sigaddset(&ss, sig) == 0);
2715 if (sigprocmask(how, &ss, NULL) < 0)
2721 char* gethostname_malloc(void) {
2724 assert_se(uname(&u) >= 0);
2726 if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2727 return strdup(u.nodename);
2729 return strdup(u.sysname);
2732 bool hostname_is_set(void) {
2735 assert_se(uname(&u) >= 0);
2737 return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2740 char *lookup_uid(uid_t uid) {
2743 _cleanup_free_ char *buf = NULL;
2744 struct passwd pwbuf, *pw = NULL;
2746 /* Shortcut things to avoid NSS lookups */
2748 return strdup("root");
2750 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2754 buf = malloc(bufsize);
2758 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2759 return strdup(pw->pw_name);
2761 if (asprintf(&name, UID_FMT, uid) < 0)
2767 char* getlogname_malloc(void) {
2771 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2776 return lookup_uid(uid);
2779 char *getusername_malloc(void) {
2786 return lookup_uid(getuid());
2789 int getttyname_malloc(int fd, char **ret) {
2799 r = ttyname_r(fd, path, sizeof(path));
2804 p = startswith(path, "/dev/");
2805 c = strdup(p ?: path);
2822 int getttyname_harder(int fd, char **r) {
2826 k = getttyname_malloc(fd, &s);
2830 if (streq(s, "tty")) {
2832 return get_ctty(0, NULL, r);
2839 int get_ctty_devnr(pid_t pid, dev_t *d) {
2841 _cleanup_free_ char *line = NULL;
2843 unsigned long ttynr;
2847 p = procfs_file_alloca(pid, "stat");
2848 r = read_one_line_file(p, &line);
2852 p = strrchr(line, ')');
2862 "%*d " /* session */
2867 if (major(ttynr) == 0 && minor(ttynr) == 0)
2876 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2877 char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2878 _cleanup_free_ char *s = NULL;
2885 k = get_ctty_devnr(pid, &devnr);
2889 sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
2891 k = readlink_malloc(fn, &s);
2897 /* This is an ugly hack */
2898 if (major(devnr) == 136) {
2899 asprintf(&b, "pts/%u", minor(devnr));
2903 /* Probably something like the ptys which have no
2904 * symlink in /dev/char. Let's return something
2905 * vaguely useful. */
2911 if (startswith(s, "/dev/"))
2913 else if (startswith(s, "../"))
2931 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2932 _cleanup_closedir_ DIR *d = NULL;
2937 /* This returns the first error we run into, but nevertheless
2938 * tries to go on. This closes the passed fd. */
2944 return errno == ENOENT ? 0 : -errno;
2949 bool is_dir, keep_around;
2956 if (errno != 0 && ret == 0)
2961 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2964 if (de->d_type == DT_UNKNOWN ||
2966 (de->d_type == DT_DIR && root_dev)) {
2967 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2968 if (ret == 0 && errno != ENOENT)
2973 is_dir = S_ISDIR(st.st_mode);
2976 (st.st_uid == 0 || st.st_uid == getuid()) &&
2977 (st.st_mode & S_ISVTX);
2979 is_dir = de->d_type == DT_DIR;
2980 keep_around = false;
2986 /* if root_dev is set, remove subdirectories only, if device is same as dir */
2987 if (root_dev && st.st_dev != root_dev->st_dev)
2990 subdir_fd = openat(fd, de->d_name,
2991 O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2992 if (subdir_fd < 0) {
2993 if (ret == 0 && errno != ENOENT)
2998 r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2999 if (r < 0 && ret == 0)
3003 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3004 if (ret == 0 && errno != ENOENT)
3008 } else if (!only_dirs && !keep_around) {
3010 if (unlinkat(fd, de->d_name, 0) < 0) {
3011 if (ret == 0 && errno != ENOENT)
3018 _pure_ static int is_temporary_fs(struct statfs *s) {
3021 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
3022 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
3025 int is_fd_on_temporary_fs(int fd) {
3028 if (fstatfs(fd, &s) < 0)
3031 return is_temporary_fs(&s);
3034 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3039 if (fstatfs(fd, &s) < 0) {
3044 /* We refuse to clean disk file systems with this call. This
3045 * is extra paranoia just to be sure we never ever remove
3047 if (!is_temporary_fs(&s)) {
3048 log_error("Attempted to remove disk file system, and we can't allow that.");
3053 return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
3056 static int file_is_priv_sticky(const char *p) {
3061 if (lstat(p, &st) < 0)
3065 (st.st_uid == 0 || st.st_uid == getuid()) &&
3066 (st.st_mode & S_ISVTX);
3069 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
3075 /* We refuse to clean the root file system with this
3076 * call. This is extra paranoia to never cause a really
3077 * seriously broken system. */
3078 if (path_equal(path, "/")) {
3079 log_error("Attempted to remove entire root file system, and we can't allow that.");
3083 fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3086 if (errno != ENOTDIR && errno != ELOOP)
3090 if (statfs(path, &s) < 0)
3093 if (!is_temporary_fs(&s)) {
3094 log_error("Attempted to remove disk file system, and we can't allow that.");
3099 if (delete_root && !only_dirs)
3100 if (unlink(path) < 0 && errno != ENOENT)
3107 if (fstatfs(fd, &s) < 0) {
3112 if (!is_temporary_fs(&s)) {
3113 log_error("Attempted to remove disk file system, and we can't allow that.");
3119 r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
3122 if (honour_sticky && file_is_priv_sticky(path) > 0)
3125 if (rmdir(path) < 0 && errno != ENOENT) {
3134 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3135 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
3138 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3139 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
3142 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3145 /* Under the assumption that we are running privileged we
3146 * first change the access mode and only then hand out
3147 * ownership to avoid a window where access is too open. */
3149 if (mode != MODE_INVALID)
3150 if (chmod(path, mode) < 0)
3153 if (uid != UID_INVALID || gid != GID_INVALID)
3154 if (chown(path, uid, gid) < 0)
3160 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3163 /* Under the assumption that we are running privileged we
3164 * first change the access mode and only then hand out
3165 * ownership to avoid a window where access is too open. */
3167 if (mode != MODE_INVALID)
3168 if (fchmod(fd, mode) < 0)
3171 if (uid != UID_INVALID || gid != GID_INVALID)
3172 if (fchown(fd, uid, gid) < 0)
3178 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3182 /* Allocates the cpuset in the right size */
3185 if (!(r = CPU_ALLOC(n)))
3188 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3189 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3199 if (errno != EINVAL)
3206 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3207 static const char status_indent[] = " "; /* "[" STATUS "] " */
3208 _cleanup_free_ char *s = NULL;
3209 _cleanup_close_ int fd = -1;
3210 struct iovec iovec[6] = {};
3212 static bool prev_ephemeral;
3216 /* This is independent of logging, as status messages are
3217 * optional and go exclusively to the console. */
3219 if (vasprintf(&s, format, ap) < 0)
3222 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3235 sl = status ? sizeof(status_indent)-1 : 0;
3241 e = ellipsize(s, emax, 50);
3249 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3250 prev_ephemeral = ephemeral;
3253 if (!isempty(status)) {
3254 IOVEC_SET_STRING(iovec[n++], "[");
3255 IOVEC_SET_STRING(iovec[n++], status);
3256 IOVEC_SET_STRING(iovec[n++], "] ");
3258 IOVEC_SET_STRING(iovec[n++], status_indent);
3261 IOVEC_SET_STRING(iovec[n++], s);
3263 IOVEC_SET_STRING(iovec[n++], "\n");
3265 if (writev(fd, iovec, n) < 0)
3271 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3277 va_start(ap, format);
3278 r = status_vprintf(status, ellipse, ephemeral, format, ap);
3284 char *replace_env(const char *format, char **env) {
3291 const char *e, *word = format;
3296 for (e = format; *e; e ++) {
3307 k = strnappend(r, word, e-word-1);
3317 } else if (*e == '$') {
3318 k = strnappend(r, word, e-word);
3335 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3337 k = strappend(r, t);
3351 k = strnappend(r, word, e-word);
3363 char **replace_env_argv(char **argv, char **env) {
3365 unsigned k = 0, l = 0;
3367 l = strv_length(argv);
3369 ret = new(char*, l+1);
3373 STRV_FOREACH(i, argv) {
3375 /* If $FOO appears as single word, replace it by the split up variable */
3376 if ((*i)[0] == '$' && (*i)[1] != '{') {
3381 e = strv_env_get(env, *i+1);
3385 r = strv_split_quoted(&m, e, true);
3397 w = realloc(ret, sizeof(char*) * (l+1));