#include <ctype.h>

#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <glob.h>

#include <grp.h>

#include <langinfo.h>

#include <libintl.h>

#include <limits.h>

#include <linux/magic.h>

#include <linux/oom.h>

#include <linux/sched.h>

#include <locale.h>

#include <netinet/ip.h>

#include <poll.h>

#include <pwd.h>

#include <sched.h>

#include <signal.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/file.h>

#include <sys/ioctl.h>

#include <sys/mman.h>

#include <sys/mount.h>

#include <sys/personality.h>

#include <sys/prctl.h>

#include <sys/resource.h>

#include <sys/stat.h>

#include <sys/statvfs.h>

#include <sys/time.h>

#include <sys/types.h>

#include <sys/utsname.h>

#include <sys/vfs.h>

#include <sys/wait.h>

#include <sys/xattr.h>

#include <syslog.h>

#include <unistd.h>

#include <libgen.h>

#undef basename

#ifdef HAVE_SYS_AUXV_H

#include <sys/auxv.h>

#endif

#include <linux/fs.h>

#include "build.h"

#include "def.h"

#include "device-nodes.h"

#include "env-util.h"

#include "escape.h"

#include "exit-status.h"

#include "fd-util.h"

#include "fileio.h"

#include "formats-util.h"

#include "gunicode.h"

#include "hashmap.h"

#include "hostname-util.h"

#include "ioprio.h"

#include "log.h"

#include "macro.h"

#include "missing.h"

#include "mkdir.h"

#include "path-util.h"

#include "process-util.h"

#include "random-util.h"

#include "signal-util.h"

#include "sparse-endian.h"

#include "string-util.h"

#include "strv.h"

#include "terminal-util.h"

#include "utf8.h"

#include "util.h"

#include "virt.h"

assert_cc(EAGAIN == EWOULDBLOCK);

int saved_argc = 0;

char **saved_argv = NULL;

size_t page_size(void) {

static thread_local size_t pgsz = 0;

long r;

if (_likely_(pgsz > 0))

return pgsz;

r = sysconf(_SC_PAGESIZE);

assert(r > 0);

pgsz = (size_t) r;

return pgsz;

}

int unlink_noerrno(const char *path) {

PROTECT_ERRNO;

int r;

r = unlink(path);

if (r < 0)

return -errno;

return 0;

}

int parse_boolean(const char *v) {

assert(v);

if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))

return 1;

else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))

return 0;

return -EINVAL;

}

int parse_pid(const char *s, pid_t* ret_pid) {

unsigned long ul = 0;

pid_t pid;

int r;

assert(s);

assert(ret_pid);

r = safe_atolu(s, &ul);

if (r < 0)

return r;

pid = (pid_t) ul;

if ((unsigned long) pid != ul)

return -ERANGE;

if (pid <= 0)

return -ERANGE;

*ret_pid = pid;

return 0;

}

bool uid_is_valid(uid_t uid) {

/* Some libc APIs use UID_INVALID as special placeholder */

if (uid == (uid_t) 0xFFFFFFFF)

return false;

/* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */

if (uid == (uid_t) 0xFFFF)

return false;

return true;

}

int parse_uid(const char *s, uid_t* ret_uid) {

unsigned long ul = 0;

uid_t uid;

int r;

assert(s);

r = safe_atolu(s, &ul);

if (r < 0)

return r;

uid = (uid_t) ul;

if ((unsigned long) uid != ul)

return -ERANGE;

if (!uid_is_valid(uid))

return -ENXIO; /* we return ENXIO instead of EINVAL

if (ret_uid)

*ret_uid = uid;

return 0;

}

int safe_atou(const char *s, unsigned *ret_u) {

char *x = NULL;

unsigned long l;

assert(s);

assert(ret_u);

errno = 0;

l = strtoul(s, &x, 0);

if (!x || x == s || *x || errno)

return errno > 0 ? -errno : -EINVAL;

if ((unsigned long) (unsigned) l != l)

return -ERANGE;

*ret_u = (unsigned) l;

return 0;

}

int safe_atoi(const char *s, int *ret_i) {

char *x = NULL;

long l;

assert(s);

assert(ret_i);

errno = 0;

l = strtol(s, &x, 0);

if (!x || x == s || *x || errno)

return errno > 0 ? -errno : -EINVAL;

if ((long) (int) l != l)

return -ERANGE;

*ret_i = (int) l;

return 0;

}

int safe_atou8(const char *s, uint8_t *ret) {

char *x = NULL;

unsigned long l;

assert(s);

assert(ret);

errno = 0;

l = strtoul(s, &x, 0);

if (!x || x == s || *x || errno)

return errno > 0 ? -errno : -EINVAL;

if ((unsigned long) (uint8_t) l != l)

return -ERANGE;

*ret = (uint8_t) l;

return 0;

}

int safe_atou16(const char *s, uint16_t *ret) {

char *x = NULL;

unsigned long l;

assert(s);

assert(ret);

errno = 0;

l = strtoul(s, &x, 0);

if (!x || x == s || *x || errno)

return errno > 0 ? -errno : -EINVAL;

if ((unsigned long) (uint16_t) l != l)

return -ERANGE;

*ret = (uint16_t) l;

return 0;

}

int safe_atoi16(const char *s, int16_t *ret) {

char *x = NULL;

long l;

assert(s);

assert(ret);

errno = 0;

l = strtol(s, &x, 0);

if (!x || x == s || *x || errno)

return errno > 0 ? -errno : -EINVAL;

if ((long) (int16_t) l != l)

return -ERANGE;

*ret = (int16_t) l;

return 0;

}

int safe_atollu(const char *s, long long unsigned *ret_llu) {

char *x = NULL;

unsigned long long l;

assert(s);

assert(ret_llu);

errno = 0;

l = strtoull(s, &x, 0);

if (!x || x == s || *x || errno)

return errno ? -errno : -EINVAL;

*ret_llu = l;

return 0;

}

int safe_atolli(const char *s, long long int *ret_lli) {

char *x = NULL;

long long l;

assert(s);

assert(ret_lli);

errno = 0;

l = strtoll(s, &x, 0);

if (!x || x == s || *x || errno)

return errno ? -errno : -EINVAL;

*ret_lli = l;

return 0;

}

int safe_atod(const char *s, double *ret_d) {

char *x = NULL;

double d = 0;

locale_t loc;

assert(s);

assert(ret_d);

loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);

if (loc == (locale_t) 0)

return -errno;

errno = 0;

d = strtod_l(s, &x, loc);

if (!x || x == s || *x || errno) {

freelocale(loc);

return errno ? -errno : -EINVAL;

}

freelocale(loc);

*ret_d = (double) d;

return 0;

}

int fchmod_umask(int fd, mode_t m) {

mode_t u;

int r;

u = umask(0777);

r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;

umask(u);

return r;

}

int readlinkat_malloc(int fd, const char *p, char **ret) {

size_t l = 100;

int r;

assert(p);

assert(ret);

for (;;) {

char *c;

ssize_t n;

c = new(char, l);

if (!c)

return -ENOMEM;

n = readlinkat(fd, p, c, l-1);

if (n < 0) {

r = -errno;

free(c);

return r;

}

if ((size_t) n < l-1) {

c[n] = 0;

*ret = c;

return 0;

}

free(c);

l *= 2;

}

}

int readlink_malloc(const char *p, char **ret) {

return readlinkat_malloc(AT_FDCWD, p, ret);

}

int readlink_value(const char *p, char **ret) {

_cleanup_free_ char *link = NULL;

char *value;

int r;

r = readlink_malloc(p, &link);

if (r < 0)

return r;

value = basename(link);

if (!value)

return -ENOENT;

value = strdup(value);

if (!value)

return -ENOMEM;

*ret = value;

return 0;

}

int readlink_and_make_absolute(const char *p, char **r) {

_cleanup_free_ char *target = NULL;

char *k;

int j;

assert(p);

assert(r);

j = readlink_malloc(p, &target);

if (j < 0)

return j;

k = file_in_same_dir(p, target);

if (!k)

return -ENOMEM;

*r = k;

return 0;

}

int readlink_and_canonicalize(const char *p, char **r) {

char *t, *s;

int j;

assert(p);

assert(r);

j = readlink_and_make_absolute(p, &t);

if (j < 0)

return j;

s = canonicalize_file_name(t);

if (s) {

free(t);

*r = s;

} else

*r = t;

path_kill_slashes(*r);

return 0;

}

char *file_in_same_dir(const char *path, const char *filename) {

char *e, *ret;

size_t k;

assert(path);

assert(filename);

/* This removes the last component of path and appends

if (path_is_absolute(filename))

return strdup(filename);

e = strrchr(path, '/');

if (!e)

return strdup(filename);

k = strlen(filename);

ret = new(char, (e + 1 - path) + k + 1);

if (!ret)

return NULL;

memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);

return ret;

}

int rmdir_parents(const char *path, const char *stop) {

size_t l;

int r = 0;

assert(path);

assert(stop);

l = strlen(path);

/* Skip trailing slashes */

while (l > 0 && path[l-1] == '/')

l--;

while (l > 0) {

char *t;

/* Skip last component */

while (l > 0 && path[l-1] != '/')

l--;

/* Skip trailing slashes */

while (l > 0 && path[l-1] == '/')

l--;

if (l <= 0)

break;

if (!(t = strndup(path, l)))

return -ENOMEM;

if (path_startswith(stop, t)) {

free(t);

return 0;

}

r = rmdir(t);

free(t);

if (r < 0)

if (errno != ENOENT)

return -errno;

}

return 0;

}

