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/>.
22 // #include <string.h>
23 // #include <unistd.h>
25 // #include <stdlib.h>
26 // #include <signal.h>
27 // #include <libintl.h>
29 // #include <syslog.h>
31 // #include <sys/resource.h>
32 // #include <linux/sched.h>
33 // #include <sys/types.h>
34 // #include <sys/stat.h>
36 // #include <dirent.h>
37 // #include <sys/ioctl.h>
38 // #include <stdarg.h>
41 #include <sys/prctl.h>
42 // #include <sys/utsname.h>
44 #include <netinet/ip.h>
45 // #include <sys/wait.h>
46 // #include <sys/time.h>
49 // #include <sys/mman.h>
50 // #include <sys/vfs.h>
51 // #include <sys/mount.h>
52 #include <linux/magic.h>
53 // #include <limits.h>
55 // #include <locale.h>
56 // #include <sys/personality.h>
57 #include <sys/xattr.h>
58 // #include <sys/statvfs.h>
59 // #include <sys/file.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 POSIX
64 * version which is really broken. We prefer GNU basename(). */
65 // #include <libgen.h>
68 #ifdef HAVE_SYS_AUXV_H
75 // #include "ioprio.h"
76 // #include "missing.h"
80 #include "path-util.h"
81 // #include "exit-status.h"
84 // #include "env-util.h"
86 // #include "device-nodes.h"
91 #include "sparse-endian.h"
92 // #include "formats-util.h"
93 #include "process-util.h"
94 #include "random-util.h"
95 // #include "terminal-util.h"
96 #include "hostname-util.h"
97 #include "signal-util.h"
99 /* Put this test here for a lack of better place */
100 assert_cc(EAGAIN == EWOULDBLOCK);
103 char **saved_argv = NULL;
105 size_t page_size(void) {
106 static thread_local size_t pgsz = 0;
109 if (_likely_(pgsz > 0))
112 r = sysconf(_SC_PAGESIZE);
119 int strcmp_ptr(const char *a, const char *b) {
121 /* Like strcmp(), but tries to make sense of NULL pointers */
134 bool streq_ptr(const char *a, const char *b) {
135 return strcmp_ptr(a, b) == 0;
138 char* endswith(const char *s, const char *postfix) {
145 pl = strlen(postfix);
148 return (char*) s + sl;
153 if (memcmp(s + sl - pl, postfix, pl) != 0)
156 return (char*) s + sl - pl;
159 char* endswith_no_case(const char *s, const char *postfix) {
166 pl = strlen(postfix);
169 return (char*) s + sl;
174 if (strcasecmp(s + sl - pl, postfix) != 0)
177 return (char*) s + sl - pl;
180 char* first_word(const char *s, const char *word) {
187 /* Checks if the string starts with the specified word, either
188 * followed by NUL or by whitespace. Returns a pointer to the
189 * NUL or the first character after the whitespace. */
200 if (memcmp(s, word, wl) != 0)
207 if (!strchr(WHITESPACE, *p))
210 p += strspn(p, WHITESPACE);
214 size_t cescape_char(char c, char *buf) {
215 char * buf_old = buf;
261 /* For special chars we prefer octal over
262 * hexadecimal encoding, simply because glib's
263 * g_strescape() does the same */
264 if ((c < ' ') || (c >= 127)) {
266 *(buf++) = octchar((unsigned char) c >> 6);
267 *(buf++) = octchar((unsigned char) c >> 3);
268 *(buf++) = octchar((unsigned char) c);
274 return buf - buf_old;
277 int close_nointr(int fd) {
284 * Just ignore EINTR; a retry loop is the wrong thing to do on
287 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
288 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
289 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
290 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
298 int safe_close(int fd) {
301 * Like close_nointr() but cannot fail. Guarantees errno is
302 * unchanged. Is a NOP with negative fds passed, and returns
303 * -1, so that it can be used in this syntax:
305 * fd = safe_close(fd);
311 /* The kernel might return pretty much any error code
312 * via close(), but the fd will be closed anyway. The
313 * only condition we want to check for here is whether
314 * the fd was invalid at all... */
316 assert_se(close_nointr(fd) != -EBADF);
322 void close_many(const int fds[], unsigned n_fd) {
325 assert(fds || n_fd <= 0);
327 for (i = 0; i < n_fd; i++)
331 int unlink_noerrno(const char *path) {
342 int parse_boolean(const char *v) {
345 if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
347 else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
353 int parse_pid(const char *s, pid_t* ret_pid) {
354 unsigned long ul = 0;
361 r = safe_atolu(s, &ul);
367 if ((unsigned long) pid != ul)
377 bool uid_is_valid(uid_t uid) {
379 /* Some libc APIs use UID_INVALID as special placeholder */
380 if (uid == (uid_t) 0xFFFFFFFF)
383 /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
384 if (uid == (uid_t) 0xFFFF)
390 int parse_uid(const char *s, uid_t* ret_uid) {
391 unsigned long ul = 0;
397 r = safe_atolu(s, &ul);
403 if ((unsigned long) uid != ul)
406 if (!uid_is_valid(uid))
407 return -ENXIO; /* we return ENXIO instead of EINVAL
408 * here, to make it easy to distuingish
409 * invalid numeric uids invalid
418 int safe_atou(const char *s, unsigned *ret_u) {
426 l = strtoul(s, &x, 0);
428 if (!x || x == s || *x || errno)
429 return errno > 0 ? -errno : -EINVAL;
431 if ((unsigned long) (unsigned) l != l)
434 *ret_u = (unsigned) l;
438 int safe_atoi(const char *s, int *ret_i) {
446 l = strtol(s, &x, 0);
448 if (!x || x == s || *x || errno)
449 return errno > 0 ? -errno : -EINVAL;
451 if ((long) (int) l != l)
458 int safe_atou8(const char *s, uint8_t *ret) {
466 l = strtoul(s, &x, 0);
468 if (!x || x == s || *x || errno)
469 return errno > 0 ? -errno : -EINVAL;
471 if ((unsigned long) (uint8_t) l != l)
478 int safe_atou16(const char *s, uint16_t *ret) {
486 l = strtoul(s, &x, 0);
488 if (!x || x == s || *x || errno)
489 return errno > 0 ? -errno : -EINVAL;
491 if ((unsigned long) (uint16_t) l != l)
498 int safe_atoi16(const char *s, int16_t *ret) {
506 l = strtol(s, &x, 0);
508 if (!x || x == s || *x || errno)
509 return errno > 0 ? -errno : -EINVAL;
511 if ((long) (int16_t) l != l)
518 int safe_atollu(const char *s, long long unsigned *ret_llu) {
520 unsigned long long l;
526 l = strtoull(s, &x, 0);
528 if (!x || x == s || *x || errno)
529 return errno ? -errno : -EINVAL;
535 int safe_atolli(const char *s, long long int *ret_lli) {
543 l = strtoll(s, &x, 0);
545 if (!x || x == s || *x || errno)
546 return errno ? -errno : -EINVAL;
552 int safe_atod(const char *s, double *ret_d) {
560 loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
561 if (loc == (locale_t) 0)
565 d = strtod_l(s, &x, loc);
567 if (!x || x == s || *x || errno) {
569 return errno ? -errno : -EINVAL;
577 static size_t strcspn_escaped(const char *s, const char *reject) {
578 bool escaped = false;
581 for (n=0; s[n]; n++) {
584 else if (s[n] == '\\')
586 else if (strchr(reject, s[n]))
590 /* if s ends in \, return index of previous char */
594 /* Split a string into words. */
595 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
601 assert(**state == '\0');
605 current += strspn(current, separator);
611 if (quoted && strchr("\'\"", *current)) {
612 char quotechars[2] = {*current, '\0'};
614 *l = strcspn_escaped(current + 1, quotechars);
615 if (current[*l + 1] == '\0' || current[*l + 1] != quotechars[0] ||
616 (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
617 /* right quote missing or garbage at the end */
621 *state = current++ + *l + 2;
623 *l = strcspn_escaped(current, separator);
624 if (current[*l] && !strchr(separator, current[*l])) {
625 /* unfinished escape */
629 *state = current + *l;
631 *l = strcspn(current, separator);
632 *state = current + *l;
638 int fchmod_umask(int fd, mode_t m) {
643 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
649 char *truncate_nl(char *s) {
652 s[strcspn(s, NEWLINE)] = 0;
656 char *strnappend(const char *s, const char *suffix, size_t b) {
664 return strndup(suffix, b);
673 if (b > ((size_t) -1) - a)
676 r = new(char, a+b+1);
681 memcpy(r+a, suffix, b);
687 char *strappend(const char *s, const char *suffix) {
688 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
691 int readlinkat_malloc(int fd, const char *p, char **ret) {
706 n = readlinkat(fd, p, c, l-1);
713 if ((size_t) n < l-1) {
724 int readlink_malloc(const char *p, char **ret) {
725 return readlinkat_malloc(AT_FDCWD, p, ret);
728 /// UNNEEDED by elogind
730 int readlink_value(const char *p, char **ret) {
731 _cleanup_free_ char *link = NULL;
735 r = readlink_malloc(p, &link);
739 value = basename(link);
743 value = strdup(value);
753 int readlink_and_make_absolute(const char *p, char **r) {
754 _cleanup_free_ char *target = NULL;
761 j = readlink_malloc(p, &target);
765 k = file_in_same_dir(p, target);
773 /// UNNEEDED by elogind
775 int readlink_and_canonicalize(const char *p, char **r) {
782 j = readlink_and_make_absolute(p, &t);
786 s = canonicalize_file_name(t);
793 path_kill_slashes(*r);
799 char *strstrip(char *s) {
802 /* Drops trailing whitespace. Modifies the string in
803 * place. Returns pointer to first non-space character */
805 s += strspn(s, WHITESPACE);
807 for (e = strchr(s, 0); e > s; e --)
808 if (!strchr(WHITESPACE, e[-1]))
816 /// UNNEEDED by elogind
818 char *delete_chars(char *s, const char *bad) {
821 /* Drops all whitespace, regardless where in the string */
823 for (f = s, t = s; *f; f++) {
836 char *file_in_same_dir(const char *path, const char *filename) {
843 /* This removes the last component of path and appends
844 * filename, unless the latter is absolute anyway or the
847 if (path_is_absolute(filename))
848 return strdup(filename);
850 e = strrchr(path, '/');
852 return strdup(filename);
854 k = strlen(filename);
855 ret = new(char, (e + 1 - path) + k + 1);
859 memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);
863 /// UNNEEDED by elogind
865 int rmdir_parents(const char *path, const char *stop) {
874 /* Skip trailing slashes */
875 while (l > 0 && path[l-1] == '/')
881 /* Skip last component */
882 while (l > 0 && path[l-1] != '/')
885 /* Skip trailing slashes */
886 while (l > 0 && path[l-1] == '/')
892 if (!(t = strndup(path, l)))
895 if (path_startswith(stop, t)) {
912 char hexchar(int x) {
913 static const char table[16] = "0123456789abcdef";
915 return table[x & 15];
918 int unhexchar(char c) {
920 if (c >= '0' && c <= '9')
923 if (c >= 'a' && c <= 'f')
926 if (c >= 'A' && c <= 'F')
932 char *hexmem(const void *p, size_t l) {
936 z = r = malloc(l * 2 + 1);
940 for (x = p; x < (const uint8_t*) p + l; x++) {
941 *(z++) = hexchar(*x >> 4);
942 *(z++) = hexchar(*x & 15);
949 int unhexmem(const char *p, size_t l, void **mem, size_t *len) {
950 _cleanup_free_ uint8_t *r = NULL;
958 z = r = malloc((l + 1) / 2 + 1);
962 for (x = p; x < p + l; x += 2) {
968 else if (x+1 < p + l) {
975 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
987 /* https://tools.ietf.org/html/rfc4648#section-6
988 * Notice that base32hex differs from base32 in the alphabet it uses.
989 * The distinction is that the base32hex representation preserves the
990 * order of the underlying data when compared as bytestrings, this is
991 * useful when representing NSEC3 hashes, as one can then verify the
992 * order of hashes directly from their representation. */
993 char base32hexchar(int x) {
994 static const char table[32] = "0123456789"
995 "ABCDEFGHIJKLMNOPQRSTUV";
997 return table[x & 31];
1000 int unbase32hexchar(char c) {
1003 if (c >= '0' && c <= '9')
1006 offset = '9' - '0' + 1;
1008 if (c >= 'A' && c <= 'V')
1009 return c - 'A' + offset;
1014 char *base32hexmem(const void *p, size_t l, bool padding) {
1020 /* five input bytes makes eight output bytes, padding is added so we must round up */
1021 len = 8 * (l + 4) / 5;
1023 /* same, but round down as there is no padding */
1042 z = r = malloc(len + 1);
1046 for (x = p; x < (const uint8_t*) p + (l / 5) * 5; x += 5) {
1047 /* x[0] == XXXXXXXX; x[1] == YYYYYYYY; x[2] == ZZZZZZZZ
1048 x[3] == QQQQQQQQ; x[4] == WWWWWWWW */
1049 *(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */
1050 *(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */
1051 *(z++) = base32hexchar((x[1] & 63) >> 1); /* 000YYYYY */
1052 *(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4); /* 000YZZZZ */
1053 *(z++) = base32hexchar((x[2] & 15) << 1 | x[3] >> 7); /* 000ZZZZQ */
1054 *(z++) = base32hexchar((x[3] & 127) >> 2); /* 000QQQQQ */
1055 *(z++) = base32hexchar((x[3] & 3) << 3 | x[4] >> 5); /* 000QQWWW */
1056 *(z++) = base32hexchar((x[4] & 31)); /* 000WWWWW */
1061 *(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */
1062 *(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */
1063 *(z++) = base32hexchar((x[1] & 63) >> 1); /* 000YYYYY */
1064 *(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4); /* 000YZZZZ */
1065 *(z++) = base32hexchar((x[2] & 15) << 1 | x[3] >> 7); /* 000ZZZZQ */
1066 *(z++) = base32hexchar((x[3] & 127) >> 2); /* 000QQQQQ */
1067 *(z++) = base32hexchar((x[3] & 3) << 3); /* 000QQ000 */
1074 *(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */
1075 *(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */
1076 *(z++) = base32hexchar((x[1] & 63) >> 1); /* 000YYYYY */
1077 *(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4); /* 000YZZZZ */
1078 *(z++) = base32hexchar((x[2] & 15) << 1); /* 000ZZZZ0 */
1088 *(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */
1089 *(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */
1090 *(z++) = base32hexchar((x[1] & 63) >> 1); /* 000YYYYY */
1091 *(z++) = base32hexchar((x[1] & 1) << 4); /* 000Y0000 */
1102 *(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */
1103 *(z++) = base32hexchar((x[0] & 7) << 2); /* 000XXX00 */
1120 int unbase32hexmem(const char *p, size_t l, bool padding, void **mem, size_t *_len) {
1121 _cleanup_free_ uint8_t *r = NULL;
1122 int a, b, c, d, e, f, g, h;
1130 /* padding ensures any base32hex input has input divisible by 8 */
1131 if (padding && l % 8 != 0)
1135 /* strip the padding */
1136 while (l > 0 && p[l - 1] == '=' && pad < 7) {
1142 /* a group of eight input bytes needs five output bytes, in case of
1143 padding we need to add some extra bytes */
1165 z = r = malloc(len + 1);
1169 for (x = p; x < p + (l / 8) * 8; x += 8) {
1170 /* a == 000XXXXX; b == 000YYYYY; c == 000ZZZZZ; d == 000WWWWW
1171 e == 000SSSSS; f == 000QQQQQ; g == 000VVVVV; h == 000RRRRR */
1172 a = unbase32hexchar(x[0]);
1176 b = unbase32hexchar(x[1]);
1180 c = unbase32hexchar(x[2]);
1184 d = unbase32hexchar(x[3]);
1188 e = unbase32hexchar(x[4]);
1192 f = unbase32hexchar(x[5]);
1196 g = unbase32hexchar(x[6]);
1200 h = unbase32hexchar(x[7]);
1204 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */
1205 *(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */
1206 *(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1; /* WWWWSSSS */
1207 *(z++) = (uint8_t) e << 7 | (uint8_t) f << 2 | (uint8_t) g >> 3; /* SQQQQQVV */
1208 *(z++) = (uint8_t) g << 5 | (uint8_t) h; /* VVVRRRRR */
1213 a = unbase32hexchar(x[0]);
1217 b = unbase32hexchar(x[1]);
1221 c = unbase32hexchar(x[2]);
1225 d = unbase32hexchar(x[3]);
1229 e = unbase32hexchar(x[4]);
1233 f = unbase32hexchar(x[5]);
1237 g = unbase32hexchar(x[6]);
1245 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */
1246 *(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */
1247 *(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1; /* WWWWSSSS */
1248 *(z++) = (uint8_t) e << 7 | (uint8_t) f << 2 | (uint8_t) g >> 3; /* SQQQQQVV */
1252 a = unbase32hexchar(x[0]);
1256 b = unbase32hexchar(x[1]);
1260 c = unbase32hexchar(x[2]);
1264 d = unbase32hexchar(x[3]);
1268 e = unbase32hexchar(x[4]);
1276 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */
1277 *(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */
1278 *(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1; /* WWWWSSSS */
1282 a = unbase32hexchar(x[0]);
1286 b = unbase32hexchar(x[1]);
1290 c = unbase32hexchar(x[2]);
1294 d = unbase32hexchar(x[3]);
1302 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */
1303 *(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */
1307 a = unbase32hexchar(x[0]);
1311 b = unbase32hexchar(x[1]);
1319 *(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */
1337 /* https://tools.ietf.org/html/rfc4648#section-4 */
1338 char base64char(int x) {
1339 static const char table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1340 "abcdefghijklmnopqrstuvwxyz"
1342 return table[x & 63];
1345 int unbase64char(char c) {
1348 if (c >= 'A' && c <= 'Z')
1351 offset = 'Z' - 'A' + 1;
1353 if (c >= 'a' && c <= 'z')
1354 return c - 'a' + offset;
1356 offset += 'z' - 'a' + 1;
1358 if (c >= '0' && c <= '9')
1359 return c - '0' + offset;
1361 offset += '9' - '0' + 1;
1374 char *base64mem(const void *p, size_t l) {
1378 /* three input bytes makes four output bytes, padding is added so we must round up */
1379 z = r = malloc(4 * (l + 2) / 3 + 1);
1383 for (x = p; x < (const uint8_t*) p + (l / 3) * 3; x += 3) {
1384 /* x[0] == XXXXXXXX; x[1] == YYYYYYYY; x[2] == ZZZZZZZZ */
1385 *(z++) = base64char(x[0] >> 2); /* 00XXXXXX */
1386 *(z++) = base64char((x[0] & 3) << 4 | x[1] >> 4); /* 00XXYYYY */
1387 *(z++) = base64char((x[1] & 15) << 2 | x[2] >> 6); /* 00YYYYZZ */
1388 *(z++) = base64char(x[2] & 63); /* 00ZZZZZZ */
1393 *(z++) = base64char(x[0] >> 2); /* 00XXXXXX */
1394 *(z++) = base64char((x[0] & 3) << 4 | x[1] >> 4); /* 00XXYYYY */
1395 *(z++) = base64char((x[1] & 15) << 2); /* 00YYYY00 */
1400 *(z++) = base64char(x[0] >> 2); /* 00XXXXXX */
1401 *(z++) = base64char((x[0] & 3) << 4); /* 00XX0000 */
1412 int unbase64mem(const char *p, size_t l, void **mem, size_t *_len) {
1413 _cleanup_free_ uint8_t *r = NULL;
1421 /* padding ensures any base63 input has input divisible by 4 */
1425 /* strip the padding */
1426 if (l > 0 && p[l - 1] == '=')
1428 if (l > 0 && p[l - 1] == '=')
1431 /* a group of four input bytes needs three output bytes, in case of
1432 padding we need to add two or three extra bytes */
1433 len = (l / 4) * 3 + (l % 4 ? (l % 4) - 1 : 0);
1435 z = r = malloc(len + 1);
1439 for (x = p; x < p + (l / 4) * 4; x += 4) {
1440 /* a == 00XXXXXX; b == 00YYYYYY; c == 00ZZZZZZ; d == 00WWWWWW */
1441 a = unbase64char(x[0]);
1445 b = unbase64char(x[1]);
1449 c = unbase64char(x[2]);
1453 d = unbase64char(x[3]);
1457 *(z++) = (uint8_t) a << 2 | (uint8_t) b >> 4; /* XXXXXXYY */
1458 *(z++) = (uint8_t) b << 4 | (uint8_t) c >> 2; /* YYYYZZZZ */
1459 *(z++) = (uint8_t) c << 6 | (uint8_t) d; /* ZZWWWWWW */
1464 a = unbase64char(x[0]);
1468 b = unbase64char(x[1]);
1472 c = unbase64char(x[2]);
1480 *(z++) = (uint8_t) a << 2 | (uint8_t) b >> 4; /* XXXXXXYY */
1481 *(z++) = (uint8_t) b << 4 | (uint8_t) c >> 2; /* YYYYZZZZ */
1485 a = unbase64char(x[0]);
1489 b = unbase64char(x[1]);
1497 *(z++) = (uint8_t) a << 2 | (uint8_t) (b >> 4); /* XXXXXXYY */
1516 char octchar(int x) {
1517 return '0' + (x & 7);
1520 int unoctchar(char c) {
1522 if (c >= '0' && c <= '7')
1528 char decchar(int x) {
1529 return '0' + (x % 10);
1532 int undecchar(char c) {
1534 if (c >= '0' && c <= '9')
1540 char *cescape(const char *s) {
1546 /* Does C style string escaping. May be reversed with
1549 r = new(char, strlen(s)*4 + 1);
1553 for (f = s, t = r; *f; f++)
1554 t += cescape_char(*f, t);
1561 static int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode) {
1568 /* Unescapes C style. Returns the unescaped character in ret,
1569 * unless we encountered a \u sequence in which case the full
1570 * unicode character is returned in ret_unicode, instead. */
1572 if (length != (size_t) -1 && length < 1)
1609 /* This is an extension of the XDG syntax files */
1614 /* hexadecimal encoding */
1617 if (length != (size_t) -1 && length < 3)
1620 a = unhexchar(p[1]);
1624 b = unhexchar(p[2]);
1628 /* Don't allow NUL bytes */
1629 if (a == 0 && b == 0)
1632 *ret = (char) ((a << 4U) | b);
1638 /* C++11 style 16bit unicode */
1644 if (length != (size_t) -1 && length < 5)
1647 for (i = 0; i < 4; i++) {
1648 a[i] = unhexchar(p[1 + i]);
1653 c = ((uint32_t) a[0] << 12U) | ((uint32_t) a[1] << 8U) | ((uint32_t) a[2] << 4U) | (uint32_t) a[3];
1655 /* Don't allow 0 chars */
1674 /* C++11 style 32bit unicode */
1680 if (length != (size_t) -1 && length < 9)
1683 for (i = 0; i < 8; i++) {
1684 a[i] = unhexchar(p[1 + i]);
1689 c = ((uint32_t) a[0] << 28U) | ((uint32_t) a[1] << 24U) | ((uint32_t) a[2] << 20U) | ((uint32_t) a[3] << 16U) |
1690 ((uint32_t) a[4] << 12U) | ((uint32_t) a[5] << 8U) | ((uint32_t) a[6] << 4U) | (uint32_t) a[7];
1692 /* Don't allow 0 chars */
1696 /* Don't allow invalid code points */
1697 if (!unichar_is_valid(c))
1722 /* octal encoding */
1726 if (length != (size_t) -1 && length < 3)
1729 a = unoctchar(p[0]);
1733 b = unoctchar(p[1]);
1737 c = unoctchar(p[2]);
1741 /* don't allow NUL bytes */
1742 if (a == 0 && b == 0 && c == 0)
1745 /* Don't allow bytes above 255 */
1746 m = ((uint32_t) a << 6U) | ((uint32_t) b << 3U) | (uint32_t) c;
1762 int cunescape_length_with_prefix(const char *s, size_t length, const char *prefix, UnescapeFlags flags, char **ret) {
1770 /* Undoes C style string escaping, and optionally prefixes it. */
1772 pl = prefix ? strlen(prefix) : 0;
1774 r = new(char, pl+length+1);
1779 memcpy(r, prefix, pl);
1781 for (f = s, t = r + pl; f < s + length; f++) {
1787 remaining = s + length - f;
1788 assert(remaining > 0);
1791 /* A literal literal, copy verbatim */
1796 if (remaining == 1) {
1797 if (flags & UNESCAPE_RELAX) {
1798 /* A trailing backslash, copy verbatim */
1807 k = cunescape_one(f + 1, remaining - 1, &c, &u);
1809 if (flags & UNESCAPE_RELAX) {
1810 /* Invalid escape code, let's take it literal then */
1820 /* Non-Unicode? Let's encode this directly */
1823 /* Unicode? Then let's encode this in UTF-8 */
1824 t += utf8_encode_unichar(t, u);
1835 int cunescape_length(const char *s, size_t length, UnescapeFlags flags, char **ret) {
1836 return cunescape_length_with_prefix(s, length, NULL, flags, ret);
1839 int cunescape(const char *s, UnescapeFlags flags, char **ret) {
1840 return cunescape_length(s, strlen(s), flags, ret);
1843 char *xescape(const char *s, const char *bad) {
1847 /* Escapes all chars in bad, in addition to \ and all special
1848 * chars, in \xFF style escaping. May be reversed with
1851 r = new(char, strlen(s) * 4 + 1);
1855 for (f = s, t = r; *f; f++) {
1857 if ((*f < ' ') || (*f >= 127) ||
1858 (*f == '\\') || strchr(bad, *f)) {
1861 *(t++) = hexchar(*f >> 4);
1862 *(t++) = hexchar(*f);
1872 /// UNNEEDED by elogind
1874 char *ascii_strlower(char *t) {
1879 for (p = t; *p; p++)
1880 if (*p >= 'A' && *p <= 'Z')
1881 *p = *p - 'A' + 'a';
1887 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1891 filename[0] == '.' ||
1892 streq(filename, "lost+found") ||
1893 streq(filename, "aquota.user") ||
1894 streq(filename, "aquota.group") ||
1895 endswith(filename, ".rpmnew") ||
1896 endswith(filename, ".rpmsave") ||
1897 endswith(filename, ".rpmorig") ||
1898 endswith(filename, ".dpkg-old") ||
1899 endswith(filename, ".dpkg-new") ||
1900 endswith(filename, ".dpkg-tmp") ||
1901 endswith(filename, ".dpkg-dist") ||
1902 endswith(filename, ".dpkg-bak") ||
1903 endswith(filename, ".dpkg-backup") ||
1904 endswith(filename, ".dpkg-remove") ||
1905 endswith(filename, ".swp");
1908 bool hidden_file(const char *filename) {
1911 if (endswith(filename, "~"))
1914 return hidden_file_allow_backup(filename);
1917 int fd_nonblock(int fd, bool nonblock) {
1922 flags = fcntl(fd, F_GETFL, 0);
1927 nflags = flags | O_NONBLOCK;
1929 nflags = flags & ~O_NONBLOCK;
1931 if (nflags == flags)
1934 if (fcntl(fd, F_SETFL, nflags) < 0)
1940 int fd_cloexec(int fd, bool cloexec) {
1945 flags = fcntl(fd, F_GETFD, 0);
1950 nflags = flags | FD_CLOEXEC;
1952 nflags = flags & ~FD_CLOEXEC;
1954 if (nflags == flags)
1957 if (fcntl(fd, F_SETFD, nflags) < 0)
1963 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1966 assert(n_fdset == 0 || fdset);
1968 for (i = 0; i < n_fdset; i++)
1975 int close_all_fds(const int except[], unsigned n_except) {
1976 _cleanup_closedir_ DIR *d = NULL;
1980 assert(n_except == 0 || except);
1982 d = opendir("/proc/self/fd");
1987 /* When /proc isn't available (for example in chroots)
1988 * the fallback is brute forcing through the fd
1991 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1992 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1994 if (fd_in_set(fd, except, n_except))
1997 if (close_nointr(fd) < 0)
1998 if (errno != EBADF && r == 0)
2005 while ((de = readdir(d))) {
2008 if (hidden_file(de->d_name))
2011 if (safe_atoi(de->d_name, &fd) < 0)
2012 /* Let's better ignore this, just in case */
2021 if (fd_in_set(fd, except, n_except))
2024 if (close_nointr(fd) < 0) {
2025 /* Valgrind has its own FD and doesn't want to have it closed */
2026 if (errno != EBADF && r == 0)
2034 bool chars_intersect(const char *a, const char *b) {
2037 /* Returns true if any of the chars in a are in b. */
2038 for (p = a; *p; p++)
2045 /// UNNEEDED by elogind
2047 bool fstype_is_network(const char *fstype) {
2048 static const char table[] =
2063 x = startswith(fstype, "fuse.");
2067 return nulstr_contains(table, fstype);
2071 int flush_fd(int fd) {
2072 struct pollfd pollfd = {
2082 r = poll(&pollfd, 1, 0);
2092 l = read(fd, buf, sizeof(buf));
2098 if (errno == EAGAIN)
2107 void safe_close_pair(int p[]) {
2111 /* Special case pairs which use the same fd in both
2113 p[0] = p[1] = safe_close(p[0]);
2117 p[0] = safe_close(p[0]);
2118 p[1] = safe_close(p[1]);
2121 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2128 /* If called with nbytes == 0, let's call read() at least
2129 * once, to validate the operation */
2131 if (nbytes > (size_t) SSIZE_MAX)
2137 k = read(fd, p, nbytes);
2142 if (errno == EAGAIN && do_poll) {
2144 /* We knowingly ignore any return value here,
2145 * and expect that any error/EOF is reported
2148 (void) fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2152 return n > 0 ? n : -errno;
2158 assert((size_t) k <= nbytes);
2163 } while (nbytes > 0);
2168 int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll) {
2171 n = loop_read(fd, buf, nbytes, do_poll);
2174 if ((size_t) n != nbytes)
2180 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2181 const uint8_t *p = buf;
2186 if (nbytes > (size_t) SSIZE_MAX)
2192 k = write(fd, p, nbytes);
2197 if (errno == EAGAIN && do_poll) {
2198 /* We knowingly ignore any return value here,
2199 * and expect that any error/EOF is reported
2202 (void) fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2209 if (_unlikely_(nbytes > 0 && k == 0)) /* Can't really happen */
2212 assert((size_t) k <= nbytes);
2216 } while (nbytes > 0);
2221 int parse_size(const char *t, off_t base, off_t *size) {
2223 /* Soo, sometimes we want to parse IEC binary suffixes, and
2224 * sometimes SI decimal suffixes. This function can parse
2225 * both. Which one is the right way depends on the
2226 * context. Wikipedia suggests that SI is customary for
2227 * hardware metrics and network speeds, while IEC is
2228 * customary for most data sizes used by software and volatile
2229 * (RAM) memory. Hence be careful which one you pick!
2231 * In either case we use just K, M, G as suffix, and not Ki,
2232 * Mi, Gi or so (as IEC would suggest). That's because that's
2233 * frickin' ugly. But this means you really need to make sure
2234 * to document which base you are parsing when you use this
2239 unsigned long long factor;
2242 static const struct table iec[] = {
2243 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2244 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2245 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2246 { "G", 1024ULL*1024ULL*1024ULL },
2247 { "M", 1024ULL*1024ULL },
2253 static const struct table si[] = {
2254 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2255 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2256 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2257 { "G", 1000ULL*1000ULL*1000ULL },
2258 { "M", 1000ULL*1000ULL },
2264 const struct table *table;
2266 unsigned long long r = 0;
2267 unsigned n_entries, start_pos = 0;
2270 assert(base == 1000 || base == 1024);
2275 n_entries = ELEMENTSOF(si);
2278 n_entries = ELEMENTSOF(iec);
2284 unsigned long long l2;
2290 l = strtoll(p, &e, 10);
2303 if (*e >= '0' && *e <= '9') {
2306 /* strotoull itself would accept space/+/- */
2307 l2 = strtoull(e, &e2, 10);
2309 if (errno == ERANGE)
2312 /* Ignore failure. E.g. 10.M is valid */
2319 e += strspn(e, WHITESPACE);
2321 for (i = start_pos; i < n_entries; i++)
2322 if (startswith(e, table[i].suffix)) {
2323 unsigned long long tmp;
2324 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2326 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2327 if (tmp > ULLONG_MAX - r)
2331 if ((unsigned long long) (off_t) r != r)
2334 p = e + strlen(table[i].suffix);
2350 bool is_device_path(const char *path) {
2352 /* Returns true on paths that refer to a device, either in
2353 * sysfs or in /dev */
2356 path_startswith(path, "/dev/") ||
2357 path_startswith(path, "/sys/");
2360 /// UNNEEDED by elogind
2362 int dir_is_empty(const char *path) {
2363 _cleanup_closedir_ DIR *d;
2374 if (!de && errno != 0)
2380 if (!hidden_file(de->d_name))
2385 char* dirname_malloc(const char *path) {
2386 char *d, *dir, *dir2;
2403 void rename_process(const char name[8]) {
2406 /* This is a like a poor man's setproctitle(). It changes the
2407 * comm field, argv[0], and also the glibc's internally used
2408 * name of the process. For the first one a limit of 16 chars
2409 * applies, to the second one usually one of 10 (i.e. length
2410 * of "/sbin/init"), to the third one one of 7 (i.e. length of
2411 * "systemd"). If you pass a longer string it will be
2414 prctl(PR_SET_NAME, name);
2416 if (program_invocation_name)
2417 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2419 if (saved_argc > 0) {
2423 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2425 for (i = 1; i < saved_argc; i++) {
2429 memzero(saved_argv[i], strlen(saved_argv[i]));
2435 char *lookup_uid(uid_t uid) {
2438 _cleanup_free_ char *buf = NULL;
2439 struct passwd pwbuf, *pw = NULL;
2441 /* Shortcut things to avoid NSS lookups */
2443 return strdup("root");
2445 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2449 buf = malloc(bufsize);
2453 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2454 return strdup(pw->pw_name);
2456 if (asprintf(&name, UID_FMT, uid) < 0)
2462 /// UNNEEDED by elogind
2464 char* getlogname_malloc(void) {
2468 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2473 return lookup_uid(uid);
2476 char *getusername_malloc(void) {
2483 return lookup_uid(getuid());
2487 bool is_temporary_fs(const struct statfs *s) {
2490 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2491 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2494 int fd_is_temporary_fs(int fd) {
2497 if (fstatfs(fd, &s) < 0)
2500 return is_temporary_fs(&s);
2503 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2506 /* Under the assumption that we are running privileged we
2507 * first change the access mode and only then hand out
2508 * ownership to avoid a window where access is too open. */
2510 if (mode != MODE_INVALID)
2511 if (chmod(path, mode) < 0)
2514 if (uid != UID_INVALID || gid != GID_INVALID)
2515 if (chown(path, uid, gid) < 0)
2521 /// UNNEEDED by elogind
2523 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2526 /* Under the assumption that we are running privileged we
2527 * first change the access mode and only then hand out
2528 * ownership to avoid a window where access is too open. */
2530 if (mode != MODE_INVALID)
2531 if (fchmod(fd, mode) < 0)
2534 if (uid != UID_INVALID || gid != GID_INVALID)
2535 if (fchown(fd, uid, gid) < 0)
2541 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2545 /* Allocates the cpuset in the right size */
2548 if (!(r = CPU_ALLOC(n)))
2551 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2552 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2562 if (errno != EINVAL)
2570 int files_same(const char *filea, const char *fileb) {
2573 if (stat(filea, &a) < 0)
2576 if (stat(fileb, &b) < 0)
2579 return a.st_dev == b.st_dev &&
2580 a.st_ino == b.st_ino;
2583 int running_in_chroot(void) {
2586 ret = files_same("/proc/1/root", "/");
2593 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
2598 assert(percent <= 100);
2599 assert(new_length >= 3);
2601 if (old_length <= 3 || old_length <= new_length)
2602 return strndup(s, old_length);
2604 r = new0(char, new_length+1);
2608 x = (new_length * percent) / 100;
2610 if (x > new_length - 3)
2618 s + old_length - (new_length - x - 3),
2619 new_length - x - 3);
2624 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
2628 unsigned k, len, len2;
2631 assert(percent <= 100);
2632 assert(new_length >= 3);
2634 /* if no multibyte characters use ascii_ellipsize_mem for speed */
2635 if (ascii_is_valid(s))
2636 return ascii_ellipsize_mem(s, old_length, new_length, percent);
2638 if (old_length <= 3 || old_length <= new_length)
2639 return strndup(s, old_length);
2641 x = (new_length * percent) / 100;
2643 if (x > new_length - 3)
2647 for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
2650 c = utf8_encoded_to_unichar(i);
2653 k += unichar_iswide(c) ? 2 : 1;
2656 if (k > x) /* last character was wide and went over quota */
2659 for (j = s + old_length; k < new_length && j > i; ) {
2662 j = utf8_prev_char(j);
2663 c = utf8_encoded_to_unichar(j);
2666 k += unichar_iswide(c) ? 2 : 1;
2670 /* we don't actually need to ellipsize */
2672 return memdup(s, old_length + 1);
2674 /* make space for ellipsis */
2675 j = utf8_next_char(j);
2678 len2 = s + old_length - j;
2679 e = new(char, len + 3 + len2 + 1);
2684 printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
2685 old_length, new_length, x, len, len2, k);
2689 e[len] = 0xe2; /* tri-dot ellipsis: … */
2693 memcpy(e + len + 3, j, len2 + 1);
2698 char *ellipsize(const char *s, size_t length, unsigned percent) {
2699 return ellipsize_mem(s, strlen(s), length, percent);
2702 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
2703 _cleanup_close_ int fd;
2709 mkdir_parents(path, 0755);
2711 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
2716 r = fchmod(fd, mode);
2721 if (uid != UID_INVALID || gid != GID_INVALID) {
2722 r = fchown(fd, uid, gid);
2727 if (stamp != USEC_INFINITY) {
2728 struct timespec ts[2];
2730 timespec_store(&ts[0], stamp);
2732 r = futimens(fd, ts);
2734 r = futimens(fd, NULL);
2741 int touch(const char *path) {
2742 return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
2745 /// UNNEEDED by elogind
2747 static char *unquote(const char *s, const char* quotes) {
2751 /* This is rather stupid, simply removes the heading and
2752 * trailing quotes if there is one. Doesn't care about
2753 * escaping or anything.
2755 * DON'T USE THIS FOR NEW CODE ANYMORE!*/
2761 if (strchr(quotes, s[0]) && s[l-1] == s[0])
2762 return strndup(s+1, l-2);
2768 noreturn void freeze(void) {
2770 /* Make sure nobody waits for us on a socket anymore */
2771 close_all_fds(NULL, 0);
2779 bool null_or_empty(struct stat *st) {
2782 if (S_ISREG(st->st_mode) && st->st_size <= 0)
2785 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
2791 int null_or_empty_path(const char *fn) {
2796 if (stat(fn, &st) < 0)
2799 return null_or_empty(&st);
2802 /// UNNEEDED by elogind
2804 int null_or_empty_fd(int fd) {
2809 if (fstat(fd, &st) < 0)
2812 return null_or_empty(&st);
2816 DIR *xopendirat(int fd, const char *name, int flags) {
2820 assert(!(flags & O_CREAT));
2822 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
2835 /// UNNEEDED by elogind
2837 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
2838 _cleanup_free_ char *t = NULL, *u = NULL;
2841 u = unquote(tagvalue, QUOTES);
2845 enc_len = strlen(u) * 4 + 1;
2846 t = new(char, enc_len);
2850 if (encode_devnode_name(u, t, enc_len) < 0)
2853 return strjoin("/dev/disk/by-", by, "/", t, NULL);
2856 char *fstab_node_to_udev_node(const char *p) {
2859 if (startswith(p, "LABEL="))
2860 return tag_to_udev_node(p+6, "label");
2862 if (startswith(p, "UUID="))
2863 return tag_to_udev_node(p+5, "uuid");
2865 if (startswith(p, "PARTUUID="))
2866 return tag_to_udev_node(p+9, "partuuid");
2868 if (startswith(p, "PARTLABEL="))
2869 return tag_to_udev_node(p+10, "partlabel");
2875 bool dirent_is_file(const struct dirent *de) {
2878 if (hidden_file(de->d_name))
2881 if (de->d_type != DT_REG &&
2882 de->d_type != DT_LNK &&
2883 de->d_type != DT_UNKNOWN)
2889 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
2892 if (de->d_type != DT_REG &&
2893 de->d_type != DT_LNK &&
2894 de->d_type != DT_UNKNOWN)
2897 if (hidden_file_allow_backup(de->d_name))
2900 return endswith(de->d_name, suffix);
2903 static int do_execute(char **directories, usec_t timeout, char *argv[]) {
2904 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
2905 _cleanup_set_free_free_ Set *seen = NULL;
2908 /* We fork this all off from a child process so that we can
2909 * somewhat cleanly make use of SIGALRM to set a time limit */
2911 (void) reset_all_signal_handlers();
2912 (void) reset_signal_mask();
2914 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
2916 pids = hashmap_new(NULL);
2920 seen = set_new(&string_hash_ops);
2924 STRV_FOREACH(directory, directories) {
2925 _cleanup_closedir_ DIR *d;
2928 d = opendir(*directory);
2930 if (errno == ENOENT)
2933 return log_error_errno(errno, "Failed to open directory %s: %m", *directory);
2936 FOREACH_DIRENT(de, d, break) {
2937 _cleanup_free_ char *path = NULL;
2941 if (!dirent_is_file(de))
2944 if (set_contains(seen, de->d_name)) {
2945 log_debug("%1$s/%2$s skipped (%2$s was already seen).", *directory, de->d_name);
2949 r = set_put_strdup(seen, de->d_name);
2953 path = strjoin(*directory, "/", de->d_name, NULL);
2957 if (null_or_empty_path(path)) {
2958 log_debug("%s is empty (a mask).", path);
2964 log_error_errno(errno, "Failed to fork: %m");
2966 } else if (pid == 0) {
2969 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
2979 return log_error_errno(errno, "Failed to execute %s: %m", path);
2982 log_debug("Spawned %s as " PID_FMT ".", path, pid);
2984 r = hashmap_put(pids, UINT_TO_PTR(pid), path);
2991 /* Abort execution of this process after the timout. We simply
2992 * rely on SIGALRM as default action terminating the process,
2993 * and turn on alarm(). */
2995 if (timeout != USEC_INFINITY)
2996 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
2998 while (!hashmap_isempty(pids)) {
2999 _cleanup_free_ char *path = NULL;
3002 pid = PTR_TO_UINT(hashmap_first_key(pids));
3005 path = hashmap_remove(pids, UINT_TO_PTR(pid));
3008 wait_for_terminate_and_warn(path, pid, true);
3014 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]) {
3018 char **dirs = (char**) directories;
3020 assert(!strv_isempty(dirs));
3022 name = basename(dirs[0]);
3023 assert(!isempty(name));
3025 /* Executes all binaries in the directories in parallel and waits
3026 * for them to finish. Optionally a timeout is applied. If a file
3027 * with the same name exists in more than one directory, the
3028 * earliest one wins. */
3030 executor_pid = fork();
3031 if (executor_pid < 0) {
3032 log_error_errno(errno, "Failed to fork: %m");
3035 } else if (executor_pid == 0) {
3036 r = do_execute(dirs, timeout, argv);
3037 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
3040 wait_for_terminate_and_warn(name, executor_pid, true);
3043 bool nulstr_contains(const char*nulstr, const char *needle) {
3049 NULSTR_FOREACH(i, nulstr)
3050 if (streq(i, needle))
3056 /// UNNEEDED by elogind
3058 bool plymouth_running(void) {
3059 return access("/run/plymouth/pid", F_OK) >= 0;
3063 char* strshorten(char *s, size_t l) {
3072 int pipe_eof(int fd) {
3073 struct pollfd pollfd = {
3075 .events = POLLIN|POLLHUP,
3080 r = poll(&pollfd, 1, 0);
3087 return pollfd.revents & POLLHUP;
3090 int fd_wait_for_event(int fd, int event, usec_t t) {
3092 struct pollfd pollfd = {
3100 r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
3107 return pollfd.revents;
3110 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3119 r = tempfn_xxxxxx(path, NULL, &t);
3123 fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
3129 f = fdopen(fd, "we");
3143 /// UNNEEDED by elogind
3145 int symlink_atomic(const char *from, const char *to) {
3146 _cleanup_free_ char *t = NULL;
3152 r = tempfn_random(to, NULL, &t);
3156 if (symlink(from, t) < 0)
3159 if (rename(t, to) < 0) {
3167 int symlink_idempotent(const char *from, const char *to) {
3168 _cleanup_free_ char *p = NULL;
3174 if (symlink(from, to) < 0) {
3175 if (errno != EEXIST)
3178 r = readlink_malloc(to, &p);
3182 if (!streq(p, from))
3189 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
3190 _cleanup_free_ char *t = NULL;
3195 r = tempfn_random(path, NULL, &t);
3199 if (mknod(t, mode, dev) < 0)
3202 if (rename(t, path) < 0) {
3210 int mkfifo_atomic(const char *path, mode_t mode) {
3211 _cleanup_free_ char *t = NULL;
3216 r = tempfn_random(path, NULL, &t);
3220 if (mkfifo(t, mode) < 0)
3223 if (rename(t, path) < 0) {
3232 bool display_is_local(const char *display) {
3236 display[0] == ':' &&
3237 display[1] >= '0' &&
3241 int socket_from_display(const char *display, char **path) {
3248 if (!display_is_local(display))
3251 k = strspn(display+1, "0123456789");
3253 f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
3257 c = stpcpy(f, "/tmp/.X11-unix/X");
3258 memcpy(c, display+1, k);
3267 const char **username,
3268 uid_t *uid, gid_t *gid,
3270 const char **shell) {
3278 /* We enforce some special rules for uid=0: in order to avoid
3279 * NSS lookups for root we hardcode its data. */
3281 if (streq(*username, "root") || streq(*username, "0")) {
3299 if (parse_uid(*username, &u) >= 0) {
3303 /* If there are multiple users with the same id, make
3304 * sure to leave $USER to the configured value instead
3305 * of the first occurrence in the database. However if
3306 * the uid was configured by a numeric uid, then let's
3307 * pick the real username from /etc/passwd. */
3309 *username = p->pw_name;
3312 p = getpwnam(*username);
3316 return errno > 0 ? -errno : -ESRCH;
3328 *shell = p->pw_shell;
3333 char* uid_to_name(uid_t uid) {
3338 return strdup("root");
3342 return strdup(p->pw_name);
3344 if (asprintf(&r, UID_FMT, uid) < 0)
3350 char* gid_to_name(gid_t gid) {
3355 return strdup("root");
3359 return strdup(p->gr_name);
3361 if (asprintf(&r, GID_FMT, gid) < 0)
3367 int get_group_creds(const char **groupname, gid_t *gid) {
3373 /* We enforce some special rules for gid=0: in order to avoid
3374 * NSS lookups for root we hardcode its data. */
3376 if (streq(*groupname, "root") || streq(*groupname, "0")) {
3377 *groupname = "root";
3385 if (parse_gid(*groupname, &id) >= 0) {
3390 *groupname = g->gr_name;
3393 g = getgrnam(*groupname);
3397 return errno > 0 ? -errno : -ESRCH;
3405 int in_gid(gid_t gid) {
3407 int ngroups_max, r, i;
3409 if (getgid() == gid)
3412 if (getegid() == gid)
3415 ngroups_max = sysconf(_SC_NGROUPS_MAX);
3416 assert(ngroups_max > 0);
3418 gids = alloca(sizeof(gid_t) * ngroups_max);
3420 r = getgroups(ngroups_max, gids);
3424 for (i = 0; i < r; i++)
3431 /// UNNEEDED by elogind
3433 int in_group(const char *name) {
3437 r = get_group_creds(&name, &gid);
3444 int glob_exists(const char *path) {
3445 _cleanup_globfree_ glob_t g = {};
3451 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
3453 if (k == GLOB_NOMATCH)
3455 else if (k == GLOB_NOSPACE)
3458 return !strv_isempty(g.gl_pathv);
3460 return errno ? -errno : -EIO;
3463 int glob_extend(char ***strv, const char *path) {
3464 _cleanup_globfree_ glob_t g = {};
3469 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
3471 if (k == GLOB_NOMATCH)
3473 else if (k == GLOB_NOSPACE)
3475 else if (k != 0 || strv_isempty(g.gl_pathv))
3476 return errno ? -errno : -EIO;
3478 STRV_FOREACH(p, g.gl_pathv) {
3479 k = strv_extend(strv, *p);
3488 int dirent_ensure_type(DIR *d, struct dirent *de) {
3494 if (de->d_type != DT_UNKNOWN)
3497 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
3501 S_ISREG(st.st_mode) ? DT_REG :
3502 S_ISDIR(st.st_mode) ? DT_DIR :
3503 S_ISLNK(st.st_mode) ? DT_LNK :
3504 S_ISFIFO(st.st_mode) ? DT_FIFO :
3505 S_ISSOCK(st.st_mode) ? DT_SOCK :
3506 S_ISCHR(st.st_mode) ? DT_CHR :
3507 S_ISBLK(st.st_mode) ? DT_BLK :
3513 int get_files_in_directory(const char *path, char ***list) {
3514 _cleanup_closedir_ DIR *d = NULL;
3515 size_t bufsize = 0, n = 0;
3516 _cleanup_strv_free_ char **l = NULL;
3520 /* Returns all files in a directory in *list, and the number
3521 * of files as return value. If list is NULL returns only the
3533 if (!de && errno != 0)
3538 dirent_ensure_type(d, de);
3540 if (!dirent_is_file(de))
3544 /* one extra slot is needed for the terminating NULL */
3545 if (!GREEDY_REALLOC(l, bufsize, n + 2))
3548 l[n] = strdup(de->d_name);
3559 l = NULL; /* avoid freeing */
3565 char *strjoin(const char *x, ...) {
3579 t = va_arg(ap, const char *);
3584 if (n > ((size_t) -1) - l) {
3608 t = va_arg(ap, const char *);
3622 bool is_main_thread(void) {
3623 static thread_local int cached = 0;
3625 if (_unlikely_(cached == 0))
3626 cached = getpid() == gettid() ? 1 : -1;
3631 /// UNNEEDED by elogind
3633 int block_get_whole_disk(dev_t d, dev_t *ret) {
3640 /* If it has a queue this is good enough for us */
3641 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
3644 r = access(p, F_OK);
3652 /* If it is a partition find the originating device */
3653 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
3656 r = access(p, F_OK);
3662 /* Get parent dev_t */
3663 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
3666 r = read_one_line_file(p, &s);
3672 r = sscanf(s, "%u:%u", &m, &n);
3678 /* Only return this if it is really good enough for us. */
3679 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
3682 r = access(p, F_OK);
3686 *ret = makedev(m, n);
3693 static const char *const ioprio_class_table[] = {
3694 [IOPRIO_CLASS_NONE] = "none",
3695 [IOPRIO_CLASS_RT] = "realtime",
3696 [IOPRIO_CLASS_BE] = "best-effort",
3697 [IOPRIO_CLASS_IDLE] = "idle"
3700 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
3703 static const char *const sigchld_code_table[] = {
3704 [CLD_EXITED] = "exited",
3705 [CLD_KILLED] = "killed",
3706 [CLD_DUMPED] = "dumped",
3707 [CLD_TRAPPED] = "trapped",
3708 [CLD_STOPPED] = "stopped",
3709 [CLD_CONTINUED] = "continued",
3712 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
3714 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
3715 [LOG_FAC(LOG_KERN)] = "kern",
3716 [LOG_FAC(LOG_USER)] = "user",
3717 [LOG_FAC(LOG_MAIL)] = "mail",
3718 [LOG_FAC(LOG_DAEMON)] = "daemon",
3719 [LOG_FAC(LOG_AUTH)] = "auth",
3720 [LOG_FAC(LOG_SYSLOG)] = "syslog",
3721 [LOG_FAC(LOG_LPR)] = "lpr",
3722 [LOG_FAC(LOG_NEWS)] = "news",
3723 [LOG_FAC(LOG_UUCP)] = "uucp",
3724 [LOG_FAC(LOG_CRON)] = "cron",
3725 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
3726 [LOG_FAC(LOG_FTP)] = "ftp",
3727 [LOG_FAC(LOG_LOCAL0)] = "local0",
3728 [LOG_FAC(LOG_LOCAL1)] = "local1",
3729 [LOG_FAC(LOG_LOCAL2)] = "local2",
3730 [LOG_FAC(LOG_LOCAL3)] = "local3",
3731 [LOG_FAC(LOG_LOCAL4)] = "local4",
3732 [LOG_FAC(LOG_LOCAL5)] = "local5",
3733 [LOG_FAC(LOG_LOCAL6)] = "local6",
3734 [LOG_FAC(LOG_LOCAL7)] = "local7"
3737 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
3739 static const char *const log_level_table[] = {
3740 [LOG_EMERG] = "emerg",
3741 [LOG_ALERT] = "alert",
3742 [LOG_CRIT] = "crit",
3744 [LOG_WARNING] = "warning",
3745 [LOG_NOTICE] = "notice",
3746 [LOG_INFO] = "info",
3747 [LOG_DEBUG] = "debug"
3750 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
3752 static const char* const sched_policy_table[] = {
3753 [SCHED_OTHER] = "other",
3754 [SCHED_BATCH] = "batch",
3755 [SCHED_IDLE] = "idle",
3756 [SCHED_FIFO] = "fifo",
3760 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
3762 static const char* const rlimit_table[_RLIMIT_MAX] = {
3763 [RLIMIT_CPU] = "LimitCPU",
3764 [RLIMIT_FSIZE] = "LimitFSIZE",
3765 [RLIMIT_DATA] = "LimitDATA",
3766 [RLIMIT_STACK] = "LimitSTACK",
3767 [RLIMIT_CORE] = "LimitCORE",
3768 [RLIMIT_RSS] = "LimitRSS",
3769 [RLIMIT_NOFILE] = "LimitNOFILE",
3770 [RLIMIT_AS] = "LimitAS",
3771 [RLIMIT_NPROC] = "LimitNPROC",
3772 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
3773 [RLIMIT_LOCKS] = "LimitLOCKS",
3774 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
3775 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
3776 [RLIMIT_NICE] = "LimitNICE",
3777 [RLIMIT_RTPRIO] = "LimitRTPRIO",
3778 [RLIMIT_RTTIME] = "LimitRTTIME"
3781 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
3783 static const char* const ip_tos_table[] = {
3784 [IPTOS_LOWDELAY] = "low-delay",
3785 [IPTOS_THROUGHPUT] = "throughput",
3786 [IPTOS_RELIABILITY] = "reliability",
3787 [IPTOS_LOWCOST] = "low-cost",
3790 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
3792 bool kexec_loaded(void) {
3793 bool loaded = false;
3796 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
3804 /// UNNEEDED by elogind
3806 int prot_from_flags(int flags) {
3808 switch (flags & O_ACCMODE) {
3817 return PROT_READ|PROT_WRITE;
3824 char *format_bytes(char *buf, size_t l, off_t t) {
3827 static const struct {
3831 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3832 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3833 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
3834 { "G", 1024ULL*1024ULL*1024ULL },
3835 { "M", 1024ULL*1024ULL },
3839 if (t == (off_t) -1)
3842 for (i = 0; i < ELEMENTSOF(table); i++) {
3844 if (t >= table[i].factor) {
3847 (unsigned long long) (t / table[i].factor),
3848 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
3855 snprintf(buf, l, "%lluB", (unsigned long long) t);
3864 void* memdup(const void *p, size_t l) {
3877 int fd_inc_sndbuf(int fd, size_t n) {
3879 socklen_t l = sizeof(value);
3881 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
3882 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
3885 /* If we have the privileges we will ignore the kernel limit. */
3888 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
3889 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
3895 int fd_inc_rcvbuf(int fd, size_t n) {
3897 socklen_t l = sizeof(value);
3899 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
3900 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
3903 /* If we have the privileges we will ignore the kernel limit. */
3906 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
3907 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
3912 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
3913 bool stdout_is_tty, stderr_is_tty;
3914 pid_t parent_pid, agent_pid;
3915 sigset_t ss, saved_ss;
3923 /* Spawns a temporary TTY agent, making sure it goes away when
3926 parent_pid = getpid();
3928 /* First we temporarily block all signals, so that the new
3929 * child has them blocked initially. This way, we can be sure
3930 * that SIGTERMs are not lost we might send to the agent. */
3931 assert_se(sigfillset(&ss) >= 0);
3932 assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
3935 if (agent_pid < 0) {
3936 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
3940 if (agent_pid != 0) {
3941 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
3948 * Make sure the agent goes away when the parent dies */
3949 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
3950 _exit(EXIT_FAILURE);
3952 /* Make sure we actually can kill the agent, if we need to, in
3953 * case somebody invoked us from a shell script that trapped
3954 * SIGTERM or so... */
3955 (void) reset_all_signal_handlers();
3956 (void) reset_signal_mask();
3958 /* Check whether our parent died before we were able
3959 * to set the death signal and unblock the signals */
3960 if (getppid() != parent_pid)
3961 _exit(EXIT_SUCCESS);
3963 /* Don't leak fds to the agent */
3964 close_all_fds(except, n_except);
3966 stdout_is_tty = isatty(STDOUT_FILENO);
3967 stderr_is_tty = isatty(STDERR_FILENO);
3969 if (!stdout_is_tty || !stderr_is_tty) {
3972 /* Detach from stdout/stderr. and reopen
3973 * /dev/tty for them. This is important to
3974 * ensure that when systemctl is started via
3975 * popen() or a similar call that expects to
3976 * read EOF we actually do generate EOF and
3977 * not delay this indefinitely by because we
3978 * keep an unused copy of stdin around. */
3979 fd = open("/dev/tty", O_WRONLY);
3981 log_error_errno(errno, "Failed to open /dev/tty: %m");
3982 _exit(EXIT_FAILURE);
3986 dup2(fd, STDOUT_FILENO);
3989 dup2(fd, STDERR_FILENO);
3995 /* Count arguments */
3997 for (n = 0; va_arg(ap, char*); n++)
4002 l = alloca(sizeof(char *) * (n + 1));
4004 /* Fill in arguments */
4006 for (i = 0; i <= n; i++)
4007 l[i] = va_arg(ap, char*);
4011 _exit(EXIT_FAILURE);
4014 /// UNNEEDED by elogind
4016 int setrlimit_closest(int resource, const struct rlimit *rlim) {
4017 struct rlimit highest, fixed;
4021 if (setrlimit(resource, rlim) >= 0)
4027 /* So we failed to set the desired setrlimit, then let's try
4028 * to get as close as we can */
4029 assert_se(getrlimit(resource, &highest) == 0);
4031 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
4032 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
4034 if (setrlimit(resource, &fixed) < 0)
4040 bool http_etag_is_valid(const char *etag) {
4044 if (!endswith(etag, "\""))
4047 if (!startswith(etag, "\"") && !startswith(etag, "W/\""))
4054 bool http_url_is_valid(const char *url) {
4060 p = startswith(url, "http://");
4062 p = startswith(url, "https://");
4069 return ascii_is_valid(p);
4072 bool documentation_url_is_valid(const char *url) {
4078 if (http_url_is_valid(url))
4081 p = startswith(url, "file:/");
4083 p = startswith(url, "info:");
4085 p = startswith(url, "man:");
4090 return ascii_is_valid(p);
4093 bool in_initrd(void) {
4094 static int saved = -1;
4100 /* We make two checks here:
4102 * 1. the flag file /etc/initrd-release must exist
4103 * 2. the root file system must be a memory file system
4105 * The second check is extra paranoia, since misdetecting an
4106 * initrd can have bad bad consequences due the initrd
4107 * emptying when transititioning to the main systemd.
4110 saved = access("/etc/initrd-release", F_OK) >= 0 &&
4111 statfs("/", &s) >= 0 &&
4112 is_temporary_fs(&s);
4117 int get_home_dir(char **_h) {
4125 /* Take the user specified one */
4126 e = secure_getenv("HOME");
4127 if (e && path_is_absolute(e)) {
4136 /* Hardcode home directory for root to avoid NSS */
4139 h = strdup("/root");
4147 /* Check the database... */
4151 return errno > 0 ? -errno : -ESRCH;
4153 if (!path_is_absolute(p->pw_dir))
4156 h = strdup(p->pw_dir);
4164 /// UNNEEDED by elogind
4166 int get_shell(char **_s) {
4174 /* Take the user specified one */
4175 e = getenv("SHELL");
4185 /* Hardcode home directory for root to avoid NSS */
4188 s = strdup("/bin/sh");
4196 /* Check the database... */
4200 return errno > 0 ? -errno : -ESRCH;
4202 if (!path_is_absolute(p->pw_shell))
4205 s = strdup(p->pw_shell);
4214 bool filename_is_valid(const char *p) {
4228 if (strlen(p) > FILENAME_MAX)
4234 bool string_is_safe(const char *p) {
4240 for (t = p; *t; t++) {
4241 if (*t > 0 && *t < ' ')
4244 if (strchr("\\\"\'\x7f", *t))
4252 * Check if a string contains control characters. If 'ok' is non-NULL
4253 * it may be a string containing additional CCs to be considered OK.
4255 bool string_has_cc(const char *p, const char *ok) {
4260 for (t = p; *t; t++) {
4261 if (ok && strchr(ok, *t))
4264 if (*t > 0 && *t < ' ')
4274 bool path_is_safe(const char *p) {
4279 if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
4282 if (strlen(p)+1 > PATH_MAX)
4285 /* The following two checks are not really dangerous, but hey, they still are confusing */
4286 if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
4289 if (strstr(p, "//"))
4295 /// UNNEEDED by elogind
4297 /* hey glibc, APIs with callbacks without a user pointer are so useless */
4298 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
4299 int (*compar) (const void *, const void *, void *), void *arg) {
4308 p = (void *)(((const char *) base) + (idx * size));
4309 comparison = compar(key, p, arg);
4312 else if (comparison > 0)
4320 void init_gettext(void) {
4321 setlocale(LC_ALL, "");
4322 textdomain(GETTEXT_PACKAGE);
4326 bool is_locale_utf8(void) {
4328 static int cached_answer = -1;
4330 if (cached_answer >= 0)
4333 if (!setlocale(LC_ALL, "")) {
4334 cached_answer = true;
4338 set = nl_langinfo(CODESET);
4340 cached_answer = true;
4344 if (streq(set, "UTF-8")) {
4345 cached_answer = true;
4349 /* For LC_CTYPE=="C" return true, because CTYPE is effectly
4350 * unset and everything can do to UTF-8 nowadays. */
4351 set = setlocale(LC_CTYPE, NULL);
4353 cached_answer = true;
4357 /* Check result, but ignore the result if C was set
4360 STR_IN_SET(set, "C", "POSIX") &&
4361 !getenv("LC_ALL") &&
4362 !getenv("LC_CTYPE") &&
4366 return (bool) cached_answer;
4369 const char *draw_special_char(DrawSpecialChar ch) {
4370 static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
4373 [DRAW_TREE_VERTICAL] = "\342\224\202 ", /* │ */
4374 [DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
4375 [DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
4376 [DRAW_TREE_SPACE] = " ", /* */
4377 [DRAW_TRIANGULAR_BULLET] = "\342\200\243", /* ‣ */
4378 [DRAW_BLACK_CIRCLE] = "\342\227\217", /* ● */
4379 [DRAW_ARROW] = "\342\206\222", /* → */
4380 [DRAW_DASH] = "\342\200\223", /* – */
4383 /* ASCII fallback */ {
4384 [DRAW_TREE_VERTICAL] = "| ",
4385 [DRAW_TREE_BRANCH] = "|-",
4386 [DRAW_TREE_RIGHT] = "`-",
4387 [DRAW_TREE_SPACE] = " ",
4388 [DRAW_TRIANGULAR_BULLET] = ">",
4389 [DRAW_BLACK_CIRCLE] = "*",
4390 [DRAW_ARROW] = "->",
4395 return draw_table[!is_locale_utf8()][ch];
4398 /// UNNEEDED by elogind
4400 char *strreplace(const char *text, const char *old_string, const char *new_string) {
4403 size_t l, old_len, new_len;
4409 old_len = strlen(old_string);
4410 new_len = strlen(new_string);
4423 if (!startswith(f, old_string)) {
4429 nl = l - old_len + new_len;
4430 a = realloc(r, nl + 1);
4438 t = stpcpy(t, new_string);
4450 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
4451 const char *i, *begin = NULL;
4456 } state = STATE_OTHER;
4458 size_t osz = 0, isz;
4464 /* Strips ANSI color and replaces TABs by 8 spaces */
4466 isz = _isz ? *_isz : strlen(*ibuf);
4468 f = open_memstream(&obuf, &osz);
4472 for (i = *ibuf; i < *ibuf + isz + 1; i++) {
4477 if (i >= *ibuf + isz) /* EOT */
4479 else if (*i == '\x1B')
4480 state = STATE_ESCAPE;
4481 else if (*i == '\t')
4488 if (i >= *ibuf + isz) { /* EOT */
4491 } else if (*i == '[') {
4492 state = STATE_BRACKET;
4497 state = STATE_OTHER;
4504 if (i >= *ibuf + isz || /* EOT */
4505 (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
4508 state = STATE_OTHER;
4510 } else if (*i == 'm')
4511 state = STATE_OTHER;
4533 int on_ac_power(void) {
4534 bool found_offline = false, found_online = false;
4535 _cleanup_closedir_ DIR *d = NULL;
4537 d = opendir("/sys/class/power_supply");
4539 return errno == ENOENT ? true : -errno;
4543 _cleanup_close_ int fd = -1, device = -1;
4549 if (!de && errno != 0)
4555 if (hidden_file(de->d_name))
4558 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
4560 if (errno == ENOENT || errno == ENOTDIR)
4566 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
4568 if (errno == ENOENT)
4574 n = read(fd, contents, sizeof(contents));
4578 if (n != 6 || memcmp(contents, "Mains\n", 6))
4582 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
4584 if (errno == ENOENT)
4590 n = read(fd, contents, sizeof(contents));
4594 if (n != 2 || contents[1] != '\n')
4597 if (contents[0] == '1') {
4598 found_online = true;
4600 } else if (contents[0] == '0')
4601 found_offline = true;
4606 return found_online || !found_offline;
4610 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
4617 if (!path_strv_resolve_uniq(search, root))
4620 STRV_FOREACH(i, search) {
4621 _cleanup_free_ char *p = NULL;
4625 p = strjoin(root, *i, "/", path, NULL);
4627 p = strjoin(*i, "/", path, NULL);
4637 if (errno != ENOENT)
4644 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
4645 _cleanup_strv_free_ char **copy = NULL;
4651 if (path_is_absolute(path)) {
4654 f = fopen(path, mode);
4663 copy = strv_copy((char**) search);
4667 return search_and_fopen_internal(path, mode, root, copy, _f);
4670 /// UNNEEDED by elogind
4672 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
4673 _cleanup_strv_free_ char **s = NULL;
4675 if (path_is_absolute(path)) {
4678 f = fopen(path, mode);
4687 s = strv_split_nulstr(search);
4691 return search_and_fopen_internal(path, mode, root, s, _f);
4695 char *strextend(char **x, ...) {
4702 l = f = *x ? strlen(*x) : 0;
4709 t = va_arg(ap, const char *);
4714 if (n > ((size_t) -1) - l) {
4723 r = realloc(*x, l+1);
4733 t = va_arg(ap, const char *);
4747 char *strrep(const char *s, unsigned n) {
4755 p = r = malloc(l * n + 1);
4759 for (i = 0; i < n; i++)
4766 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
4773 if (*allocated >= need)
4776 newalloc = MAX(need * 2, 64u / size);
4777 a = newalloc * size;
4779 /* check for overflows */
4780 if (a < size * need)
4788 *allocated = newalloc;
4792 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
4801 q = greedy_realloc(p, allocated, need, size);
4805 if (*allocated > prev)
4806 memzero(q + prev * size, (*allocated - prev) * size);
4811 bool id128_is_valid(const char *s) {
4817 /* Simple formatted 128bit hex string */
4819 for (i = 0; i < l; i++) {
4822 if (!(c >= '0' && c <= '9') &&
4823 !(c >= 'a' && c <= 'z') &&
4824 !(c >= 'A' && c <= 'Z'))
4828 } else if (l == 36) {
4830 /* Formatted UUID */
4832 for (i = 0; i < l; i++) {
4835 if ((i == 8 || i == 13 || i == 18 || i == 23)) {
4839 if (!(c >= '0' && c <= '9') &&
4840 !(c >= 'a' && c <= 'z') &&
4841 !(c >= 'A' && c <= 'Z'))
4852 /// UNNEEDED by elogind
4854 int split_pair(const char *s, const char *sep, char **l, char **r) {
4869 a = strndup(s, x - s);
4873 b = strdup(x + strlen(sep));
4885 int shall_restore_state(void) {
4886 _cleanup_free_ char *value = NULL;
4889 r = get_proc_cmdline_key("systemd.restore_state=", &value);
4895 return parse_boolean(value) != 0;
4899 int proc_cmdline(char **ret) {
4902 if (detect_container(NULL) > 0)
4903 return get_process_cmdline(1, 0, false, ret);
4905 return read_one_line_file("/proc/cmdline", ret);
4908 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
4909 _cleanup_free_ char *line = NULL;
4915 r = proc_cmdline(&line);
4921 _cleanup_free_ char *word = NULL;
4924 r = extract_first_word(&p, &word, NULL, EXTRACT_QUOTES|EXTRACT_RELAX);
4930 /* Filter out arguments that are intended only for the
4932 if (!in_initrd() && startswith(word, "rd."))
4935 value = strchr(word, '=');
4939 r = parse_item(word, value);
4947 int get_proc_cmdline_key(const char *key, char **value) {
4948 _cleanup_free_ char *line = NULL, *ret = NULL;
4955 r = proc_cmdline(&line);
4961 _cleanup_free_ char *word = NULL;
4964 r = extract_first_word(&p, &word, NULL, EXTRACT_QUOTES|EXTRACT_RELAX);
4970 /* Filter out arguments that are intended only for the
4972 if (!in_initrd() && startswith(word, "rd."))
4976 e = startswith(word, key);
4980 r = free_and_strdup(&ret, e);
4986 if (streq(word, key))
5000 int container_get_leader(const char *machine, pid_t *pid) {
5001 _cleanup_free_ char *s = NULL, *class = NULL;
5009 if (!machine_name_is_valid(machine))
5012 p = strjoina("/run/systemd/machines/", machine);
5013 r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
5021 if (!streq_ptr(class, "container"))
5024 r = parse_pid(s, &leader);
5034 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *userns_fd, int *root_fd) {
5035 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1, usernsfd = -1;
5043 mntns = procfs_file_alloca(pid, "ns/mnt");
5044 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
5052 pidns = procfs_file_alloca(pid, "ns/pid");
5053 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
5061 netns = procfs_file_alloca(pid, "ns/net");
5062 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
5070 userns = procfs_file_alloca(pid, "ns/user");
5071 usernsfd = open(userns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
5072 if (usernsfd < 0 && errno != ENOENT)
5079 root = procfs_file_alloca(pid, "root");
5080 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
5086 *pidns_fd = pidnsfd;
5089 *mntns_fd = mntnsfd;
5092 *netns_fd = netnsfd;
5095 *userns_fd = usernsfd;
5100 pidnsfd = mntnsfd = netnsfd = usernsfd = -1;
5105 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int userns_fd, int root_fd) {
5106 if (userns_fd >= 0) {
5107 /* Can't setns to your own userns, since then you could
5108 * escalate from non-root to root in your own namespace, so
5109 * check if namespaces equal before attempting to enter. */
5110 _cleanup_free_ char *userns_fd_path = NULL;
5112 if (asprintf(&userns_fd_path, "/proc/self/fd/%d", userns_fd) < 0)
5115 r = files_same(userns_fd_path, "/proc/self/ns/user");
5123 if (setns(pidns_fd, CLONE_NEWPID) < 0)
5127 if (setns(mntns_fd, CLONE_NEWNS) < 0)
5131 if (setns(netns_fd, CLONE_NEWNET) < 0)
5135 if (setns(userns_fd, CLONE_NEWUSER) < 0)
5139 if (fchdir(root_fd) < 0)
5142 if (chroot(".") < 0)
5146 return reset_uid_gid();
5149 int getpeercred(int fd, struct ucred *ucred) {
5150 socklen_t n = sizeof(struct ucred);
5157 r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
5161 if (n != sizeof(struct ucred))
5164 /* Check if the data is actually useful and not suppressed due
5165 * to namespacing issues */
5168 if (u.uid == UID_INVALID)
5170 if (u.gid == GID_INVALID)
5177 int getpeersec(int fd, char **ret) {
5189 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
5193 if (errno != ERANGE)
5200 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
5216 /* This is much like like mkostemp() but is subject to umask(). */
5217 int mkostemp_safe(char *pattern, int flags) {
5218 _cleanup_umask_ mode_t u;
5225 fd = mkostemp(pattern, flags);
5232 /// UNNEEDED by elogind
5234 int open_tmpfile(const char *path, int flags) {
5241 /* Try O_TMPFILE first, if it is supported */
5242 fd = open(path, flags|O_TMPFILE|O_EXCL, S_IRUSR|S_IWUSR);
5247 /* Fall back to unguessable name + unlinking */
5248 p = strjoina(path, "/systemd-tmp-XXXXXX");
5250 fd = mkostemp_safe(p, flags);
5259 int fd_warn_permissions(const char *path, int fd) {
5262 if (fstat(fd, &st) < 0)
5265 if (st.st_mode & 0111)
5266 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
5268 if (st.st_mode & 0002)
5269 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
5271 if (getpid() == 1 && (st.st_mode & 0044) != 0044)
5272 log_warning("Configuration file %s is marked world-inaccessible. This has no effect as configuration data is accessible via APIs without restrictions. Proceeding anyway.", path);
5277 /// UNNEEDED by elogind
5279 unsigned long personality_from_string(const char *p) {
5281 /* Parse a personality specifier. We introduce our own
5282 * identifiers that indicate specific ABIs, rather than just
5283 * hints regarding the register size, since we want to keep
5284 * things open for multiple locally supported ABIs for the
5285 * same register size. We try to reuse the ABI identifiers
5286 * used by libseccomp. */
5288 #if defined(__x86_64__)
5290 if (streq(p, "x86"))
5293 if (streq(p, "x86-64"))
5296 #elif defined(__i386__)
5298 if (streq(p, "x86"))
5302 return PERSONALITY_INVALID;
5305 const char* personality_to_string(unsigned long p) {
5307 #if defined(__x86_64__)
5309 if (p == PER_LINUX32)
5315 #elif defined(__i386__)
5325 uint64_t physical_memory(void) {
5328 /* We return this as uint64_t in case we are running as 32bit
5329 * process on a 64bit kernel with huge amounts of memory */
5331 mem = sysconf(_SC_PHYS_PAGES);
5334 return (uint64_t) mem * (uint64_t) page_size();
5337 /// UNNEEDED by elogind
5339 void hexdump(FILE *f, const void *p, size_t s) {
5340 const uint8_t *b = p;
5343 assert(s == 0 || b);
5348 fprintf(f, "%04x ", n);
5350 for (i = 0; i < 16; i++) {
5355 fprintf(f, "%02x ", b[i]);
5363 for (i = 0; i < 16; i++) {
5368 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
5382 int update_reboot_param_file(const char *param) {
5387 r = write_string_file(REBOOT_PARAM_FILE, param, WRITE_STRING_FILE_CREATE);
5389 log_error("Failed to write reboot param to "
5390 REBOOT_PARAM_FILE": %s", strerror(-r));
5392 unlink(REBOOT_PARAM_FILE);
5397 int umount_recursive(const char *prefix, int flags) {
5401 /* Try to umount everything recursively below a
5402 * directory. Also, take care of stacked mounts, and keep
5403 * unmounting them until they are gone. */
5406 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
5411 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
5412 if (!proc_self_mountinfo)
5416 _cleanup_free_ char *path = NULL, *p = NULL;
5419 k = fscanf(proc_self_mountinfo,
5420 "%*s " /* (1) mount id */
5421 "%*s " /* (2) parent id */
5422 "%*s " /* (3) major:minor */
5423 "%*s " /* (4) root */
5424 "%ms " /* (5) mount point */
5425 "%*s" /* (6) mount options */
5426 "%*[^-]" /* (7) optional fields */
5427 "- " /* (8) separator */
5428 "%*s " /* (9) file system type */
5429 "%*s" /* (10) mount source */
5430 "%*s" /* (11) mount options 2 */
5431 "%*[^\n]", /* some rubbish at the end */
5440 r = cunescape(path, UNESCAPE_RELAX, &p);
5444 if (!path_startswith(p, prefix))
5447 if (umount2(p, flags) < 0) {
5463 static int get_mount_flags(const char *path, unsigned long *flags) {
5466 if (statvfs(path, &buf) < 0)
5468 *flags = buf.f_flag;
5472 int bind_remount_recursive(const char *prefix, bool ro) {
5473 _cleanup_set_free_free_ Set *done = NULL;
5474 _cleanup_free_ char *cleaned = NULL;
5477 /* Recursively remount a directory (and all its submounts)
5478 * read-only or read-write. If the directory is already
5479 * mounted, we reuse the mount and simply mark it
5480 * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
5481 * operation). If it isn't we first make it one. Afterwards we
5482 * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
5483 * submounts we can access, too. When mounts are stacked on
5484 * the same mount point we only care for each individual
5485 * "top-level" mount on each point, as we cannot
5486 * influence/access the underlying mounts anyway. We do not
5487 * have any effect on future submounts that might get
5488 * propagated, they migt be writable. This includes future
5489 * submounts that have been triggered via autofs. */
5491 cleaned = strdup(prefix);
5495 path_kill_slashes(cleaned);
5497 done = set_new(&string_hash_ops);
5502 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
5503 _cleanup_set_free_free_ Set *todo = NULL;
5504 bool top_autofs = false;
5506 unsigned long orig_flags;
5508 todo = set_new(&string_hash_ops);
5512 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
5513 if (!proc_self_mountinfo)
5517 _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
5520 k = fscanf(proc_self_mountinfo,
5521 "%*s " /* (1) mount id */
5522 "%*s " /* (2) parent id */
5523 "%*s " /* (3) major:minor */
5524 "%*s " /* (4) root */
5525 "%ms " /* (5) mount point */
5526 "%*s" /* (6) mount options (superblock) */
5527 "%*[^-]" /* (7) optional fields */
5528 "- " /* (8) separator */
5529 "%ms " /* (9) file system type */
5530 "%*s" /* (10) mount source */
5531 "%*s" /* (11) mount options (bind mount) */
5532 "%*[^\n]", /* some rubbish at the end */
5542 r = cunescape(path, UNESCAPE_RELAX, &p);
5546 /* Let's ignore autofs mounts. If they aren't
5547 * triggered yet, we want to avoid triggering
5548 * them, as we don't make any guarantees for
5549 * future submounts anyway. If they are
5550 * already triggered, then we will find
5551 * another entry for this. */
5552 if (streq(type, "autofs")) {
5553 top_autofs = top_autofs || path_equal(cleaned, p);
5557 if (path_startswith(p, cleaned) &&
5558 !set_contains(done, p)) {
5560 r = set_consume(todo, p);
5570 /* If we have no submounts to process anymore and if
5571 * the root is either already done, or an autofs, we
5573 if (set_isempty(todo) &&
5574 (top_autofs || set_contains(done, cleaned)))
5577 if (!set_contains(done, cleaned) &&
5578 !set_contains(todo, cleaned)) {
5579 /* The prefix directory itself is not yet a
5580 * mount, make it one. */
5581 if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
5585 (void) get_mount_flags(cleaned, &orig_flags);
5586 orig_flags &= ~MS_RDONLY;
5588 if (mount(NULL, prefix, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
5591 x = strdup(cleaned);
5595 r = set_consume(done, x);
5600 while ((x = set_steal_first(todo))) {
5602 r = set_consume(done, x);
5603 if (r == -EEXIST || r == 0)
5608 /* Try to reuse the original flag set, but
5609 * don't care for errors, in case of
5610 * obstructed mounts */
5612 (void) get_mount_flags(x, &orig_flags);
5613 orig_flags &= ~MS_RDONLY;
5615 if (mount(NULL, x, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
5617 /* Deal with mount points that are
5618 * obstructed by a later mount */
5620 if (errno != ENOENT)
5629 int fflush_and_check(FILE *f) {
5636 return errno ? -errno : -EIO;
5641 int tempfn_xxxxxx(const char *p, const char *extra, char **ret) {
5653 * /foo/bar/.#<extra>waldoXXXXXX
5657 if (!filename_is_valid(fn))
5663 t = new(char, strlen(p) + 2 + strlen(extra) + 6 + 1);
5667 strcpy(stpcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), extra), fn), "XXXXXX");
5669 *ret = path_kill_slashes(t);
5673 int tempfn_random(const char *p, const char *extra, char **ret) {
5687 * /foo/bar/.#<extra>waldobaa2a261115984a9
5691 if (!filename_is_valid(fn))
5697 t = new(char, strlen(p) + 2 + strlen(extra) + 16 + 1);
5701 x = stpcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), extra), fn);
5704 for (i = 0; i < 16; i++) {
5705 *(x++) = hexchar(u & 0xF);
5711 *ret = path_kill_slashes(t);
5715 /// UNNEEDED by elogind
5717 int tempfn_random_child(const char *p, const char *extra, char **ret) {
5728 * /foo/bar/waldo/.#<extra>3c2b6219aa75d7d0
5734 t = new(char, strlen(p) + 3 + strlen(extra) + 16 + 1);
5738 x = stpcpy(stpcpy(stpcpy(t, p), "/.#"), extra);
5741 for (i = 0; i < 16; i++) {
5742 *(x++) = hexchar(u & 0xF);
5748 *ret = path_kill_slashes(t);
5752 int take_password_lock(const char *root) {
5754 struct flock flock = {
5756 .l_whence = SEEK_SET,
5764 /* This is roughly the same as lckpwdf(), but not as awful. We
5765 * don't want to use alarm() and signals, hence we implement
5766 * our own trivial version of this.
5768 * Note that shadow-utils also takes per-database locks in
5769 * addition to lckpwdf(). However, we don't given that they
5770 * are redundant as they they invoke lckpwdf() first and keep
5771 * it during everything they do. The per-database locks are
5772 * awfully racy, and thus we just won't do them. */
5775 path = strjoina(root, "/etc/.pwd.lock");
5777 path = "/etc/.pwd.lock";
5779 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
5783 r = fcntl(fd, F_SETLKW, &flock);
5792 int is_symlink(const char *path) {
5795 if (lstat(path, &info) < 0)
5798 return !!S_ISLNK(info.st_mode);
5802 int is_dir(const char* path, bool follow) {
5807 r = stat(path, &st);
5809 r = lstat(path, &st);
5813 return !!S_ISDIR(st.st_mode);
5816 /// UNNEEDED by elogind
5818 int is_device_node(const char *path) {
5821 if (lstat(path, &info) < 0)
5824 return !!(S_ISBLK(info.st_mode) || S_ISCHR(info.st_mode));
5828 int extract_first_word(const char **p, char **ret, const char *separators, ExtractFlags flags) {
5829 _cleanup_free_ char *s = NULL;
5830 size_t allocated = 0, sz = 0;
5838 SINGLE_QUOTE_ESCAPE,
5840 DOUBLE_QUOTE_ESCAPE,
5848 separators = WHITESPACE;
5850 /* Bail early if called after last value or with no input */
5852 goto finish_force_terminate;
5854 /* Parses the first word of a string, and returns it in
5855 * *ret. Removes all quotes in the process. When parsing fails
5856 * (because of an uneven number of quotes or similar), leaves
5857 * the pointer *p at the first invalid character. */
5865 if (flags & EXTRACT_DONT_COALESCE_SEPARATORS)
5866 if (!GREEDY_REALLOC(s, allocated, sz+1))
5870 goto finish_force_terminate;
5871 else if (strchr(separators, c)) {
5872 if (flags & EXTRACT_DONT_COALESCE_SEPARATORS) {
5874 goto finish_force_next;
5879 /* We found a non-blank character, so we will always
5880 * want to return a string (even if it is empty),
5881 * allocate it here. */
5882 if (!GREEDY_REALLOC(s, allocated, sz+1))
5890 goto finish_force_terminate;
5891 else if (c == '\'' && (flags & EXTRACT_QUOTES))
5892 state = SINGLE_QUOTE;
5894 state = VALUE_ESCAPE;
5895 else if (c == '\"' && (flags & EXTRACT_QUOTES))
5896 state = DOUBLE_QUOTE;
5897 else if (strchr(separators, c)) {
5898 if (flags & EXTRACT_DONT_COALESCE_SEPARATORS) {
5900 goto finish_force_next;
5904 if (!GREEDY_REALLOC(s, allocated, sz+2))
5914 if (flags & EXTRACT_RELAX)
5915 goto finish_force_terminate;
5917 } else if (c == '\'')
5920 state = SINGLE_QUOTE_ESCAPE;
5922 if (!GREEDY_REALLOC(s, allocated, sz+2))
5936 state = DOUBLE_QUOTE_ESCAPE;
5938 if (!GREEDY_REALLOC(s, allocated, sz+2))
5946 case SINGLE_QUOTE_ESCAPE:
5947 case DOUBLE_QUOTE_ESCAPE:
5949 if (!GREEDY_REALLOC(s, allocated, sz+7))
5953 if ((flags & EXTRACT_CUNESCAPE_RELAX) &&
5954 (state == VALUE_ESCAPE || flags & EXTRACT_RELAX)) {
5955 /* If we find an unquoted trailing backslash and we're in
5956 * EXTRACT_CUNESCAPE_RELAX mode, keep it verbatim in the
5959 * Unbalanced quotes will only be allowed in EXTRACT_RELAX
5960 * mode, EXTRACT_CUNESCAPE_RELAX mode does not allow them.
5963 goto finish_force_terminate;
5965 if (flags & EXTRACT_RELAX)
5966 goto finish_force_terminate;
5970 if (flags & EXTRACT_CUNESCAPE) {
5973 r = cunescape_one(*p, (size_t) -1, &c, &u);
5975 if (flags & EXTRACT_CUNESCAPE_RELAX) {
5986 s[sz++] = c; /* normal explicit char */
5988 sz += utf8_encode_unichar(s + sz, u); /* unicode chars we'll encode as utf8 */
5993 state = (state == SINGLE_QUOTE_ESCAPE) ? SINGLE_QUOTE :
5994 (state == DOUBLE_QUOTE_ESCAPE) ? DOUBLE_QUOTE :
6000 goto finish_force_terminate;
6001 if (!strchr(separators, c))
6009 finish_force_terminate:
6026 /// UNNEEDED by elogind
6028 int extract_first_word_and_warn(
6031 const char *separators,
6034 const char *filename,
6036 const char *rvalue) {
6037 /* Try to unquote it, if it fails, warn about it and try again but this
6038 * time using EXTRACT_CUNESCAPE_RELAX to keep the backslashes verbatim
6039 * in invalid escape sequences. */
6044 r = extract_first_word(p, ret, separators, flags);
6045 if (r < 0 && !(flags&EXTRACT_CUNESCAPE_RELAX)) {
6046 /* Retry it with EXTRACT_CUNESCAPE_RELAX. */
6048 r = extract_first_word(p, ret, separators, flags|EXTRACT_CUNESCAPE_RELAX);
6050 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
6051 "Unbalanced quoting in command line, ignoring: \"%s\"", rvalue);
6053 log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
6054 "Invalid escape sequences in command line: \"%s\"", rvalue);
6059 int extract_many_words(const char **p, const char *separators, ExtractFlags flags, ...) {
6064 /* Parses a number of words from a string, stripping any
6065 * quotes if necessary. */
6069 /* Count how many words are expected */
6070 va_start(ap, flags);
6072 if (!va_arg(ap, char **))
6081 /* Read all words into a temporary array */
6082 l = newa0(char*, n);
6083 for (c = 0; c < n; c++) {
6085 r = extract_first_word(p, &l[c], separators, flags);
6089 for (j = 0; j < c; j++)
6099 /* If we managed to parse all words, return them in the passed
6101 va_start(ap, flags);
6102 for (i = 0; i < n; i++) {
6105 v = va_arg(ap, char **);
6116 int free_and_strdup(char **p, const char *s) {
6121 /* Replaces a string pointer with an strdup()ed new string,
6122 * possibly freeing the old one. */
6124 if (streq_ptr(*p, s))
6140 /// UNNEEDED by elogind
6142 int ptsname_malloc(int fd, char **ret) {
6155 if (ptsname_r(fd, c, l) == 0) {
6159 if (errno != ERANGE) {
6169 int openpt_in_namespace(pid_t pid, int flags) {
6170 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, usernsfd = -1, rootfd = -1;
6171 _cleanup_close_pair_ int pair[2] = { -1, -1 };
6173 struct cmsghdr cmsghdr;
6174 uint8_t buf[CMSG_SPACE(sizeof(int))];
6176 struct msghdr mh = {
6177 .msg_control = &control,
6178 .msg_controllen = sizeof(control),
6180 struct cmsghdr *cmsg;
6187 r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &usernsfd, &rootfd);
6191 if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
6201 pair[0] = safe_close(pair[0]);
6203 r = namespace_enter(pidnsfd, mntnsfd, -1, usernsfd, rootfd);
6205 _exit(EXIT_FAILURE);
6207 master = posix_openpt(flags);
6209 _exit(EXIT_FAILURE);
6211 if (unlockpt(master) < 0)
6212 _exit(EXIT_FAILURE);
6214 cmsg = CMSG_FIRSTHDR(&mh);
6215 cmsg->cmsg_level = SOL_SOCKET;
6216 cmsg->cmsg_type = SCM_RIGHTS;
6217 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
6218 memcpy(CMSG_DATA(cmsg), &master, sizeof(int));
6220 mh.msg_controllen = cmsg->cmsg_len;
6222 if (sendmsg(pair[1], &mh, MSG_NOSIGNAL) < 0)
6223 _exit(EXIT_FAILURE);
6225 _exit(EXIT_SUCCESS);
6228 pair[1] = safe_close(pair[1]);
6230 r = wait_for_terminate(child, &si);
6233 if (si.si_code != CLD_EXITED || si.si_status != EXIT_SUCCESS)
6236 if (recvmsg(pair[0], &mh, MSG_NOSIGNAL|MSG_CMSG_CLOEXEC) < 0)
6239 CMSG_FOREACH(cmsg, &mh)
6240 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
6244 fds = (int*) CMSG_DATA(cmsg);
6245 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
6248 close_many(fds, n_fds);
6259 ssize_t fgetxattrat_fake(int dirfd, const char *filename, const char *attribute, void *value, size_t size, int flags) {
6260 _cleanup_close_ int fd = -1;
6263 /* The kernel doesn't have a fgetxattrat() command, hence let's emulate one */
6265 fd = openat(dirfd, filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOATIME|(flags & AT_SYMLINK_NOFOLLOW ? O_NOFOLLOW : 0));
6269 l = fgetxattr(fd, attribute, value, size);
6276 static int parse_crtime(le64_t le, usec_t *usec) {
6282 if (u == 0 || u == (uint64_t) -1)
6289 int fd_getcrtime(int fd, usec_t *usec) {
6296 /* Until Linux gets a real concept of birthtime/creation time,
6297 * let's fake one with xattrs */
6299 n = fgetxattr(fd, "user.crtime_usec", &le, sizeof(le));
6302 if (n != sizeof(le))
6305 return parse_crtime(le, usec);
6308 /// UNNEEDED by elogind
6310 int fd_getcrtime_at(int dirfd, const char *name, usec_t *usec, int flags) {
6314 n = fgetxattrat_fake(dirfd, name, "user.crtime_usec", &le, sizeof(le), flags);
6317 if (n != sizeof(le))
6320 return parse_crtime(le, usec);
6323 int path_getcrtime(const char *p, usec_t *usec) {
6330 n = getxattr(p, "user.crtime_usec", &le, sizeof(le));
6333 if (n != sizeof(le))
6336 return parse_crtime(le, usec);
6339 int fd_setcrtime(int fd, usec_t usec) {
6345 usec = now(CLOCK_REALTIME);
6347 le = htole64((uint64_t) usec);
6348 if (fsetxattr(fd, "user.crtime_usec", &le, sizeof(le), 0) < 0)
6354 int same_fd(int a, int b) {
6355 struct stat sta, stb;
6362 /* Compares two file descriptors. Note that semantics are
6363 * quite different depending on whether we have kcmp() or we
6364 * don't. If we have kcmp() this will only return true for
6365 * dup()ed file descriptors, but not otherwise. If we don't
6366 * have kcmp() this will also return true for two fds of the same
6367 * file, created by separate open() calls. Since we use this
6368 * call mostly for filtering out duplicates in the fd store
6369 * this difference hopefully doesn't matter too much. */
6374 /* Try to use kcmp() if we have it. */
6376 r = kcmp(pid, pid, KCMP_FILE, a, b);
6381 if (errno != ENOSYS)
6384 /* We don't have kcmp(), use fstat() instead. */
6385 if (fstat(a, &sta) < 0)
6388 if (fstat(b, &stb) < 0)
6391 if ((sta.st_mode & S_IFMT) != (stb.st_mode & S_IFMT))
6394 /* We consider all device fds different, since two device fds
6395 * might refer to quite different device contexts even though
6396 * they share the same inode and backing dev_t. */
6398 if (S_ISCHR(sta.st_mode) || S_ISBLK(sta.st_mode))
6401 if (sta.st_dev != stb.st_dev || sta.st_ino != stb.st_ino)
6404 /* The fds refer to the same inode on disk, let's also check
6405 * if they have the same fd flags. This is useful to
6406 * distinguish the read and write side of a pipe created with
6408 fa = fcntl(a, F_GETFL);
6412 fb = fcntl(b, F_GETFL);
6420 int chattr_fd(int fd, unsigned value, unsigned mask) {
6421 unsigned old_attr, new_attr;
6426 if (fstat(fd, &st) < 0)
6429 /* Explicitly check whether this is a regular file or
6430 * directory. If it is anything else (such as a device node or
6431 * fifo), then the ioctl will not hit the file systems but
6432 * possibly drivers, where the ioctl might have different
6433 * effects. Notably, DRM is using the same ioctl() number. */
6435 if (!S_ISDIR(st.st_mode) && !S_ISREG(st.st_mode))
6441 if (ioctl(fd, FS_IOC_GETFLAGS, &old_attr) < 0)
6444 new_attr = (old_attr & ~mask) | (value & mask);
6445 if (new_attr == old_attr)
6448 if (ioctl(fd, FS_IOC_SETFLAGS, &new_attr) < 0)
6454 /// UNNEEDED by elogind
6456 int chattr_path(const char *p, unsigned value, unsigned mask) {
6457 _cleanup_close_ int fd = -1;
6464 fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
6468 return chattr_fd(fd, value, mask);
6472 int read_attr_fd(int fd, unsigned *ret) {
6477 if (fstat(fd, &st) < 0)
6480 if (!S_ISDIR(st.st_mode) && !S_ISREG(st.st_mode))
6483 if (ioctl(fd, FS_IOC_GETFLAGS, ret) < 0)
6489 /// UNNEEDED by elogind
6491 int read_attr_path(const char *p, unsigned *ret) {
6492 _cleanup_close_ int fd = -1;
6497 fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
6501 return read_attr_fd(fd, ret);
6504 static size_t nul_length(const uint8_t *p, size_t sz) {
6519 ssize_t sparse_write(int fd, const void *p, size_t sz, size_t run_length) {
6520 const uint8_t *q, *w, *e;
6528 n = nul_length(q, e - q);
6530 /* If there are more than the specified run length of
6531 * NUL bytes, or if this is the beginning or the end
6532 * of the buffer, then seek instead of write */
6533 if ((n > run_length) ||
6534 (n > 0 && q == p) ||
6535 (n > 0 && q + n >= e)) {
6537 l = write(fd, w, q - w);
6544 if (lseek(fd, n, SEEK_CUR) == (off_t) -1)
6556 l = write(fd, w, q - w);
6563 return q - (const uint8_t*) p;
6567 void sigkill_wait(pid_t *pid) {
6573 if (kill(*pid, SIGKILL) > 0)
6574 (void) wait_for_terminate(*pid, NULL);
6577 /// UNNEEDED by elogind
6579 int syslog_parse_priority(const char **p, int *priority, bool with_facility) {
6580 int a = 0, b = 0, c = 0;
6590 if (!strchr(*p, '>'))
6593 if ((*p)[2] == '>') {
6594 c = undecchar((*p)[1]);
6596 } else if ((*p)[3] == '>') {
6597 b = undecchar((*p)[1]);
6598 c = undecchar((*p)[2]);
6600 } else if ((*p)[4] == '>') {
6601 a = undecchar((*p)[1]);
6602 b = undecchar((*p)[2]);
6603 c = undecchar((*p)[3]);
6608 if (a < 0 || b < 0 || c < 0 ||
6609 (!with_facility && (a || b || c > 7)))
6613 *priority = a*100 + b*10 + c;
6615 *priority = (*priority & LOG_FACMASK) | c;
6622 ssize_t string_table_lookup(const char * const *table, size_t len, const char *key) {
6628 for (i = 0; i < len; ++i)
6629 if (streq_ptr(table[i], key))
6635 /// UNNEEDED by elogind
6637 void cmsg_close_all(struct msghdr *mh) {
6638 struct cmsghdr *cmsg;
6642 CMSG_FOREACH(cmsg, mh)
6643 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS)
6644 close_many((int*) CMSG_DATA(cmsg), (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int));
6647 int rename_noreplace(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
6651 ret = renameat2(olddirfd, oldpath, newdirfd, newpath, RENAME_NOREPLACE);
6655 /* renameat2() exists since Linux 3.15, btrfs added support for it later.
6656 * If it is not implemented, fallback to another method. */
6657 if (!IN_SET(errno, EINVAL, ENOSYS))
6660 /* The link()/unlink() fallback does not work on directories. But
6661 * renameat() without RENAME_NOREPLACE gives the same semantics on
6662 * directories, except when newpath is an *empty* directory. This is
6664 ret = fstatat(olddirfd, oldpath, &buf, AT_SYMLINK_NOFOLLOW);
6665 if (ret >= 0 && S_ISDIR(buf.st_mode)) {
6666 ret = renameat(olddirfd, oldpath, newdirfd, newpath);
6667 return ret >= 0 ? 0 : -errno;
6670 /* If it is not a directory, use the link()/unlink() fallback. */
6671 ret = linkat(olddirfd, oldpath, newdirfd, newpath, 0);
6675 ret = unlinkat(olddirfd, oldpath, 0);
6677 /* backup errno before the following unlinkat() alters it */
6679 (void) unlinkat(newdirfd, newpath, 0);
6687 static char *strcpy_backslash_escaped(char *t, const char *s, const char *bad) {
6691 if (*s == '\\' || strchr(bad, *s))
6700 char *shell_escape(const char *s, const char *bad) {
6703 r = new(char, strlen(s)*2+1);
6707 t = strcpy_backslash_escaped(r, s, bad);
6713 char *shell_maybe_quote(const char *s) {
6719 /* Encloses a string in double quotes if necessary to make it
6720 * OK as shell string. */
6722 for (p = s; *p; p++)
6725 strchr(SHELL_NEED_QUOTES, *p))
6731 r = new(char, 1+strlen(s)*2+1+1);
6737 t = mempcpy(t, s, p - s);
6739 t = strcpy_backslash_escaped(t, p, SHELL_NEED_ESCAPE);
6748 int parse_mode(const char *s, mode_t *ret) {
6756 l = strtol(s, &x, 8);
6760 if (!x || x == s || *x)
6762 if (l < 0 || l > 07777)
6769 /// UNNEEDED by elogind
6771 int mount_move_root(const char *path) {
6774 if (chdir(path) < 0)
6777 if (mount(path, "/", NULL, MS_MOVE, NULL) < 0)
6780 if (chroot(".") < 0)
6790 int reset_uid_gid(void) {
6792 if (setgroups(0, NULL) < 0)
6795 if (setresgid(0, 0, 0) < 0)
6798 if (setresuid(0, 0, 0) < 0)
6804 int getxattr_malloc(const char *path, const char *name, char **value, bool allow_symlink) {
6813 for (l = 100; ; l = (size_t) n + 1) {
6819 n = lgetxattr(path, name, v, l);
6821 n = getxattr(path, name, v, l);
6823 if (n >= 0 && (size_t) n < l) {
6830 if (n < 0 && errno != ERANGE)
6834 n = lgetxattr(path, name, NULL, 0);
6836 n = getxattr(path, name, NULL, 0);
6842 int fgetxattr_malloc(int fd, const char *name, char **value) {
6851 for (l = 100; ; l = (size_t) n + 1) {
6856 n = fgetxattr(fd, name, v, l);
6858 if (n >= 0 && (size_t) n < l) {
6865 if (n < 0 && errno != ERANGE)
6868 n = fgetxattr(fd, name, NULL, 0);