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>
41 #include <sys/prctl.h>
42 #include <sys/utsname.h>
44 #include <netinet/ip.h>
51 #include <sys/mount.h>
52 #include <linux/magic.h>
56 #include <sys/personality.h>
57 #include <sys/xattr.h>
58 #include <sys/statvfs.h>
62 /* When we include libgen.h because we need dirname() we immediately
63 * undefine basename() since libgen.h defines it as a macro to the XDG
64 * version which is really broken. */
68 #ifdef HAVE_SYS_AUXV_H
80 #include "path-util.h"
81 #include "exit-status.h"
85 #include "device-nodes.h"
90 #include "sparse-endian.h"
91 #include "formats-util.h"
92 #include "process-util.h"
93 #include "random-util.h"
94 #include "terminal-util.h"
95 #include "hostname-util.h"
97 /* Put this test here for a lack of better place */
98 assert_cc(EAGAIN == EWOULDBLOCK);
101 char **saved_argv = NULL;
103 size_t page_size(void) {
104 static thread_local size_t pgsz = 0;
107 if (_likely_(pgsz > 0))
110 r = sysconf(_SC_PAGESIZE);
117 bool streq_ptr(const char *a, const char *b) {
119 /* Like streq(), but tries to make sense of NULL pointers */
130 char* endswith(const char *s, const char *postfix) {
137 pl = strlen(postfix);
140 return (char*) s + sl;
145 if (memcmp(s + sl - pl, postfix, pl) != 0)
148 return (char*) s + sl - pl;
151 char* first_word(const char *s, const char *word) {
158 /* Checks if the string starts with the specified word, either
159 * followed by NUL or by whitespace. Returns a pointer to the
160 * NUL or the first character after the whitespace. */
171 if (memcmp(s, word, wl) != 0)
178 if (!strchr(WHITESPACE, *p))
181 p += strspn(p, WHITESPACE);
185 size_t cescape_char(char c, char *buf) {
186 char * buf_old = buf;
232 /* For special chars we prefer octal over
233 * hexadecimal encoding, simply because glib's
234 * g_strescape() does the same */
235 if ((c < ' ') || (c >= 127)) {
237 *(buf++) = octchar((unsigned char) c >> 6);
238 *(buf++) = octchar((unsigned char) c >> 3);
239 *(buf++) = octchar((unsigned char) c);
245 return buf - buf_old;
248 int close_nointr(int fd) {
255 * Just ignore EINTR; a retry loop is the wrong thing to do on
258 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
259 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
260 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
261 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
269 int safe_close(int fd) {
272 * Like close_nointr() but cannot fail. Guarantees errno is
273 * unchanged. Is a NOP with negative fds passed, and returns
274 * -1, so that it can be used in this syntax:
276 * fd = safe_close(fd);
282 /* The kernel might return pretty much any error code
283 * via close(), but the fd will be closed anyway. The
284 * only condition we want to check for here is whether
285 * the fd was invalid at all... */
287 assert_se(close_nointr(fd) != -EBADF);
293 void close_many(const int fds[], unsigned n_fd) {
296 assert(fds || n_fd <= 0);
298 for (i = 0; i < n_fd; i++)
302 int unlink_noerrno(const char *path) {
313 int parse_boolean(const char *v) {
316 if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
318 else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
324 int parse_pid(const char *s, pid_t* ret_pid) {
325 unsigned long ul = 0;
332 r = safe_atolu(s, &ul);
338 if ((unsigned long) pid != ul)
348 int parse_uid(const char *s, uid_t* ret_uid) {
349 unsigned long ul = 0;
355 r = safe_atolu(s, &ul);
361 if ((unsigned long) uid != ul)
364 /* Some libc APIs use UID_INVALID as special placeholder */
365 if (uid == (uid_t) 0xFFFFFFFF)
368 /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
369 if (uid == (uid_t) 0xFFFF)
378 int safe_atou(const char *s, unsigned *ret_u) {
386 l = strtoul(s, &x, 0);
388 if (!x || x == s || *x || errno)
389 return errno > 0 ? -errno : -EINVAL;
391 if ((unsigned long) (unsigned) l != l)
394 *ret_u = (unsigned) l;
398 int safe_atoi(const char *s, int *ret_i) {
406 l = strtol(s, &x, 0);
408 if (!x || x == s || *x || errno)
409 return errno > 0 ? -errno : -EINVAL;
411 if ((long) (int) l != l)
418 int safe_atou8(const char *s, uint8_t *ret) {
426 l = strtoul(s, &x, 0);
428 if (!x || x == s || *x || errno)
429 return errno > 0 ? -errno : -EINVAL;
431 if ((unsigned long) (uint8_t) l != l)
438 int safe_atou16(const char *s, uint16_t *ret) {
446 l = strtoul(s, &x, 0);
448 if (!x || x == s || *x || errno)
449 return errno > 0 ? -errno : -EINVAL;
451 if ((unsigned long) (uint16_t) l != l)
458 int safe_atoi16(const char *s, int16_t *ret) {
466 l = strtol(s, &x, 0);
468 if (!x || x == s || *x || errno)
469 return errno > 0 ? -errno : -EINVAL;
471 if ((long) (int16_t) l != l)
478 int safe_atollu(const char *s, long long unsigned *ret_llu) {
480 unsigned long long l;
486 l = strtoull(s, &x, 0);
488 if (!x || x == s || *x || errno)
489 return errno ? -errno : -EINVAL;
495 int safe_atolli(const char *s, long long int *ret_lli) {
503 l = strtoll(s, &x, 0);
505 if (!x || x == s || *x || errno)
506 return errno ? -errno : -EINVAL;
512 int safe_atod(const char *s, double *ret_d) {
520 loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
521 if (loc == (locale_t) 0)
525 d = strtod_l(s, &x, loc);
527 if (!x || x == s || *x || errno) {
529 return errno ? -errno : -EINVAL;
537 static size_t strcspn_escaped(const char *s, const char *reject) {
538 bool escaped = false;
541 for (n=0; s[n]; n++) {
544 else if (s[n] == '\\')
546 else if (strchr(reject, s[n]))
550 /* if s ends in \, return index of previous char */
554 /* Split a string into words. */
555 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
561 assert(**state == '\0');
565 current += strspn(current, separator);
571 if (quoted && strchr("\'\"", *current)) {
572 char quotechars[2] = {*current, '\0'};
574 *l = strcspn_escaped(current + 1, quotechars);
575 if (current[*l + 1] == '\0' ||
576 (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
577 /* right quote missing or garbage at the end */
581 assert(current[*l + 1] == quotechars[0]);
582 *state = current++ + *l + 2;
584 *l = strcspn_escaped(current, separator);
585 if (current[*l] && !strchr(separator, current[*l])) {
586 /* unfinished escape */
590 *state = current + *l;
592 *l = strcspn(current, separator);
593 *state = current + *l;
599 int fchmod_umask(int fd, mode_t m) {
604 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
610 char *truncate_nl(char *s) {
613 s[strcspn(s, NEWLINE)] = 0;
617 char *strnappend(const char *s, const char *suffix, size_t b) {
625 return strndup(suffix, b);
634 if (b > ((size_t) -1) - a)
637 r = new(char, a+b+1);
642 memcpy(r+a, suffix, b);
648 char *strappend(const char *s, const char *suffix) {
649 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
652 int readlinkat_malloc(int fd, const char *p, char **ret) {
667 n = readlinkat(fd, p, c, l-1);
674 if ((size_t) n < l-1) {
685 int readlink_malloc(const char *p, char **ret) {
686 return readlinkat_malloc(AT_FDCWD, p, ret);
689 int readlink_value(const char *p, char **ret) {
690 _cleanup_free_ char *link = NULL;
694 r = readlink_malloc(p, &link);
698 value = basename(link);
702 value = strdup(value);
711 int readlink_and_make_absolute(const char *p, char **r) {
712 _cleanup_free_ char *target = NULL;
719 j = readlink_malloc(p, &target);
723 k = file_in_same_dir(p, target);
731 int readlink_and_canonicalize(const char *p, char **r) {
738 j = readlink_and_make_absolute(p, &t);
742 s = canonicalize_file_name(t);
749 path_kill_slashes(*r);
754 int reset_all_signal_handlers(void) {
757 for (sig = 1; sig < _NSIG; sig++) {
758 struct sigaction sa = {
759 .sa_handler = SIG_DFL,
760 .sa_flags = SA_RESTART,
763 /* These two cannot be caught... */
764 if (sig == SIGKILL || sig == SIGSTOP)
767 /* On Linux the first two RT signals are reserved by
768 * glibc, and sigaction() will return EINVAL for them. */
769 if ((sigaction(sig, &sa, NULL) < 0))
770 if (errno != EINVAL && r == 0)
777 int reset_signal_mask(void) {
780 if (sigemptyset(&ss) < 0)
783 if (sigprocmask(SIG_SETMASK, &ss, NULL) < 0)
789 char *strstrip(char *s) {
792 /* Drops trailing whitespace. Modifies the string in
793 * place. Returns pointer to first non-space character */
795 s += strspn(s, WHITESPACE);
797 for (e = strchr(s, 0); e > s; e --)
798 if (!strchr(WHITESPACE, e[-1]))
806 char *delete_chars(char *s, const char *bad) {
809 /* Drops all whitespace, regardless where in the string */
811 for (f = s, t = s; *f; f++) {
823 char *file_in_same_dir(const char *path, const char *filename) {
830 /* This removes the last component of path and appends
831 * filename, unless the latter is absolute anyway or the
834 if (path_is_absolute(filename))
835 return strdup(filename);
837 e = strrchr(path, '/');
839 return strdup(filename);
841 k = strlen(filename);
842 ret = new(char, (e + 1 - path) + k + 1);
846 memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);
850 int rmdir_parents(const char *path, const char *stop) {
859 /* Skip trailing slashes */
860 while (l > 0 && path[l-1] == '/')
866 /* Skip last component */
867 while (l > 0 && path[l-1] != '/')
870 /* Skip trailing slashes */
871 while (l > 0 && path[l-1] == '/')
877 if (!(t = strndup(path, l)))
880 if (path_startswith(stop, t)) {
896 char hexchar(int x) {
897 static const char table[16] = "0123456789abcdef";
899 return table[x & 15];
902 int unhexchar(char c) {
904 if (c >= '0' && c <= '9')
907 if (c >= 'a' && c <= 'f')
910 if (c >= 'A' && c <= 'F')
916 char *hexmem(const void *p, size_t l) {
920 z = r = malloc(l * 2 + 1);
924 for (x = p; x < (const uint8_t*) p + l; x++) {
925 *(z++) = hexchar(*x >> 4);
926 *(z++) = hexchar(*x & 15);
933 void *unhexmem(const char *p, size_t l) {
939 z = r = malloc((l + 1) / 2 + 1);
943 for (x = p; x < p + l; x += 2) {
952 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
959 char octchar(int x) {
960 return '0' + (x & 7);
963 int unoctchar(char c) {
965 if (c >= '0' && c <= '7')
971 char decchar(int x) {
972 return '0' + (x % 10);
975 int undecchar(char c) {
977 if (c >= '0' && c <= '9')
983 char *cescape(const char *s) {
989 /* Does C style string escaping. May be reversed with
992 r = new(char, strlen(s)*4 + 1);
996 for (f = s, t = r; *f; f++)
997 t += cescape_char(*f, t);
1004 static int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode) {
1011 /* Unescapes C style. Returns the unescaped character in ret,
1012 * unless we encountered a \u sequence in which case the full
1013 * unicode character is returned in ret_unicode, instead. */
1015 if (length != (size_t) -1 && length < 1)
1052 /* This is an extension of the XDG syntax files */
1057 /* hexadecimal encoding */
1060 if (length != (size_t) -1 && length < 3)
1063 a = unhexchar(p[1]);
1067 b = unhexchar(p[2]);
1071 /* Don't allow NUL bytes */
1072 if (a == 0 && b == 0)
1075 *ret = (char) ((a << 4U) | b);
1081 /* C++11 style 16bit unicode */
1087 if (length != (size_t) -1 && length < 5)
1090 for (i = 0; i < 4; i++) {
1091 a[i] = unhexchar(p[1 + i]);
1096 c = ((uint32_t) a[0] << 12U) | ((uint32_t) a[1] << 8U) | ((uint32_t) a[2] << 4U) | (uint32_t) a[3];
1098 /* Don't allow 0 chars */
1117 /* C++11 style 32bit unicode */
1123 if (length != (size_t) -1 && length < 9)
1126 for (i = 0; i < 8; i++) {
1127 a[i] = unhexchar(p[1 + i]);
1132 c = ((uint32_t) a[0] << 28U) | ((uint32_t) a[1] << 24U) | ((uint32_t) a[2] << 20U) | ((uint32_t) a[3] << 16U) |
1133 ((uint32_t) a[4] << 12U) | ((uint32_t) a[5] << 8U) | ((uint32_t) a[6] << 4U) | (uint32_t) a[7];
1135 /* Don't allow 0 chars */
1139 /* Don't allow invalid code points */
1140 if (!unichar_is_valid(c))
1165 /* octal encoding */
1169 if (length != (size_t) -1 && length < 4)
1172 a = unoctchar(p[0]);
1176 b = unoctchar(p[1]);
1180 c = unoctchar(p[2]);
1184 /* don't allow NUL bytes */
1185 if (a == 0 && b == 0 && c == 0)
1188 /* Don't allow bytes above 255 */
1189 m = ((uint32_t) a << 6U) | ((uint32_t) b << 3U) | (uint32_t) c;
1205 int cunescape_length_with_prefix(const char *s, size_t length, const char *prefix, UnescapeFlags flags, char **ret) {
1213 /* Undoes C style string escaping, and optionally prefixes it. */
1215 pl = prefix ? strlen(prefix) : 0;
1217 r = new(char, pl+length+1);
1222 memcpy(r, prefix, pl);
1224 for (f = s, t = r + pl; f < s + length; f++) {
1230 remaining = s + length - f;
1231 assert(remaining > 0);
1234 /* A literal literal, copy verbatim */
1239 if (remaining == 1) {
1240 if (flags & UNESCAPE_RELAX) {
1241 /* A trailing backslash, copy verbatim */
1250 k = cunescape_one(f + 1, remaining - 1, &c, &u);
1252 if (flags & UNESCAPE_RELAX) {
1253 /* Invalid escape code, let's take it literal then */
1263 /* Non-Unicode? Let's encode this directly */
1266 /* Unicode? Then let's encode this in UTF-8 */
1267 t += utf8_encode_unichar(t, u);
1278 int cunescape_length(const char *s, size_t length, UnescapeFlags flags, char **ret) {
1279 return cunescape_length_with_prefix(s, length, NULL, flags, ret);
1282 int cunescape(const char *s, UnescapeFlags flags, char **ret) {
1283 return cunescape_length(s, strlen(s), flags, ret);
1286 char *xescape(const char *s, const char *bad) {
1290 /* Escapes all chars in bad, in addition to \ and all special
1291 * chars, in \xFF style escaping. May be reversed with
1294 r = new(char, strlen(s) * 4 + 1);
1298 for (f = s, t = r; *f; f++) {
1300 if ((*f < ' ') || (*f >= 127) ||
1301 (*f == '\\') || strchr(bad, *f)) {
1304 *(t++) = hexchar(*f >> 4);
1305 *(t++) = hexchar(*f);
1315 char *ascii_strlower(char *t) {
1320 for (p = t; *p; p++)
1321 if (*p >= 'A' && *p <= 'Z')
1322 *p = *p - 'A' + 'a';
1327 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1331 filename[0] == '.' ||
1332 streq(filename, "lost+found") ||
1333 streq(filename, "aquota.user") ||
1334 streq(filename, "aquota.group") ||
1335 endswith(filename, ".rpmnew") ||
1336 endswith(filename, ".rpmsave") ||
1337 endswith(filename, ".rpmorig") ||
1338 endswith(filename, ".dpkg-old") ||
1339 endswith(filename, ".dpkg-new") ||
1340 endswith(filename, ".dpkg-tmp") ||
1341 endswith(filename, ".dpkg-dist") ||
1342 endswith(filename, ".dpkg-bak") ||
1343 endswith(filename, ".dpkg-backup") ||
1344 endswith(filename, ".dpkg-remove") ||
1345 endswith(filename, ".swp");
1348 bool hidden_file(const char *filename) {
1351 if (endswith(filename, "~"))
1354 return hidden_file_allow_backup(filename);
1357 int fd_nonblock(int fd, bool nonblock) {
1362 flags = fcntl(fd, F_GETFL, 0);
1367 nflags = flags | O_NONBLOCK;
1369 nflags = flags & ~O_NONBLOCK;
1371 if (nflags == flags)
1374 if (fcntl(fd, F_SETFL, nflags) < 0)
1380 int fd_cloexec(int fd, bool cloexec) {
1385 flags = fcntl(fd, F_GETFD, 0);
1390 nflags = flags | FD_CLOEXEC;
1392 nflags = flags & ~FD_CLOEXEC;
1394 if (nflags == flags)
1397 if (fcntl(fd, F_SETFD, nflags) < 0)
1403 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1406 assert(n_fdset == 0 || fdset);
1408 for (i = 0; i < n_fdset; i++)
1415 int close_all_fds(const int except[], unsigned n_except) {
1416 _cleanup_closedir_ DIR *d = NULL;
1420 assert(n_except == 0 || except);
1422 d = opendir("/proc/self/fd");
1427 /* When /proc isn't available (for example in chroots)
1428 * the fallback is brute forcing through the fd
1431 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1432 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1434 if (fd_in_set(fd, except, n_except))
1437 if (close_nointr(fd) < 0)
1438 if (errno != EBADF && r == 0)
1445 while ((de = readdir(d))) {
1448 if (hidden_file(de->d_name))
1451 if (safe_atoi(de->d_name, &fd) < 0)
1452 /* Let's better ignore this, just in case */
1461 if (fd_in_set(fd, except, n_except))
1464 if (close_nointr(fd) < 0) {
1465 /* Valgrind has its own FD and doesn't want to have it closed */
1466 if (errno != EBADF && r == 0)
1474 bool chars_intersect(const char *a, const char *b) {
1477 /* Returns true if any of the chars in a are in b. */
1478 for (p = a; *p; p++)
1485 bool fstype_is_network(const char *fstype) {
1486 static const char table[] =
1501 x = startswith(fstype, "fuse.");
1505 return nulstr_contains(table, fstype);
1508 int flush_fd(int fd) {
1509 struct pollfd pollfd = {
1519 r = poll(&pollfd, 1, 0);
1529 l = read(fd, buf, sizeof(buf));
1535 if (errno == EAGAIN)
1544 int sigaction_many(const struct sigaction *sa, ...) {
1549 while ((sig = va_arg(ap, int)) > 0)
1550 if (sigaction(sig, sa, NULL) < 0)
1557 int ignore_signals(int sig, ...) {
1558 struct sigaction sa = {
1559 .sa_handler = SIG_IGN,
1560 .sa_flags = SA_RESTART,
1565 if (sigaction(sig, &sa, NULL) < 0)
1569 while ((sig = va_arg(ap, int)) > 0)
1570 if (sigaction(sig, &sa, NULL) < 0)
1577 int default_signals(int sig, ...) {
1578 struct sigaction sa = {
1579 .sa_handler = SIG_DFL,
1580 .sa_flags = SA_RESTART,
1585 if (sigaction(sig, &sa, NULL) < 0)
1589 while ((sig = va_arg(ap, int)) > 0)
1590 if (sigaction(sig, &sa, NULL) < 0)
1597 void safe_close_pair(int p[]) {
1601 /* Special case pairs which use the same fd in both
1603 p[0] = p[1] = safe_close(p[0]);
1607 p[0] = safe_close(p[0]);
1608 p[1] = safe_close(p[1]);
1611 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
1618 while (nbytes > 0) {
1621 k = read(fd, p, nbytes);
1626 if (errno == EAGAIN && do_poll) {
1628 /* We knowingly ignore any return value here,
1629 * and expect that any error/EOF is reported
1632 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
1636 return n > 0 ? n : -errno;
1650 int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll) {
1653 n = loop_read(fd, buf, nbytes, do_poll);
1656 if ((size_t) n != nbytes)
1661 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
1662 const uint8_t *p = buf;
1672 k = write(fd, p, nbytes);
1677 if (errno == EAGAIN && do_poll) {
1678 /* We knowingly ignore any return value here,
1679 * and expect that any error/EOF is reported
1682 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
1689 if (nbytes > 0 && k == 0) /* Can't really happen */
1694 } while (nbytes > 0);
1699 int parse_size(const char *t, off_t base, off_t *size) {
1701 /* Soo, sometimes we want to parse IEC binary suffixes, and
1702 * sometimes SI decimal suffixes. This function can parse
1703 * both. Which one is the right way depends on the
1704 * context. Wikipedia suggests that SI is customary for
1705 * hardware metrics and network speeds, while IEC is
1706 * customary for most data sizes used by software and volatile
1707 * (RAM) memory. Hence be careful which one you pick!
1709 * In either case we use just K, M, G as suffix, and not Ki,
1710 * Mi, Gi or so (as IEC would suggest). That's because that's
1711 * frickin' ugly. But this means you really need to make sure
1712 * to document which base you are parsing when you use this
1717 unsigned long long factor;
1720 static const struct table iec[] = {
1721 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
1722 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
1723 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
1724 { "G", 1024ULL*1024ULL*1024ULL },
1725 { "M", 1024ULL*1024ULL },
1731 static const struct table si[] = {
1732 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
1733 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
1734 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
1735 { "G", 1000ULL*1000ULL*1000ULL },
1736 { "M", 1000ULL*1000ULL },
1742 const struct table *table;
1744 unsigned long long r = 0;
1745 unsigned n_entries, start_pos = 0;
1748 assert(base == 1000 || base == 1024);
1753 n_entries = ELEMENTSOF(si);
1756 n_entries = ELEMENTSOF(iec);
1762 unsigned long long l2;
1768 l = strtoll(p, &e, 10);
1781 if (*e >= '0' && *e <= '9') {
1784 /* strotoull itself would accept space/+/- */
1785 l2 = strtoull(e, &e2, 10);
1787 if (errno == ERANGE)
1790 /* Ignore failure. E.g. 10.M is valid */
1797 e += strspn(e, WHITESPACE);
1799 for (i = start_pos; i < n_entries; i++)
1800 if (startswith(e, table[i].suffix)) {
1801 unsigned long long tmp;
1802 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
1804 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
1805 if (tmp > ULLONG_MAX - r)
1809 if ((unsigned long long) (off_t) r != r)
1812 p = e + strlen(table[i].suffix);
1828 bool is_device_path(const char *path) {
1830 /* Returns true on paths that refer to a device, either in
1831 * sysfs or in /dev */
1834 path_startswith(path, "/dev/") ||
1835 path_startswith(path, "/sys/");
1838 int dir_is_empty(const char *path) {
1839 _cleanup_closedir_ DIR *d;
1850 if (!de && errno != 0)
1856 if (!hidden_file(de->d_name))
1861 char* dirname_malloc(const char *path) {
1862 char *d, *dir, *dir2;
1879 void rename_process(const char name[8]) {
1882 /* This is a like a poor man's setproctitle(). It changes the
1883 * comm field, argv[0], and also the glibc's internally used
1884 * name of the process. For the first one a limit of 16 chars
1885 * applies, to the second one usually one of 10 (i.e. length
1886 * of "/sbin/init"), to the third one one of 7 (i.e. length of
1887 * "systemd"). If you pass a longer string it will be
1890 prctl(PR_SET_NAME, name);
1892 if (program_invocation_name)
1893 strncpy(program_invocation_name, name, strlen(program_invocation_name));
1895 if (saved_argc > 0) {
1899 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
1901 for (i = 1; i < saved_argc; i++) {
1905 memzero(saved_argv[i], strlen(saved_argv[i]));
1910 void sigset_add_many(sigset_t *ss, ...) {
1917 while ((sig = va_arg(ap, int)) > 0)
1918 assert_se(sigaddset(ss, sig) == 0);
1922 int sigprocmask_many(int how, ...) {
1927 assert_se(sigemptyset(&ss) == 0);
1930 while ((sig = va_arg(ap, int)) > 0)
1931 assert_se(sigaddset(&ss, sig) == 0);
1934 if (sigprocmask(how, &ss, NULL) < 0)
1939 char *lookup_uid(uid_t uid) {
1942 _cleanup_free_ char *buf = NULL;
1943 struct passwd pwbuf, *pw = NULL;
1945 /* Shortcut things to avoid NSS lookups */
1947 return strdup("root");
1949 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
1953 buf = malloc(bufsize);
1957 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
1958 return strdup(pw->pw_name);
1960 if (asprintf(&name, UID_FMT, uid) < 0)
1966 char* getlogname_malloc(void) {
1970 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
1975 return lookup_uid(uid);
1978 char *getusername_malloc(void) {
1985 return lookup_uid(getuid());
1988 bool is_temporary_fs(const struct statfs *s) {
1991 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
1992 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
1995 int fd_is_temporary_fs(int fd) {
1998 if (fstatfs(fd, &s) < 0)
2001 return is_temporary_fs(&s);
2004 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2007 /* Under the assumption that we are running privileged we
2008 * first change the access mode and only then hand out
2009 * ownership to avoid a window where access is too open. */
2011 if (mode != MODE_INVALID)
2012 if (chmod(path, mode) < 0)
2015 if (uid != UID_INVALID || gid != GID_INVALID)
2016 if (chown(path, uid, gid) < 0)
2022 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2025 /* Under the assumption that we are running privileged we
2026 * first change the access mode and only then hand out
2027 * ownership to avoid a window where access is too open. */
2029 if (mode != MODE_INVALID)
2030 if (fchmod(fd, mode) < 0)
2033 if (uid != UID_INVALID || gid != GID_INVALID)
2034 if (fchown(fd, uid, gid) < 0)
2040 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2044 /* Allocates the cpuset in the right size */
2047 if (!(r = CPU_ALLOC(n)))
2050 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2051 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2061 if (errno != EINVAL)
2068 int files_same(const char *filea, const char *fileb) {
2071 if (stat(filea, &a) < 0)
2074 if (stat(fileb, &b) < 0)
2077 return a.st_dev == b.st_dev &&
2078 a.st_ino == b.st_ino;
2081 int running_in_chroot(void) {
2084 ret = files_same("/proc/1/root", "/");
2091 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
2096 assert(percent <= 100);
2097 assert(new_length >= 3);
2099 if (old_length <= 3 || old_length <= new_length)
2100 return strndup(s, old_length);
2102 r = new0(char, new_length+1);
2106 x = (new_length * percent) / 100;
2108 if (x > new_length - 3)
2116 s + old_length - (new_length - x - 3),
2117 new_length - x - 3);
2122 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
2126 unsigned k, len, len2;
2129 assert(percent <= 100);
2130 assert(new_length >= 3);
2132 /* if no multibyte characters use ascii_ellipsize_mem for speed */
2133 if (ascii_is_valid(s))
2134 return ascii_ellipsize_mem(s, old_length, new_length, percent);
2136 if (old_length <= 3 || old_length <= new_length)
2137 return strndup(s, old_length);
2139 x = (new_length * percent) / 100;
2141 if (x > new_length - 3)
2145 for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
2148 c = utf8_encoded_to_unichar(i);
2151 k += unichar_iswide(c) ? 2 : 1;
2154 if (k > x) /* last character was wide and went over quota */
2157 for (j = s + old_length; k < new_length && j > i; ) {
2160 j = utf8_prev_char(j);
2161 c = utf8_encoded_to_unichar(j);
2164 k += unichar_iswide(c) ? 2 : 1;
2168 /* we don't actually need to ellipsize */
2170 return memdup(s, old_length + 1);
2172 /* make space for ellipsis */
2173 j = utf8_next_char(j);
2176 len2 = s + old_length - j;
2177 e = new(char, len + 3 + len2 + 1);
2182 printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
2183 old_length, new_length, x, len, len2, k);
2187 e[len] = 0xe2; /* tri-dot ellipsis: … */
2191 memcpy(e + len + 3, j, len2 + 1);
2196 char *ellipsize(const char *s, size_t length, unsigned percent) {
2197 return ellipsize_mem(s, strlen(s), length, percent);
2200 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
2201 _cleanup_close_ int fd;
2207 mkdir_parents(path, 0755);
2209 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
2214 r = fchmod(fd, mode);
2219 if (uid != UID_INVALID || gid != GID_INVALID) {
2220 r = fchown(fd, uid, gid);
2225 if (stamp != USEC_INFINITY) {
2226 struct timespec ts[2];
2228 timespec_store(&ts[0], stamp);
2230 r = futimens(fd, ts);
2232 r = futimens(fd, NULL);
2239 int touch(const char *path) {
2240 return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
2243 static char *unquote(const char *s, const char* quotes) {
2247 /* This is rather stupid, simply removes the heading and
2248 * trailing quotes if there is one. Doesn't care about
2249 * escaping or anything.
2251 * DON'T USE THIS FOR NEW CODE ANYMORE!*/
2257 if (strchr(quotes, s[0]) && s[l-1] == s[0])
2258 return strndup(s+1, l-2);
2263 noreturn void freeze(void) {
2265 /* Make sure nobody waits for us on a socket anymore */
2266 close_all_fds(NULL, 0);
2274 bool null_or_empty(struct stat *st) {
2277 if (S_ISREG(st->st_mode) && st->st_size <= 0)
2280 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
2286 int null_or_empty_path(const char *fn) {
2291 if (stat(fn, &st) < 0)
2294 return null_or_empty(&st);
2297 int null_or_empty_fd(int fd) {
2302 if (fstat(fd, &st) < 0)
2305 return null_or_empty(&st);
2308 DIR *xopendirat(int fd, const char *name, int flags) {
2312 assert(!(flags & O_CREAT));
2314 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
2327 int signal_from_string_try_harder(const char *s) {
2331 signo = signal_from_string(s);
2333 if (startswith(s, "SIG"))
2334 return signal_from_string(s+3);
2339 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
2340 _cleanup_free_ char *t = NULL, *u = NULL;
2343 u = unquote(tagvalue, QUOTES);
2347 enc_len = strlen(u) * 4 + 1;
2348 t = new(char, enc_len);
2352 if (encode_devnode_name(u, t, enc_len) < 0)
2355 return strjoin("/dev/disk/by-", by, "/", t, NULL);
2358 char *fstab_node_to_udev_node(const char *p) {
2361 if (startswith(p, "LABEL="))
2362 return tag_to_udev_node(p+6, "label");
2364 if (startswith(p, "UUID="))
2365 return tag_to_udev_node(p+5, "uuid");
2367 if (startswith(p, "PARTUUID="))
2368 return tag_to_udev_node(p+9, "partuuid");
2370 if (startswith(p, "PARTLABEL="))
2371 return tag_to_udev_node(p+10, "partlabel");
2376 bool dirent_is_file(const struct dirent *de) {
2379 if (hidden_file(de->d_name))
2382 if (de->d_type != DT_REG &&
2383 de->d_type != DT_LNK &&
2384 de->d_type != DT_UNKNOWN)
2390 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
2393 if (de->d_type != DT_REG &&
2394 de->d_type != DT_LNK &&
2395 de->d_type != DT_UNKNOWN)
2398 if (hidden_file_allow_backup(de->d_name))
2401 return endswith(de->d_name, suffix);
2404 static int do_execute(char **directories, usec_t timeout, char *argv[]) {
2405 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
2406 _cleanup_set_free_free_ Set *seen = NULL;
2409 /* We fork this all off from a child process so that we can
2410 * somewhat cleanly make use of SIGALRM to set a time limit */
2412 reset_all_signal_handlers();
2413 reset_signal_mask();
2415 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
2417 pids = hashmap_new(NULL);
2421 seen = set_new(&string_hash_ops);
2425 STRV_FOREACH(directory, directories) {
2426 _cleanup_closedir_ DIR *d;
2429 d = opendir(*directory);
2431 if (errno == ENOENT)
2434 return log_error_errno(errno, "Failed to open directory %s: %m", *directory);
2437 FOREACH_DIRENT(de, d, break) {
2438 _cleanup_free_ char *path = NULL;
2442 if (!dirent_is_file(de))
2445 if (set_contains(seen, de->d_name)) {
2446 log_debug("%1$s/%2$s skipped (%2$s was already seen).", *directory, de->d_name);
2450 r = set_put_strdup(seen, de->d_name);
2454 path = strjoin(*directory, "/", de->d_name, NULL);
2458 if (null_or_empty_path(path)) {
2459 log_debug("%s is empty (a mask).", path);
2465 log_error_errno(errno, "Failed to fork: %m");
2467 } else if (pid == 0) {
2470 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
2480 return log_error_errno(errno, "Failed to execute %s: %m", path);
2483 log_debug("Spawned %s as " PID_FMT ".", path, pid);
2485 r = hashmap_put(pids, UINT_TO_PTR(pid), path);
2492 /* Abort execution of this process after the timout. We simply
2493 * rely on SIGALRM as default action terminating the process,
2494 * and turn on alarm(). */
2496 if (timeout != USEC_INFINITY)
2497 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
2499 while (!hashmap_isempty(pids)) {
2500 _cleanup_free_ char *path = NULL;
2503 pid = PTR_TO_UINT(hashmap_first_key(pids));
2506 path = hashmap_remove(pids, UINT_TO_PTR(pid));
2509 wait_for_terminate_and_warn(path, pid, true);
2515 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]) {
2519 char **dirs = (char**) directories;
2521 assert(!strv_isempty(dirs));
2523 name = basename(dirs[0]);
2524 assert(!isempty(name));
2526 /* Executes all binaries in the directories in parallel and waits
2527 * for them to finish. Optionally a timeout is applied. If a file
2528 * with the same name exists in more than one directory, the
2529 * earliest one wins. */
2531 executor_pid = fork();
2532 if (executor_pid < 0) {
2533 log_error_errno(errno, "Failed to fork: %m");
2536 } else if (executor_pid == 0) {
2537 r = do_execute(dirs, timeout, argv);
2538 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
2541 wait_for_terminate_and_warn(name, executor_pid, true);
2544 bool nulstr_contains(const char*nulstr, const char *needle) {
2550 NULSTR_FOREACH(i, nulstr)
2551 if (streq(i, needle))
2557 bool plymouth_running(void) {
2558 return access("/run/plymouth/pid", F_OK) >= 0;
2561 char* strshorten(char *s, size_t l) {
2570 bool machine_name_is_valid(const char *s) {
2572 if (!hostname_is_valid(s))
2575 /* Machine names should be useful hostnames, but also be
2576 * useful in unit names, hence we enforce a stricter length
2585 int pipe_eof(int fd) {
2586 struct pollfd pollfd = {
2588 .events = POLLIN|POLLHUP,
2593 r = poll(&pollfd, 1, 0);
2600 return pollfd.revents & POLLHUP;
2603 int fd_wait_for_event(int fd, int event, usec_t t) {
2605 struct pollfd pollfd = {
2613 r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
2620 return pollfd.revents;
2623 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
2632 r = tempfn_xxxxxx(path, &t);
2636 fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
2642 f = fdopen(fd, "we");
2655 int symlink_atomic(const char *from, const char *to) {
2656 _cleanup_free_ char *t = NULL;
2662 r = tempfn_random(to, &t);
2666 if (symlink(from, t) < 0)
2669 if (rename(t, to) < 0) {
2677 int symlink_idempotent(const char *from, const char *to) {
2678 _cleanup_free_ char *p = NULL;
2684 if (symlink(from, to) < 0) {
2685 if (errno != EEXIST)
2688 r = readlink_malloc(to, &p);
2692 if (!streq(p, from))
2699 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
2700 _cleanup_free_ char *t = NULL;
2705 r = tempfn_random(path, &t);
2709 if (mknod(t, mode, dev) < 0)
2712 if (rename(t, path) < 0) {
2720 int mkfifo_atomic(const char *path, mode_t mode) {
2721 _cleanup_free_ char *t = NULL;
2726 r = tempfn_random(path, &t);
2730 if (mkfifo(t, mode) < 0)
2733 if (rename(t, path) < 0) {
2741 bool display_is_local(const char *display) {
2745 display[0] == ':' &&
2746 display[1] >= '0' &&
2750 int socket_from_display(const char *display, char **path) {
2757 if (!display_is_local(display))
2760 k = strspn(display+1, "0123456789");
2762 f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
2766 c = stpcpy(f, "/tmp/.X11-unix/X");
2767 memcpy(c, display+1, k);
2776 const char **username,
2777 uid_t *uid, gid_t *gid,
2779 const char **shell) {
2787 /* We enforce some special rules for uid=0: in order to avoid
2788 * NSS lookups for root we hardcode its data. */
2790 if (streq(*username, "root") || streq(*username, "0")) {
2808 if (parse_uid(*username, &u) >= 0) {
2812 /* If there are multiple users with the same id, make
2813 * sure to leave $USER to the configured value instead
2814 * of the first occurrence in the database. However if
2815 * the uid was configured by a numeric uid, then let's
2816 * pick the real username from /etc/passwd. */
2818 *username = p->pw_name;
2821 p = getpwnam(*username);
2825 return errno > 0 ? -errno : -ESRCH;
2837 *shell = p->pw_shell;
2842 char* uid_to_name(uid_t uid) {
2847 return strdup("root");
2851 return strdup(p->pw_name);
2853 if (asprintf(&r, UID_FMT, uid) < 0)
2859 char* gid_to_name(gid_t gid) {
2864 return strdup("root");
2868 return strdup(p->gr_name);
2870 if (asprintf(&r, GID_FMT, gid) < 0)
2876 int get_group_creds(const char **groupname, gid_t *gid) {
2882 /* We enforce some special rules for gid=0: in order to avoid
2883 * NSS lookups for root we hardcode its data. */
2885 if (streq(*groupname, "root") || streq(*groupname, "0")) {
2886 *groupname = "root";
2894 if (parse_gid(*groupname, &id) >= 0) {
2899 *groupname = g->gr_name;
2902 g = getgrnam(*groupname);
2906 return errno > 0 ? -errno : -ESRCH;
2914 int in_gid(gid_t gid) {
2916 int ngroups_max, r, i;
2918 if (getgid() == gid)
2921 if (getegid() == gid)
2924 ngroups_max = sysconf(_SC_NGROUPS_MAX);
2925 assert(ngroups_max > 0);
2927 gids = alloca(sizeof(gid_t) * ngroups_max);
2929 r = getgroups(ngroups_max, gids);
2933 for (i = 0; i < r; i++)
2940 int in_group(const char *name) {
2944 r = get_group_creds(&name, &gid);
2951 int glob_exists(const char *path) {
2952 _cleanup_globfree_ glob_t g = {};
2958 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
2960 if (k == GLOB_NOMATCH)
2962 else if (k == GLOB_NOSPACE)
2965 return !strv_isempty(g.gl_pathv);
2967 return errno ? -errno : -EIO;
2970 int glob_extend(char ***strv, const char *path) {
2971 _cleanup_globfree_ glob_t g = {};
2976 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
2978 if (k == GLOB_NOMATCH)
2980 else if (k == GLOB_NOSPACE)
2982 else if (k != 0 || strv_isempty(g.gl_pathv))
2983 return errno ? -errno : -EIO;
2985 STRV_FOREACH(p, g.gl_pathv) {
2986 k = strv_extend(strv, *p);
2994 int dirent_ensure_type(DIR *d, struct dirent *de) {
3000 if (de->d_type != DT_UNKNOWN)
3003 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
3007 S_ISREG(st.st_mode) ? DT_REG :
3008 S_ISDIR(st.st_mode) ? DT_DIR :
3009 S_ISLNK(st.st_mode) ? DT_LNK :
3010 S_ISFIFO(st.st_mode) ? DT_FIFO :
3011 S_ISSOCK(st.st_mode) ? DT_SOCK :
3012 S_ISCHR(st.st_mode) ? DT_CHR :
3013 S_ISBLK(st.st_mode) ? DT_BLK :
3019 int get_files_in_directory(const char *path, char ***list) {
3020 _cleanup_closedir_ DIR *d = NULL;
3021 size_t bufsize = 0, n = 0;
3022 _cleanup_strv_free_ char **l = NULL;
3026 /* Returns all files in a directory in *list, and the number
3027 * of files as return value. If list is NULL returns only the
3039 if (!de && errno != 0)
3044 dirent_ensure_type(d, de);
3046 if (!dirent_is_file(de))
3050 /* one extra slot is needed for the terminating NULL */
3051 if (!GREEDY_REALLOC(l, bufsize, n + 2))
3054 l[n] = strdup(de->d_name);
3065 l = NULL; /* avoid freeing */
3071 char *strjoin(const char *x, ...) {
3085 t = va_arg(ap, const char *);
3090 if (n > ((size_t) -1) - l) {
3114 t = va_arg(ap, const char *);
3128 bool is_main_thread(void) {
3129 static thread_local int cached = 0;
3131 if (_unlikely_(cached == 0))
3132 cached = getpid() == gettid() ? 1 : -1;
3137 int block_get_whole_disk(dev_t d, dev_t *ret) {
3144 /* If it has a queue this is good enough for us */
3145 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
3148 r = access(p, F_OK);
3156 /* If it is a partition find the originating device */
3157 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
3160 r = access(p, F_OK);
3166 /* Get parent dev_t */
3167 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
3170 r = read_one_line_file(p, &s);
3176 r = sscanf(s, "%u:%u", &m, &n);
3182 /* Only return this if it is really good enough for us. */
3183 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
3186 r = access(p, F_OK);
3190 *ret = makedev(m, n);
3197 static const char *const ioprio_class_table[] = {
3198 [IOPRIO_CLASS_NONE] = "none",
3199 [IOPRIO_CLASS_RT] = "realtime",
3200 [IOPRIO_CLASS_BE] = "best-effort",
3201 [IOPRIO_CLASS_IDLE] = "idle"
3204 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
3206 static const char *const sigchld_code_table[] = {
3207 [CLD_EXITED] = "exited",
3208 [CLD_KILLED] = "killed",
3209 [CLD_DUMPED] = "dumped",
3210 [CLD_TRAPPED] = "trapped",
3211 [CLD_STOPPED] = "stopped",
3212 [CLD_CONTINUED] = "continued",
3215 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
3217 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
3218 [LOG_FAC(LOG_KERN)] = "kern",
3219 [LOG_FAC(LOG_USER)] = "user",
3220 [LOG_FAC(LOG_MAIL)] = "mail",
3221 [LOG_FAC(LOG_DAEMON)] = "daemon",
3222 [LOG_FAC(LOG_AUTH)] = "auth",
3223 [LOG_FAC(LOG_SYSLOG)] = "syslog",
3224 [LOG_FAC(LOG_LPR)] = "lpr",
3225 [LOG_FAC(LOG_NEWS)] = "news",
3226 [LOG_FAC(LOG_UUCP)] = "uucp",
3227 [LOG_FAC(LOG_CRON)] = "cron",
3228 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
3229 [LOG_FAC(LOG_FTP)] = "ftp",
3230 [LOG_FAC(LOG_LOCAL0)] = "local0",
3231 [LOG_FAC(LOG_LOCAL1)] = "local1",
3232 [LOG_FAC(LOG_LOCAL2)] = "local2",
3233 [LOG_FAC(LOG_LOCAL3)] = "local3",
3234 [LOG_FAC(LOG_LOCAL4)] = "local4",
3235 [LOG_FAC(LOG_LOCAL5)] = "local5",
3236 [LOG_FAC(LOG_LOCAL6)] = "local6",
3237 [LOG_FAC(LOG_LOCAL7)] = "local7"
3240 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
3242 static const char *const log_level_table[] = {
3243 [LOG_EMERG] = "emerg",
3244 [LOG_ALERT] = "alert",
3245 [LOG_CRIT] = "crit",
3247 [LOG_WARNING] = "warning",
3248 [LOG_NOTICE] = "notice",
3249 [LOG_INFO] = "info",
3250 [LOG_DEBUG] = "debug"
3253 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
3255 static const char* const sched_policy_table[] = {
3256 [SCHED_OTHER] = "other",
3257 [SCHED_BATCH] = "batch",
3258 [SCHED_IDLE] = "idle",
3259 [SCHED_FIFO] = "fifo",
3263 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
3265 static const char* const rlimit_table[_RLIMIT_MAX] = {
3266 [RLIMIT_CPU] = "LimitCPU",
3267 [RLIMIT_FSIZE] = "LimitFSIZE",
3268 [RLIMIT_DATA] = "LimitDATA",
3269 [RLIMIT_STACK] = "LimitSTACK",
3270 [RLIMIT_CORE] = "LimitCORE",
3271 [RLIMIT_RSS] = "LimitRSS",
3272 [RLIMIT_NOFILE] = "LimitNOFILE",
3273 [RLIMIT_AS] = "LimitAS",
3274 [RLIMIT_NPROC] = "LimitNPROC",
3275 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
3276 [RLIMIT_LOCKS] = "LimitLOCKS",
3277 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
3278 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
3279 [RLIMIT_NICE] = "LimitNICE",
3280 [RLIMIT_RTPRIO] = "LimitRTPRIO",
3281 [RLIMIT_RTTIME] = "LimitRTTIME"
3284 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
3286 static const char* const ip_tos_table[] = {
3287 [IPTOS_LOWDELAY] = "low-delay",
3288 [IPTOS_THROUGHPUT] = "throughput",
3289 [IPTOS_RELIABILITY] = "reliability",
3290 [IPTOS_LOWCOST] = "low-cost",
3293 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
3295 static const char *const __signal_table[] = {
3312 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
3323 [SIGVTALRM] = "VTALRM",
3325 [SIGWINCH] = "WINCH",
3331 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
3333 const char *signal_to_string(int signo) {
3334 static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
3337 name = __signal_to_string(signo);
3341 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
3342 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
3344 snprintf(buf, sizeof(buf), "%d", signo);
3349 int signal_from_string(const char *s) {
3354 signo = __signal_from_string(s);
3358 if (startswith(s, "RTMIN+")) {
3362 if (safe_atou(s, &u) >= 0) {
3363 signo = (int) u + offset;
3364 if (signo > 0 && signo < _NSIG)
3370 bool kexec_loaded(void) {
3371 bool loaded = false;
3374 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
3382 int prot_from_flags(int flags) {
3384 switch (flags & O_ACCMODE) {
3393 return PROT_READ|PROT_WRITE;
3400 char *format_bytes(char *buf, size_t l, off_t t) {
3403 static const struct {
3407 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3408 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3409 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
3410 { "G", 1024ULL*1024ULL*1024ULL },
3411 { "M", 1024ULL*1024ULL },
3415 if (t == (off_t) -1)
3418 for (i = 0; i < ELEMENTSOF(table); i++) {
3420 if (t >= table[i].factor) {
3423 (unsigned long long) (t / table[i].factor),
3424 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
3431 snprintf(buf, l, "%lluB", (unsigned long long) t);
3439 void* memdup(const void *p, size_t l) {
3452 int fd_inc_sndbuf(int fd, size_t n) {
3454 socklen_t l = sizeof(value);
3456 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
3457 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
3460 /* If we have the privileges we will ignore the kernel limit. */
3463 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
3464 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
3470 int fd_inc_rcvbuf(int fd, size_t n) {
3472 socklen_t l = sizeof(value);
3474 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
3475 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
3478 /* If we have the privileges we will ignore the kernel limit. */