char hexchar(int x) {

static const char table[16] = "0123456789abcdef";

return table[x & 15];

}

int unhexchar(char c) {

if (c >= '0' && c <= '9')

return c - '0';

if (c >= 'a' && c <= 'f')

return c - 'a' + 10;

if (c >= 'A' && c <= 'F')

return c - 'A' + 10;

return -EINVAL;

}

char *hexmem(const void *p, size_t l) {

char *r, *z;

const uint8_t *x;

z = r = malloc(l * 2 + 1);

if (!r)

return NULL;

for (x = p; x < (const uint8_t*) p + l; x++) {

*(z++) = hexchar(*x >> 4);

*(z++) = hexchar(*x & 15);

}

*z = 0;

return r;

}

int unhexmem(const char *p, size_t l, void **mem, size_t *len) {

_cleanup_free_ uint8_t *r = NULL;

uint8_t *z;

const char *x;

assert(mem);

assert(len);

assert(p);

z = r = malloc((l + 1) / 2 + 1);

if (!r)

return -ENOMEM;

for (x = p; x < p + l; x += 2) {

int a, b;

a = unhexchar(x[0]);

if (a < 0)

return a;

else if (x+1 < p + l) {

b = unhexchar(x[1]);

if (b < 0)

return b;

} else

b = 0;

*(z++) = (uint8_t) a << 4 | (uint8_t) b;

}

*z = 0;

*mem = r;

r = NULL;

*len = (l + 1) / 2;

return 0;

}

char base32hexchar(int x) {

static const char table[32] = "0123456789"

"ABCDEFGHIJKLMNOPQRSTUV";

return table[x & 31];

}

int unbase32hexchar(char c) {

unsigned offset;

if (c >= '0' && c <= '9')

return c - '0';

offset = '9' - '0' + 1;

if (c >= 'A' && c <= 'V')

return c - 'A' + offset;

return -EINVAL;

}

char *base32hexmem(const void *p, size_t l, bool padding) {

char *r, *z;

const uint8_t *x;

size_t len;

if (padding)

/* five input bytes makes eight output bytes, padding is added so we must round up */

len = 8 * (l + 4) / 5;

else {

/* same, but round down as there is no padding */

len = 8 * l / 5;

switch (l % 5) {

case 4:

len += 7;

break;

case 3:

len += 5;

break;

case 2:

len += 4;

break;

case 1:

len += 2;

break;

}

}

z = r = malloc(len + 1);

if (!r)

return NULL;

for (x = p; x < (const uint8_t*) p + (l / 5) * 5; x += 5) {

/* x[0] == XXXXXXXX; x[1] == YYYYYYYY; x[2] == ZZZZZZZZ

*(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */

*(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */

*(z++) = base32hexchar((x[1] & 63) >> 1); /* 000YYYYY */

*(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4); /* 000YZZZZ */

*(z++) = base32hexchar((x[2] & 15) << 1 | x[3] >> 7); /* 000ZZZZQ */

*(z++) = base32hexchar((x[3] & 127) >> 2); /* 000QQQQQ */

*(z++) = base32hexchar((x[3] & 3) << 3 | x[4] >> 5); /* 000QQWWW */

*(z++) = base32hexchar((x[4] & 31)); /* 000WWWWW */

}

switch (l % 5) {

case 4:

*(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */

*(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */

*(z++) = base32hexchar((x[1] & 63) >> 1); /* 000YYYYY */

*(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4); /* 000YZZZZ */

*(z++) = base32hexchar((x[2] & 15) << 1 | x[3] >> 7); /* 000ZZZZQ */

*(z++) = base32hexchar((x[3] & 127) >> 2); /* 000QQQQQ */

*(z++) = base32hexchar((x[3] & 3) << 3); /* 000QQ000 */

if (padding)

*(z++) = '=';

break;

case 3:

*(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */

*(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */

*(z++) = base32hexchar((x[1] & 63) >> 1); /* 000YYYYY */

*(z++) = base32hexchar((x[1] & 1) << 4 | x[2] >> 4); /* 000YZZZZ */

*(z++) = base32hexchar((x[2] & 15) << 1); /* 000ZZZZ0 */

if (padding) {

*(z++) = '=';

*(z++) = '=';

*(z++) = '=';

}

break;

case 2:

*(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */

*(z++) = base32hexchar((x[0] & 7) << 2 | x[1] >> 6); /* 000XXXYY */

*(z++) = base32hexchar((x[1] & 63) >> 1); /* 000YYYYY */

*(z++) = base32hexchar((x[1] & 1) << 4); /* 000Y0000 */

if (padding) {

*(z++) = '=';

*(z++) = '=';

*(z++) = '=';

*(z++) = '=';

}

break;

case 1:

*(z++) = base32hexchar(x[0] >> 3); /* 000XXXXX */

*(z++) = base32hexchar((x[0] & 7) << 2); /* 000XXX00 */

if (padding) {

*(z++) = '=';

*(z++) = '=';

*(z++) = '=';

*(z++) = '=';

*(z++) = '=';

*(z++) = '=';

}

break;

}

*z = 0;

return r;

}

int unbase32hexmem(const char *p, size_t l, bool padding, void **mem, size_t *_len) {

_cleanup_free_ uint8_t *r = NULL;

int a, b, c, d, e, f, g, h;

uint8_t *z;

const char *x;

size_t len;

unsigned pad = 0;

assert(p);

/* padding ensures any base32hex input has input divisible by 8 */

if (padding && l % 8 != 0)

return -EINVAL;

if (padding) {

/* strip the padding */

while (l > 0 && p[l - 1] == '=' && pad < 7) {

pad ++;

l --;

}

}

/* a group of eight input bytes needs five output bytes, in case of

len = (l / 8) * 5;

switch (l % 8) {

case 7:

len += 4;

break;

case 5:

len += 3;

break;

case 4:

len += 2;

break;

case 2:

len += 1;

break;

case 0:

break;

default:

return -EINVAL;

}

z = r = malloc(len + 1);

if (!r)

return -ENOMEM;

for (x = p; x < p + (l / 8) * 8; x += 8) {

/* a == 000XXXXX; b == 000YYYYY; c == 000ZZZZZ; d == 000WWWWW

a = unbase32hexchar(x[0]);

if (a < 0)

return -EINVAL;

b = unbase32hexchar(x[1]);

if (b < 0)

return -EINVAL;

c = unbase32hexchar(x[2]);

if (c < 0)

return -EINVAL;

d = unbase32hexchar(x[3]);

if (d < 0)

return -EINVAL;

e = unbase32hexchar(x[4]);

if (e < 0)

return -EINVAL;

f = unbase32hexchar(x[5]);

if (f < 0)

return -EINVAL;

g = unbase32hexchar(x[6]);

if (g < 0)

return -EINVAL;

h = unbase32hexchar(x[7]);

if (h < 0)

return -EINVAL;

*(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */

*(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */

*(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1; /* WWWWSSSS */

*(z++) = (uint8_t) e << 7 | (uint8_t) f << 2 | (uint8_t) g >> 3; /* SQQQQQVV */

*(z++) = (uint8_t) g << 5 | (uint8_t) h; /* VVVRRRRR */

}

switch (l % 8) {

case 7:

a = unbase32hexchar(x[0]);

if (a < 0)

return -EINVAL;

b = unbase32hexchar(x[1]);

if (b < 0)

return -EINVAL;

c = unbase32hexchar(x[2]);

if (c < 0)

return -EINVAL;

d = unbase32hexchar(x[3]);

if (d < 0)

return -EINVAL;

e = unbase32hexchar(x[4]);

if (e < 0)

return -EINVAL;

f = unbase32hexchar(x[5]);

if (f < 0)

return -EINVAL;

g = unbase32hexchar(x[6]);

if (g < 0)

return -EINVAL;

/* g == 000VV000 */

if (g & 7)

return -EINVAL;

*(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */

*(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */

*(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1; /* WWWWSSSS */

*(z++) = (uint8_t) e << 7 | (uint8_t) f << 2 | (uint8_t) g >> 3; /* SQQQQQVV */

break;

case 5:

a = unbase32hexchar(x[0]);

if (a < 0)

return -EINVAL;

b = unbase32hexchar(x[1]);

if (b < 0)

return -EINVAL;

c = unbase32hexchar(x[2]);

if (c < 0)

return -EINVAL;

d = unbase32hexchar(x[3]);

if (d < 0)

return -EINVAL;

e = unbase32hexchar(x[4]);

if (e < 0)

return -EINVAL;

/* e == 000SSSS0 */

if (e & 1)

return -EINVAL;

*(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */

*(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */

*(z++) = (uint8_t) d << 4 | (uint8_t) e >> 1; /* WWWWSSSS */

break;

case 4:

a = unbase32hexchar(x[0]);

if (a < 0)

return -EINVAL;

b = unbase32hexchar(x[1]);

if (b < 0)

return -EINVAL;

c = unbase32hexchar(x[2]);

if (c < 0)

return -EINVAL;

d = unbase32hexchar(x[3]);

if (d < 0)

return -EINVAL;

/* d == 000W0000 */

if (d & 15)

return -EINVAL;

*(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */

*(z++) = (uint8_t) b << 6 | (uint8_t) c << 1 | (uint8_t) d >> 4; /* YYZZZZZW */

break;

case 2:

a = unbase32hexchar(x[0]);

if (a < 0)

return -EINVAL;

b = unbase32hexchar(x[1]);

if (b < 0)

return -EINVAL;

/* b == 000YYY00 */

if (b & 3)

return -EINVAL;

*(z++) = (uint8_t) a << 3 | (uint8_t) b >> 2; /* XXXXXYYY */

break;

case 0:

break;

default:

return -EINVAL;

}

*z = 0;

*mem = r;

r = NULL;

*_len = len;

return 0;

}

char base64char(int x) {

static const char table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

"abcdefghijklmnopqrstuvwxyz"

"0123456789+/";

return table[x & 63];

}

int unbase64char(char c) {

unsigned offset;

if (c >= 'A' && c <= 'Z')

return c - 'A';

offset = 'Z' - 'A' + 1;

if (c >= 'a' && c <= 'z')

return c - 'a' + offset;

offset += 'z' - 'a' + 1;

if (c >= '0' && c <= '9')

return c - '0' + offset;

offset += '9' - '0' + 1;

if (c == '+')

return offset;

offset ++;

if (c == '/')

return offset;

return -EINVAL;

}

char *base64mem(const void *p, size_t l) {

char *r, *z;

const uint8_t *x;

/* three input bytes makes four output bytes, padding is added so we must round up */

z = r = malloc(4 * (l + 2) / 3 + 1);

if (!r)

return NULL;

for (x = p; x < (const uint8_t*) p + (l / 3) * 3; x += 3) {

/* x[0] == XXXXXXXX; x[1] == YYYYYYYY; x[2] == ZZZZZZZZ */

*(z++) = base64char(x[0] >> 2); /* 00XXXXXX */

*(z++) = base64char((x[0] & 3) << 4 | x[1] >> 4); /* 00XXYYYY */

*(z++) = base64char((x[1] & 15) << 2 | x[2] >> 6); /* 00YYYYZZ */

*(z++) = base64char(x[2] & 63); /* 00ZZZZZZ */

}

switch (l % 3) {

case 2:

*(z++) = base64char(x[0] >> 2); /* 00XXXXXX */

*(z++) = base64char((x[0] & 3) << 4 | x[1] >> 4); /* 00XXYYYY */

*(z++) = base64char((x[1] & 15) << 2); /* 00YYYY00 */

*(z++) = '=';

break;

case 1:

*(z++) = base64char(x[0] >> 2); /* 00XXXXXX */

*(z++) = base64char((x[0] & 3) << 4); /* 00XX0000 */

*(z++) = '=';

*(z++) = '=';

break;

}

*z = 0;

return r;

}

int unbase64mem(const char *p, size_t l, void **mem, size_t *_len) {

_cleanup_free_ uint8_t *r = NULL;

int a, b, c, d;

uint8_t *z;

const char *x;

size_t len;

assert(p);

/* padding ensures any base63 input has input divisible by 4 */

if (l % 4 != 0)

return -EINVAL;

/* strip the padding */

if (l > 0 && p[l - 1] == '=')

l --;

if (l > 0 && p[l - 1] == '=')

l --;

/* a group of four input bytes needs three output bytes, in case of

len = (l / 4) * 3 + (l % 4 ? (l % 4) - 1 : 0);

z = r = malloc(len + 1);

if (!r)

return -ENOMEM;

for (x = p; x < p + (l / 4) * 4; x += 4) {

/* a == 00XXXXXX; b == 00YYYYYY; c == 00ZZZZZZ; d == 00WWWWWW */

a = unbase64char(x[0]);

if (a < 0)

return -EINVAL;

b = unbase64char(x[1]);

if (b < 0)

return -EINVAL;

c = unbase64char(x[2]);

if (c < 0)

return -EINVAL;

d = unbase64char(x[3]);

if (d < 0)

return -EINVAL;

*(z++) = (uint8_t) a << 2 | (uint8_t) b >> 4; /* XXXXXXYY */

*(z++) = (uint8_t) b << 4 | (uint8_t) c >> 2; /* YYYYZZZZ */

*(z++) = (uint8_t) c << 6 | (uint8_t) d; /* ZZWWWWWW */

}

switch (l % 4) {

case 3:

a = unbase64char(x[0]);

if (a < 0)

return -EINVAL;

b = unbase64char(x[1]);

if (b < 0)

return -EINVAL;

c = unbase64char(x[2]);

if (c < 0)

return -EINVAL;

/* c == 00ZZZZ00 */

if (c & 3)

return -EINVAL;

*(z++) = (uint8_t) a << 2 | (uint8_t) b >> 4; /* XXXXXXYY */

*(z++) = (uint8_t) b << 4 | (uint8_t) c >> 2; /* YYYYZZZZ */

break;

case 2:

a = unbase64char(x[0]);

if (a < 0)

return -EINVAL;

b = unbase64char(x[1]);

if (b < 0)

return -EINVAL;

/* b == 00YY0000 */

if (b & 15)

return -EINVAL;

*(z++) = (uint8_t) a << 2 | (uint8_t) (b >> 4); /* XXXXXXYY */

break;

case 0:

break;

default:

return -EINVAL;

}

*z = 0;

*mem = r;

r = NULL;

*_len = len;

return 0;

}

char octchar(int x) {

return '0' + (x & 7);

}

int unoctchar(char c) {

if (c >= '0' && c <= '7')

return c - '0';

return -EINVAL;

}

char decchar(int x) {

return '0' + (x % 10);

}

int undecchar(char c) {

if (c >= '0' && c <= '9')

return c - '0';

return -EINVAL;

}

_pure_ static bool hidden_file_allow_backup(const char *filename) {

assert(filename);

return

filename[0] == '.' ||

streq(filename, "lost+found") ||

streq(filename, "aquota.user") ||

streq(filename, "aquota.group") ||

endswith(filename, ".rpmnew") ||

endswith(filename, ".rpmsave") ||

endswith(filename, ".rpmorig") ||

endswith(filename, ".dpkg-old") ||

endswith(filename, ".dpkg-new") ||

endswith(filename, ".dpkg-tmp") ||

endswith(filename, ".dpkg-dist") ||

endswith(filename, ".dpkg-bak") ||

endswith(filename, ".dpkg-backup") ||

endswith(filename, ".dpkg-remove") ||

endswith(filename, ".swp");

}

bool hidden_file(const char *filename) {

assert(filename);

if (endswith(filename, "~"))

return true;

return hidden_file_allow_backup(filename);

}

bool fstype_is_network(const char *fstype) {

static const char table[] =

"afs\0"

"cifs\0"

"smbfs\0"

"sshfs\0"

"ncpfs\0"

"ncp\0"

"nfs\0"

"nfs4\0"

"gfs\0"

"gfs2\0"

"glusterfs\0";

const char *x;

x = startswith(fstype, "fuse.");

if (x)

fstype = x;

return nulstr_contains(table, fstype);

}

int flush_fd(int fd) {

struct pollfd pollfd = {

.fd = fd,

.events = POLLIN,

};

for (;;) {

char buf[LINE_MAX];

ssize_t l;

int r;

r = poll(&pollfd, 1, 0);

if (r < 0) {

if (errno == EINTR)

continue;

return -errno;

} else if (r == 0)

return 0;

l = read(fd, buf, sizeof(buf));

if (l < 0) {

if (errno == EINTR)

continue;

if (errno == EAGAIN)

return 0;

return -errno;

} else if (l == 0)

return 0;

}

}

ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {

uint8_t *p = buf;

ssize_t n = 0;

assert(fd >= 0);

assert(buf);

/* If called with nbytes == 0, let's call read() at least

if (nbytes > (size_t) SSIZE_MAX)

return -EINVAL;

do {

ssize_t k;

k = read(fd, p, nbytes);

if (k < 0) {

if (errno == EINTR)

continue;

if (errno == EAGAIN && do_poll) {

/* We knowingly ignore any return value here,

(void) fd_wait_for_event(fd, POLLIN, USEC_INFINITY);

continue;

}

return n > 0 ? n : -errno;

}

if (k == 0)

return n;

assert((size_t) k <= nbytes);

p += k;

nbytes -= k;

n += k;

} while (nbytes > 0);

return n;

}

int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll) {

ssize_t n;

n = loop_read(fd, buf, nbytes, do_poll);

if (n < 0)

return (int) n;

if ((size_t) n != nbytes)

return -EIO;

return 0;

}

int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {

const uint8_t *p = buf;

assert(fd >= 0);

assert(buf);

if (nbytes > (size_t) SSIZE_MAX)

return -EINVAL;

do {

ssize_t k;

k = write(fd, p, nbytes);

if (k < 0) {

if (errno == EINTR)

continue;

if (errno == EAGAIN && do_poll) {

/* We knowingly ignore any return value here,

(void) fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);

continue;

}

return -errno;

}

if (_unlikely_(nbytes > 0 && k == 0)) /* Can't really happen */

return -EIO;

assert((size_t) k <= nbytes);

p += k;

nbytes -= k;

} while (nbytes > 0);

return 0;

}

int parse_size(const char *t, uint64_t base, uint64_t *size) {

/* Soo, sometimes we want to parse IEC binary suffixes, and

struct table {

const char *suffix;

unsigned long long factor;

};

static const struct table iec[] = {

{ "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },

{ "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },

{ "T", 1024ULL*1024ULL*1024ULL*1024ULL },

{ "G", 1024ULL*1024ULL*1024ULL },

{ "M", 1024ULL*1024ULL },

{ "K", 1024ULL },

{ "B", 1ULL },

{ "", 1ULL },

};

static const struct table si[] = {

{ "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },

{ "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },

{ "T", 1000ULL*1000ULL*1000ULL*1000ULL },

{ "G", 1000ULL*1000ULL*1000ULL },

{ "M", 1000ULL*1000ULL },

{ "K", 1000ULL },

{ "B", 1ULL },

{ "", 1ULL },

};

const struct table *table;

const char *p;

unsigned long long r = 0;

unsigned n_entries, start_pos = 0;

assert(t);

assert(base == 1000 || base == 1024);

assert(size);

if (base == 1000) {

table = si;

n_entries = ELEMENTSOF(si);

} else {

table = iec;

n_entries = ELEMENTSOF(iec);

}

p = t;

do {

unsigned long long l, tmp;

double frac = 0;

char *e;

unsigned i;

p += strspn(p, WHITESPACE);

if (*p == '-')

return -ERANGE;

errno = 0;

l = strtoull(p, &e, 10);

if (errno > 0)

return -errno;

if (e == p)

return -EINVAL;

if (*e == '.') {

e++;

/* strtoull() itself would accept space/+/- */

if (*e >= '0' && *e <= '9') {

unsigned long long l2;

char *e2;

l2 = strtoull(e, &e2, 10);

if (errno > 0)

return -errno;

/* Ignore failure. E.g. 10.M is valid */

frac = l2;

for (; e < e2; e++)

frac /= 10;

}

}

e += strspn(e, WHITESPACE);

for (i = start_pos; i < n_entries; i++)

if (startswith(e, table[i].suffix))

break;

if (i >= n_entries)

return -EINVAL;

if (l + (frac > 0) > ULLONG_MAX / table[i].factor)

return -ERANGE;

tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);

if (tmp > ULLONG_MAX - r)

return -ERANGE;

r += tmp;

if ((unsigned long long) (uint64_t) r != r)

return -ERANGE;

p = e + strlen(table[i].suffix);

start_pos = i + 1;

} while (*p);

*size = r;

return 0;

}

bool is_device_path(const char *path) {

/* Returns true on paths that refer to a device, either in

return

path_startswith(path, "/dev/") ||

path_startswith(path, "/sys/");

}

int dir_is_empty(const char *path) {

_cleanup_closedir_ DIR *d;

struct dirent *de;

d = opendir(path);

if (!d)

return -errno;

FOREACH_DIRENT(de, d, return -errno)

return 0;

return 1;

}

char* dirname_malloc(const char *path) {

char *d, *dir, *dir2;

d = strdup(path);

if (!d)

return NULL;

dir = dirname(d);

assert(dir);

if (dir != d) {

dir2 = strdup(dir);

free(d);

return dir2;

}

return dir;

}

void rename_process(const char name[8]) {

assert(name);

/* This is a like a poor man's setproctitle(). It changes the

prctl(PR_SET_NAME, name);

if (program_invocation_name)

strncpy(program_invocation_name, name, strlen(program_invocation_name));

if (saved_argc > 0) {

int i;

if (saved_argv[0])

strncpy(saved_argv[0], name, strlen(saved_argv[0]));

for (i = 1; i < saved_argc; i++) {

if (!saved_argv[i])

break;

memzero(saved_argv[i], strlen(saved_argv[i]));

}

}

}

char *lookup_uid(uid_t uid) {

long bufsize;

char *name;

_cleanup_free_ char *buf = NULL;

struct passwd pwbuf, *pw = NULL;

/* Shortcut things to avoid NSS lookups */

if (uid == 0)

return strdup("root");

bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);

if (bufsize <= 0)

bufsize = 4096;

buf = malloc(bufsize);

if (!buf)

return NULL;

if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)

return strdup(pw->pw_name);

if (asprintf(&name, UID_FMT, uid) < 0)

return NULL;

return name;

}

char* getlogname_malloc(void) {

uid_t uid;

struct stat st;

if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)

uid = st.st_uid;

else

uid = getuid();

return lookup_uid(uid);

}

char *getusername_malloc(void) {

const char *e;

e = getenv("USER");

if (e)

return strdup(e);

return lookup_uid(getuid());

}

bool is_fs_type(const struct statfs *s, statfs_f_type_t magic_value) {

assert(s);

assert_cc(sizeof(statfs_f_type_t) >= sizeof(s->f_type));

return F_TYPE_EQUAL(s->f_type, magic_value);

}

int fd_check_fstype(int fd, statfs_f_type_t magic_value) {

struct statfs s;

if (fstatfs(fd, &s) < 0)

return -errno;

return is_fs_type(&s, magic_value);

}

int path_check_fstype(const char *path, statfs_f_type_t magic_value) {

_cleanup_close_ int fd = -1;

fd = open(path, O_RDONLY);

if (fd < 0)

return -errno;

return fd_check_fstype(fd, magic_value);

}

bool is_temporary_fs(const struct statfs *s) {

return is_fs_type(s, TMPFS_MAGIC) ||

is_fs_type(s, RAMFS_MAGIC);

}

int fd_is_temporary_fs(int fd) {

struct statfs s;

if (fstatfs(fd, &s) < 0)

return -errno;

return is_temporary_fs(&s);

}

int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {

assert(path);

/* Under the assumption that we are running privileged we

if (mode != MODE_INVALID)

if (chmod(path, mode) < 0)

return -errno;

if (uid != UID_INVALID || gid != GID_INVALID)

if (chown(path, uid, gid) < 0)

return -errno;

return 0;

}

int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {

assert(fd >= 0);

/* Under the assumption that we are running privileged we

if (mode != MODE_INVALID)

if (fchmod(fd, mode) < 0)

return -errno;

if (uid != UID_INVALID || gid != GID_INVALID)

if (fchown(fd, uid, gid) < 0)

return -errno;

return 0;

}

int files_same(const char *filea, const char *fileb) {

struct stat a, b;

if (stat(filea, &a) < 0)

return -errno;

if (stat(fileb, &b) < 0)

return -errno;

return a.st_dev == b.st_dev &&

a.st_ino == b.st_ino;

}

int running_in_chroot(void) {

int ret;

ret = files_same("/proc/1/root", "/");

if (ret < 0)

return ret;

return ret == 0;

}

int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {

_cleanup_close_ int fd;

int r;

assert(path);

if (parents)

mkdir_parents(path, 0755);

fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);

if (fd < 0)

return -errno;

if (mode > 0) {

r = fchmod(fd, mode);

if (r < 0)

return -errno;

}

if (uid != UID_INVALID || gid != GID_INVALID) {

r = fchown(fd, uid, gid);

if (r < 0)

return -errno;

}

if (stamp != USEC_INFINITY) {

struct timespec ts[2];

timespec_store(&ts[0], stamp);

ts[1] = ts[0];

r = futimens(fd, ts);

} else

r = futimens(fd, NULL);

if (r < 0)

return -errno;

return 0;

}

int touch(const char *path) {

return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);

}

static char *unquote(const char *s, const char* quotes) {

size_t l;

assert(s);

/* This is rather stupid, simply removes the heading and

l = strlen(s);

if (l < 2)

return strdup(s);

if (strchr(quotes, s[0]) && s[l-1] == s[0])

return strndup(s+1, l-2);

return strdup(s);

}

noreturn void freeze(void) {

/* Make sure nobody waits for us on a socket anymore */

close_all_fds(NULL, 0);

sync();

for (;;)

pause();

}

bool null_or_empty(struct stat *st) {

assert(st);

if (S_ISREG(st->st_mode) && st->st_size <= 0)

return true;

if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))

return true;

return false;

}

int null_or_empty_path(const char *fn) {

struct stat st;

assert(fn);

if (stat(fn, &st) < 0)

return -errno;

return null_or_empty(&st);

}

int null_or_empty_fd(int fd) {

struct stat st;

assert(fd >= 0);

if (fstat(fd, &st) < 0)

return -errno;

return null_or_empty(&st);

}

DIR *xopendirat(int fd, const char *name, int flags) {

int nfd;

DIR *d;

assert(!(flags & O_CREAT));

nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);

if (nfd < 0)

return NULL;

d = fdopendir(nfd);

if (!d) {

safe_close(nfd);

return NULL;

}

return d;

}

static char *tag_to_udev_node(const char *tagvalue, const char *by) {

_cleanup_free_ char *t = NULL, *u = NULL;

size_t enc_len;

u = unquote(tagvalue, QUOTES);

if (!u)

return NULL;

enc_len = strlen(u) * 4 + 1;

t = new(char, enc_len);

if (!t)

return NULL;

if (encode_devnode_name(u, t, enc_len) < 0)

return NULL;

return strjoin("/dev/disk/by-", by, "/", t, NULL);

}

char *fstab_node_to_udev_node(const char *p) {

assert(p);

if (startswith(p, "LABEL="))

return tag_to_udev_node(p+6, "label");

if (startswith(p, "UUID="))

return tag_to_udev_node(p+5, "uuid");

if (startswith(p, "PARTUUID="))

return tag_to_udev_node(p+9, "partuuid");

if (startswith(p, "PARTLABEL="))

return tag_to_udev_node(p+10, "partlabel");

return strdup(p);

}

bool dirent_is_file(const struct dirent *de) {

assert(de);

if (hidden_file(de->d_name))

return false;

if (de->d_type != DT_REG &&

de->d_type != DT_LNK &&

de->d_type != DT_UNKNOWN)

return false;

return true;

}

bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {

assert(de);

if (de->d_type != DT_REG &&

de->d_type != DT_LNK &&

de->d_type != DT_UNKNOWN)

return false;

if (hidden_file_allow_backup(de->d_name))

return false;

return endswith(de->d_name, suffix);

}

static int do_execute(char **directories, usec_t timeout, char *argv[]) {

_cleanup_hashmap_free_free_ Hashmap *pids = NULL;

_cleanup_set_free_free_ Set *seen = NULL;

char **directory;

/* We fork this all off from a child process so that we can

(void) reset_all_signal_handlers();

(void) reset_signal_mask();

assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);

pids = hashmap_new(NULL);

if (!pids)

return log_oom();

seen = set_new(&string_hash_ops);

if (!seen)

return log_oom();

STRV_FOREACH(directory, directories) {

_cleanup_closedir_ DIR *d;

struct dirent *de;

d = opendir(*directory);

if (!d) {

if (errno == ENOENT)

continue;

return log_error_errno(errno, "Failed to open directory %s: %m", *directory);

}

FOREACH_DIRENT(de, d, break) {

_cleanup_free_ char *path = NULL;

pid_t pid;

int r;

if (!dirent_is_file(de))

continue;

if (set_contains(seen, de->d_name)) {

log_debug("%1$s/%2$s skipped (%2$s was already seen).", *directory, de->d_name);

continue;

}

r = set_put_strdup(seen, de->d_name);

if (r < 0)

return log_oom();

path = strjoin(*directory, "/", de->d_name, NULL);

if (!path)

return log_oom();

if (null_or_empty_path(path)) {

log_debug("%s is empty (a mask).", path);

continue;

}

pid = fork();

if (pid < 0) {

log_error_errno(errno, "Failed to fork: %m");

continue;

} else if (pid == 0) {

char *_argv[2];

assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);

if (!argv) {

_argv[0] = path;

_argv[1] = NULL;

argv = _argv;

} else

argv[0] = path;

execv(path, argv);

return log_error_errno(errno, "Failed to execute %s: %m", path);

}

log_debug("Spawned %s as " PID_FMT ".", path, pid);

r = hashmap_put(pids, UINT_TO_PTR(pid), path);

if (r < 0)

return log_oom();

path = NULL;

}

}

/* Abort execution of this process after the timout. We simply

if (timeout != USEC_INFINITY)

alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);

while (!hashmap_isempty(pids)) {

_cleanup_free_ char *path = NULL;

pid_t pid;

pid = PTR_TO_UINT(hashmap_first_key(pids));

assert(pid > 0);

path = hashmap_remove(pids, UINT_TO_PTR(pid));

assert(path);

wait_for_terminate_and_warn(path, pid, true);

}

return 0;

}

void execute_directories(const char* const* directories, usec_t timeout, char *argv[]) {

pid_t executor_pid;

int r;

char *name;

char **dirs = (char**) directories;

assert(!strv_isempty(dirs));

name = basename(dirs[0]);

assert(!isempty(name));

/* Executes all binaries in the directories in parallel and waits

executor_pid = fork();

if (executor_pid < 0) {

log_error_errno(errno, "Failed to fork: %m");

return;

} else if (executor_pid == 0) {

r = do_execute(dirs, timeout, argv);

_exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);

}

wait_for_terminate_and_warn(name, executor_pid, true);

}

bool plymouth_running(void) {

return access("/run/plymouth/pid", F_OK) >= 0;

}

int pipe_eof(int fd) {

struct pollfd pollfd = {

.fd = fd,

.events = POLLIN|POLLHUP,

};

int r;

r = poll(&pollfd, 1, 0);

if (r < 0)

return -errno;

if (r == 0)

return 0;

return pollfd.revents & POLLHUP;

}

int fd_wait_for_event(int fd, int event, usec_t t) {

struct pollfd pollfd = {

.fd = fd,

.events = event,

};

struct timespec ts;

int r;

r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);

if (r < 0)

return -errno;

if (r == 0)

return 0;

return pollfd.revents;

}

int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {

FILE *f;

char *t;

int r, fd;

assert(path);

assert(_f);

assert(_temp_path);

r = tempfn_xxxxxx(path, NULL, &t);

if (r < 0)

return r;

fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);

if (fd < 0) {

free(t);

return -errno;

}

f = fdopen(fd, "we");

if (!f) {

unlink_noerrno(t);

free(t);

safe_close(fd);

return -errno;

}

*_f = f;

*_temp_path = t;

return 0;

}

int symlink_atomic(const char *from, const char *to) {

_cleanup_free_ char *t = NULL;

int r;

assert(from);

assert(to);

r = tempfn_random(to, NULL, &t);

if (r < 0)

return r;

if (symlink(from, t) < 0)

return -errno;

if (rename(t, to) < 0) {

unlink_noerrno(t);

return -errno;

}

return 0;

}

int symlink_idempotent(const char *from, const char *to) {

_cleanup_free_ char *p = NULL;

int r;

assert(from);

assert(to);

if (symlink(from, to) < 0) {

if (errno != EEXIST)

return -errno;

r = readlink_malloc(to, &p);

if (r < 0)

return r;

if (!streq(p, from))

return -EINVAL;

}

return 0;

}

int mknod_atomic(const char *path, mode_t mode, dev_t dev) {

_cleanup_free_ char *t = NULL;

int r;

assert(path);

r = tempfn_random(path, NULL, &t);

if (r < 0)

return r;

if (mknod(t, mode, dev) < 0)

return -errno;

if (rename(t, path) < 0) {

unlink_noerrno(t);

return -errno;

}

return 0;

}

int mkfifo_atomic(const char *path, mode_t mode) {

_cleanup_free_ char *t = NULL;

int r;

assert(path);

r = tempfn_random(path, NULL, &t);

if (r < 0)

return r;

if (mkfifo(t, mode) < 0)

return -errno;

if (rename(t, path) < 0) {

unlink_noerrno(t);

return -errno;

}

return 0;

}

bool display_is_local(const char *display) {

assert(display);

return

display[0] == ':' &&

display[1] >= '0' &&

display[1] <= '9';

}

int socket_from_display(const char *display, char **path) {

size_t k;

char *f, *c;

assert(display);

assert(path);

if (!display_is_local(display))

return -EINVAL;

k = strspn(display+1, "0123456789");

f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);

if (!f)

return -ENOMEM;

c = stpcpy(f, "/tmp/.X11-unix/X");

memcpy(c, display+1, k);

c[k] = 0;

*path = f;

return 0;

}

int get_user_creds(

const char **username,

uid_t *uid, gid_t *gid,

const char **home,

const char **shell) {

struct passwd *p;

uid_t u;

assert(username);

assert(*username);

/* We enforce some special rules for uid=0: in order to avoid

if (streq(*username, "root") || streq(*username, "0")) {

*username = "root";

if (uid)

*uid = 0;

if (gid)

*gid = 0;

if (home)

*home = "/root";

if (shell)

*shell = "/bin/sh";

return 0;

}

if (parse_uid(*username, &u) >= 0) {

errno = 0;

p = getpwuid(u);

/* If there are multiple users with the same id, make

if (p)

*username = p->pw_name;

} else {

errno = 0;

p = getpwnam(*username);

}

if (!p)

return errno > 0 ? -errno : -ESRCH;

if (uid)

*uid = p->pw_uid;

if (gid)

*gid = p->pw_gid;

if (home)

*home = p->pw_dir;

if (shell)

*shell = p->pw_shell;

return 0;

}

char* uid_to_name(uid_t uid) {

struct passwd *p;

char *r;

if (uid == 0)

return strdup("root");

p = getpwuid(uid);

if (p)

return strdup(p->pw_name);

if (asprintf(&r, UID_FMT, uid) < 0)

return NULL;

return r;

}

char* gid_to_name(gid_t gid) {

struct group *p;

char *r;

if (gid == 0)

return strdup("root");

p = getgrgid(gid);

if (p)

return strdup(p->gr_name);

if (asprintf(&r, GID_FMT, gid) < 0)

return NULL;

return r;

}

int get_group_creds(const char **groupname, gid_t *gid) {

struct group *g;

gid_t id;

assert(groupname);

/* We enforce some special rules for gid=0: in order to avoid

if (streq(*groupname, "root") || streq(*groupname, "0")) {

*groupname = "root";

if (gid)

*gid = 0;

return 0;

}

if (parse_gid(*groupname, &id) >= 0) {

errno = 0;

g = getgrgid(id);

if (g)

*groupname = g->gr_name;

} else {

errno = 0;

g = getgrnam(*groupname);

}

if (!g)

return errno > 0 ? -errno : -ESRCH;

if (gid)

*gid = g->gr_gid;

return 0;

}

int in_gid(gid_t gid) {

gid_t *gids;

int ngroups_max, r, i;

if (getgid() == gid)

return 1;

if (getegid() == gid)

return 1;

ngroups_max = sysconf(_SC_NGROUPS_MAX);

assert(ngroups_max > 0);

gids = alloca(sizeof(gid_t) * ngroups_max);

r = getgroups(ngroups_max, gids);

if (r < 0)

return -errno;

for (i = 0; i < r; i++)

if (gids[i] == gid)

return 1;

return 0;

}

int in_group(const char *name) {

int r;

gid_t gid;

r = get_group_creds(&name, &gid);

if (r < 0)

return r;

return in_gid(gid);

}

int glob_exists(const char *path) {

_cleanup_globfree_ glob_t g = {};

int k;

assert(path);

errno = 0;

k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);

if (k == GLOB_NOMATCH)

return 0;

else if (k == GLOB_NOSPACE)

return -ENOMEM;

else if (k == 0)

return !strv_isempty(g.gl_pathv);

else

return errno ? -errno : -EIO;

}

int glob_extend(char ***strv, const char *path) {

_cleanup_globfree_ glob_t g = {};

int k;

char **p;

errno = 0;

k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);

if (k == GLOB_NOMATCH)

return -ENOENT;

else if (k == GLOB_NOSPACE)

return -ENOMEM;

else if (k != 0 || strv_isempty(g.gl_pathv))

return errno ? -errno : -EIO;

STRV_FOREACH(p, g.gl_pathv) {

k = strv_extend(strv, *p);

if (k < 0)

break;

}

return k;

}

int dirent_ensure_type(DIR *d, struct dirent *de) {

struct stat st;

assert(d);

assert(de);

if (de->d_type != DT_UNKNOWN)

return 0;

if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)

return -errno;

de->d_type =

S_ISREG(st.st_mode) ? DT_REG :

S_ISDIR(st.st_mode) ? DT_DIR :

S_ISLNK(st.st_mode) ? DT_LNK :

S_ISFIFO(st.st_mode) ? DT_FIFO :

S_ISSOCK(st.st_mode) ? DT_SOCK :

S_ISCHR(st.st_mode) ? DT_CHR :

S_ISBLK(st.st_mode) ? DT_BLK :

DT_UNKNOWN;

return 0;

}

int get_files_in_directory(const char *path, char ***list) {

_cleanup_closedir_ DIR *d = NULL;

size_t bufsize = 0, n = 0;

_cleanup_strv_free_ char **l = NULL;

assert(path);

/* Returns all files in a directory in *list, and the number

d = opendir(path);

if (!d)

return -errno;

for (;;) {

struct dirent *de;

errno = 0;

de = readdir(d);

if (!de && errno != 0)

return -errno;

if (!de)

break;

dirent_ensure_type(d, de);

if (!dirent_is_file(de))

continue;

if (list) {

/* one extra slot is needed for the terminating NULL */

if (!GREEDY_REALLOC(l, bufsize, n + 2))

return -ENOMEM;

l[n] = strdup(de->d_name);

if (!l[n])

return -ENOMEM;

l[++n] = NULL;

} else

n++;

}

if (list) {

*list = l;

l = NULL; /* avoid freeing */

}

return n;

}

bool is_main_thread(void) {

static thread_local int cached = 0;

if (_unlikely_(cached == 0))

cached = getpid() == gettid() ? 1 : -1;

return cached > 0;

}

int block_get_whole_disk(dev_t d, dev_t *ret) {

char *p, *s;

int r;

unsigned n, m;

assert(ret);

/* If it has a queue this is good enough for us */

if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)

return -ENOMEM;

r = access(p, F_OK);

free(p);

if (r >= 0) {

*ret = d;

return 0;

}

/* If it is a partition find the originating device */

if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)

return -ENOMEM;

r = access(p, F_OK);

free(p);

if (r < 0)

return -ENOENT;

/* Get parent dev_t */

if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)

return -ENOMEM;

r = read_one_line_file(p, &s);

free(p);

if (r < 0)

return r;

r = sscanf(s, "%u:%u", &m, &n);

free(s);

if (r != 2)

return -EINVAL;

/* Only return this if it is really good enough for us. */

if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)

return -ENOMEM;

r = access(p, F_OK);

free(p);

if (r >= 0) {

*ret = makedev(m, n);

return 0;

}

return -ENOENT;

}

static const char *const ioprio_class_table[] = {

[IOPRIO_CLASS_NONE] = "none",

[IOPRIO_CLASS_RT] = "realtime",

[IOPRIO_CLASS_BE] = "best-effort",

[IOPRIO_CLASS_IDLE] = "idle"

};

DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);

static const char *const sigchld_code_table[] = {

[CLD_EXITED] = "exited",

[CLD_KILLED] = "killed",

[CLD_DUMPED] = "dumped",

[CLD_TRAPPED] = "trapped",

[CLD_STOPPED] = "stopped",

[CLD_CONTINUED] = "continued",

};

DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);

static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {

[LOG_FAC(LOG_KERN)] = "kern",

[LOG_FAC(LOG_USER)] = "user",

[LOG_FAC(LOG_MAIL)] = "mail",

[LOG_FAC(LOG_DAEMON)] = "daemon",

[LOG_FAC(LOG_AUTH)] = "auth",

[LOG_FAC(LOG_SYSLOG)] = "syslog",

[LOG_FAC(LOG_LPR)] = "lpr",

[LOG_FAC(LOG_NEWS)] = "news",

[LOG_FAC(LOG_UUCP)] = "uucp",

[LOG_FAC(LOG_CRON)] = "cron",

[LOG_FAC(LOG_AUTHPRIV)] = "authpriv",

[LOG_FAC(LOG_FTP)] = "ftp",

[LOG_FAC(LOG_LOCAL0)] = "local0",

[LOG_FAC(LOG_LOCAL1)] = "local1",

[LOG_FAC(LOG_LOCAL2)] = "local2",

[LOG_FAC(LOG_LOCAL3)] = "local3",

[LOG_FAC(LOG_LOCAL4)] = "local4",

[LOG_FAC(LOG_LOCAL5)] = "local5",

[LOG_FAC(LOG_LOCAL6)] = "local6",

[LOG_FAC(LOG_LOCAL7)] = "local7"

};

DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));

bool log_facility_unshifted_is_valid(int facility) {

return facility >= 0 && facility <= LOG_FAC(~0);

}

static const char *const log_level_table[] = {

[LOG_EMERG] = "emerg",

[LOG_ALERT] = "alert",

[LOG_CRIT] = "crit",

[LOG_ERR] = "err",

[LOG_WARNING] = "warning",

[LOG_NOTICE] = "notice",

[LOG_INFO] = "info",

[LOG_DEBUG] = "debug"

};

DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);

bool log_level_is_valid(int level) {

return level >= 0 && level <= LOG_DEBUG;

}

static const char* const sched_policy_table[] = {

[SCHED_OTHER] = "other",

[SCHED_BATCH] = "batch",

[SCHED_IDLE] = "idle",

[SCHED_FIFO] = "fifo",

[SCHED_RR] = "rr"

};

DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);

static const char* const rlimit_table[_RLIMIT_MAX] = {

[RLIMIT_CPU] = "LimitCPU",

[RLIMIT_FSIZE] = "LimitFSIZE",

[RLIMIT_DATA] = "LimitDATA",

[RLIMIT_STACK] = "LimitSTACK",

[RLIMIT_CORE] = "LimitCORE",

[RLIMIT_RSS] = "LimitRSS",

[RLIMIT_NOFILE] = "LimitNOFILE",

[RLIMIT_AS] = "LimitAS",

[RLIMIT_NPROC] = "LimitNPROC",

[RLIMIT_MEMLOCK] = "LimitMEMLOCK",

[RLIMIT_LOCKS] = "LimitLOCKS",

[RLIMIT_SIGPENDING] = "LimitSIGPENDING",

[RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",

[RLIMIT_NICE] = "LimitNICE",

[RLIMIT_RTPRIO] = "LimitRTPRIO",

[RLIMIT_RTTIME] = "LimitRTTIME"

};

DEFINE_STRING_TABLE_LOOKUP(rlimit, int);

static const char* const ip_tos_table[] = {

[IPTOS_LOWDELAY] = "low-delay",

[IPTOS_THROUGHPUT] = "throughput",

[IPTOS_RELIABILITY] = "reliability",

[IPTOS_LOWCOST] = "low-cost",

};

DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);

bool kexec_loaded(void) {

bool loaded = false;

char *s;

if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {

if (s[0] == '1')

loaded = true;

free(s);

}

return loaded;

}

int prot_from_flags(int flags) {

switch (flags & O_ACCMODE) {

case O_RDONLY:

return PROT_READ;

case O_WRONLY:

return PROT_WRITE;

case O_RDWR:

return PROT_READ|PROT_WRITE;

default:

return -EINVAL;

}

}

char *format_bytes(char *buf, size_t l, uint64_t t) {

unsigned i;

static const struct {

const char *suffix;

uint64_t factor;

} table[] = {

{ "E", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },

{ "P", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },

{ "T", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },

{ "G", UINT64_C(1024)*UINT64_C(1024)*UINT64_C(1024) },

{ "M", UINT64_C(1024)*UINT64_C(1024) },

{ "K", UINT64_C(1024) },

};

if (t == (uint64_t) -1)

return NULL;

for (i = 0; i < ELEMENTSOF(table); i++) {

if (t >= table[i].factor) {

snprintf(buf, l,

"%" PRIu64 ".%" PRIu64 "%s",

t / table[i].factor,

((t*UINT64_C(10)) / table[i].factor) % UINT64_C(10),

table[i].suffix);

goto finish;

}

}

snprintf(buf, l, "%" PRIu64 "B", t);

finish:

buf[l-1] = 0;

return buf;

}

void* memdup(const void *p, size_t l) {

void *r;

assert(p);

r = malloc(l);

if (!r)

return NULL;

memcpy(r, p, l);

return r;

}

int fd_inc_sndbuf(int fd, size_t n) {

int r, value;

socklen_t l = sizeof(value);

r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);

if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)

return 0;

/* If we have the privileges we will ignore the kernel limit. */

value = (int) n;

if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)

if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)

return -errno;

return 1;

}

int fd_inc_rcvbuf(int fd, size_t n) {

int r, value;

socklen_t l = sizeof(value);

r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);

if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)

return 0;

/* If we have the privileges we will ignore the kernel limit. */

value = (int) n;

if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)

if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)

return -errno;

return 1;

}

int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {

bool stdout_is_tty, stderr_is_tty;

pid_t parent_pid, agent_pid;

sigset_t ss, saved_ss;

unsigned n, i;

va_list ap;

char **l;

assert(pid);

assert(path);

/* Spawns a temporary TTY agent, making sure it goes away when

parent_pid = getpid();

/* First we temporarily block all signals, so that the new

assert_se(sigfillset(&ss) >= 0);

assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);

agent_pid = fork();

if (agent_pid < 0) {

assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);

return -errno;

}

if (agent_pid != 0) {

assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);

*pid = agent_pid;

return 0;

}

/* In the child:

if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)

_exit(EXIT_FAILURE);

/* Make sure we actually can kill the agent, if we need to, in

(void) reset_all_signal_handlers();

(void) reset_signal_mask();

/* Check whether our parent died before we were able

if (getppid() != parent_pid)

_exit(EXIT_SUCCESS);

/* Don't leak fds to the agent */

close_all_fds(except, n_except);

stdout_is_tty = isatty(STDOUT_FILENO);

stderr_is_tty = isatty(STDERR_FILENO);

if (!stdout_is_tty || !stderr_is_tty) {

int fd;

/* Detach from stdout/stderr. and reopen

fd = open("/dev/tty", O_WRONLY);

if (fd < 0) {

log_error_errno(errno, "Failed to open /dev/tty: %m");

_exit(EXIT_FAILURE);

}

if (!stdout_is_tty)

dup2(fd, STDOUT_FILENO);

if (!stderr_is_tty)

dup2(fd, STDERR_FILENO);

if (fd > 2)

close(fd);

}

/* Count arguments */

va_start(ap, path);

for (n = 0; va_arg(ap, char*); n++)

;

va_end(ap);

/* Allocate strv */

l = alloca(sizeof(char *) * (n + 1));

/* Fill in arguments */

va_start(ap, path);

for (i = 0; i <= n; i++)

l[i] = va_arg(ap, char*);

va_end(ap);

execv(path, l);

_exit(EXIT_FAILURE);

}

int setrlimit_closest(int resource, const struct rlimit *rlim) {

struct rlimit highest, fixed;

assert(rlim);