#include <assert.h>

#include <string.h>

#include <unistd.h>

#include <errno.h>

#include <stdlib.h>

#include <signal.h>

#include <stdio.h>

#include <syslog.h>

#include <sched.h>

#include <sys/resource.h>

#include <linux/sched.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <dirent.h>

#include <sys/ioctl.h>

#include <linux/vt.h>

#include <linux/tiocl.h>

#include <termios.h>

#include <stdarg.h>

#include <sys/inotify.h>

#include <sys/poll.h>

#include <libgen.h>

#include <ctype.h>

#include <sys/prctl.h>

#include <sys/utsname.h>

#include <pwd.h>

#include <netinet/ip.h>

#include <linux/kd.h>

#include <dlfcn.h>

#include <sys/wait.h>

#include <sys/time.h>

#include <glob.h>

#include <grp.h>

#include <sys/mman.h>

#include <sys/vfs.h>

#include <linux/magic.h>

#include <limits.h>

#include <langinfo.h>

#include <locale.h>

#include "macro.h"

#include "util.h"

#include "ioprio.h"

#include "missing.h"

#include "log.h"

#include "strv.h"

#include "label.h"

#include "path-util.h"

#include "exit-status.h"

#include "hashmap.h"

int saved_argc = 0;

char **saved_argv = NULL;

static volatile unsigned cached_columns = 0;

static volatile unsigned cached_lines = 0;

bool is_efiboot(void) {

return access("/sys/firmware/efi", F_OK) >= 0;

}

size_t page_size(void) {

static __thread 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;

}

bool streq_ptr(const char *a, const char *b) {

/* Like streq(), but tries to make sense of NULL pointers */

if (a && b)

return streq(a, b);

if (!a && !b)

return true;

return false;

}

char* endswith(const char *s, const char *postfix) {

size_t sl, pl;

assert(s);

assert(postfix);

sl = strlen(s);

pl = strlen(postfix);

if (pl == 0)

return (char*) s + sl;

if (sl < pl)

return NULL;

if (memcmp(s + sl - pl, postfix, pl) != 0)

return NULL;

return (char*) s + sl - pl;

}

char* startswith(const char *s, const char *prefix) {

const char *a, *b;

assert(s);

assert(prefix);

a = s, b = prefix;

for (;;) {

if (*b == 0)

return (char*) a;

if (*a != *b)

return NULL;

a++, b++;

}

}

char* startswith_no_case(const char *s, const char *prefix) {

const char *a, *b;

assert(s);

assert(prefix);

a = s, b = prefix;

for (;;) {

if (*b == 0)

return (char*) a;

if (tolower(*a) != tolower(*b))

return NULL;

a++, b++;

}

}

bool first_word(const char *s, const char *word) {

size_t sl, wl;

assert(s);

assert(word);

sl = strlen(s);

wl = strlen(word);

if (sl < wl)

return false;

if (wl == 0)

return true;

if (memcmp(s, word, wl) != 0)

return false;

return s[wl] == 0 ||

strchr(WHITESPACE, s[wl]);

}

int close_nointr(int fd) {

assert(fd >= 0);

for (;;) {

int r;

r = close(fd);

if (r >= 0)

return r;

if (errno != EINTR)

return -errno;

}

}

void close_nointr_nofail(int fd) {

int saved_errno = errno;

/* like close_nointr() but cannot fail, and guarantees errno

assert_se(close_nointr(fd) == 0);

errno = saved_errno;

}

void close_many(const int fds[], unsigned n_fd) {

unsigned i;

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

close_nointr_nofail(fds[i]);

}

int parse_boolean(const char *v) {

assert(v);

if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))

return 1;

else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(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;

}

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

unsigned long ul = 0;

uid_t uid;

int r;

assert(s);

assert(ret_uid);

r = safe_atolu(s, &ul);

if (r < 0)

return r;

uid = (uid_t) ul;

if ((unsigned long) uid != ul)

return -ERANGE;

*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 ? -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 ? -errno : -EINVAL;

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

return -ERANGE;

*ret_i = (int) 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;

}

char *split(const char *c, size_t *l, const char *separator, char **state) {

char *current;

current = *state ? *state : (char*) c;

if (!*current || *c == 0)

return NULL;

current += strspn(current, separator);

*l = strcspn(current, separator);

*state = current+*l;

return (char*) current;

}

char *split_quoted(const char *c, size_t *l, char **state) {

char *current, *e;

bool escaped = false;

current = *state ? *state : (char*) c;

if (!*current || *c == 0)

return NULL;

current += strspn(current, WHITESPACE);

if (*current == '\'') {

current ++;

for (e = current; *e; e++) {

if (escaped)

escaped = false;

else if (*e == '\\')

escaped = true;

else if (*e == '\'')

break;

}

*l = e-current;

*state = *e == 0 ? e : e+1;

} else if (*current == '\"') {

current ++;

for (e = current; *e; e++) {

if (escaped)

escaped = false;

else if (*e == '\\')

escaped = true;

else if (*e == '\"')

break;

}

*l = e-current;

*state = *e == 0 ? e : e+1;

} else {

for (e = current; *e; e++) {

if (escaped)

escaped = false;

else if (*e == '\\')

escaped = true;

else if (strchr(WHITESPACE, *e))

break;

}

*l = e-current;

*state = e;

}

return (char*) current;

}

int get_parent_of_pid(pid_t pid, pid_t *_ppid) {

int r;

_cleanup_fclose_ FILE *f = NULL;

char fn[PATH_MAX], line[LINE_MAX], *p;

long unsigned ppid;

assert(pid > 0);

assert(_ppid);

assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));

char_array_0(fn);

f = fopen(fn, "re");

if (!f)

return -errno;

if (!fgets(line, sizeof(line), f)) {

r = feof(f) ? -EIO : -errno;

fclose(f);

return r;

}

/* Let's skip the pid and comm fields. The latter is enclosed

p = strrchr(line, ')');

if (!p)

return -EIO;

p++;

if (sscanf(p, " "

"%*c " /* state */

"%lu ", /* ppid */

&ppid) != 1)

return -EIO;

if ((long unsigned) (pid_t) ppid != ppid)

return -ERANGE;

*_ppid = (pid_t) ppid;

return 0;

}

int get_starttime_of_pid(pid_t pid, unsigned long long *st) {

_cleanup_fclose_ FILE *f = NULL;

char fn[PATH_MAX], line[LINE_MAX], *p;

assert(pid > 0);

assert(st);

assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));

char_array_0(fn);

f = fopen(fn, "re");

if (!f)

return -errno;

if (!fgets(line, sizeof(line), f)) {

if (ferror(f))

return -errno;

return -EIO;

}

/* Let's skip the pid and comm fields. The latter is enclosed

p = strrchr(line, ')');

if (!p)

return -EIO;

p++;

if (sscanf(p, " "

"%*c " /* state */

"%*d " /* ppid */

"%*d " /* pgrp */

"%*d " /* session */

"%*d " /* tty_nr */

"%*d " /* tpgid */

"%*u " /* flags */

"%*u " /* minflt */

"%*u " /* cminflt */

"%*u " /* majflt */

"%*u " /* cmajflt */

"%*u " /* utime */

"%*u " /* stime */

"%*d " /* cutime */

"%*d " /* cstime */

"%*d " /* priority */

"%*d " /* nice */

"%*d " /* num_threads */

"%*d " /* itrealvalue */

"%llu " /* starttime */,

st) != 1)

return -EIO;

return 0;

}

int write_one_line_file(const char *fn, const char *line) {

_cleanup_fclose_ FILE *f = NULL;

assert(fn);

assert(line);

f = fopen(fn, "we");

if (!f)

return -errno;

errno = 0;

if (fputs(line, f) < 0)

return errno ? -errno : -EIO;

if (!endswith(line, "\n"))

fputc('\n', f);

fflush(f);

if (ferror(f))

return errno ? -errno : -EIO;

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 write_one_line_file_atomic(const char *fn, const char *line) {

FILE *f;

int r;

char *p;

assert(fn);

assert(line);

r = fopen_temporary(fn, &f, &p);

if (r < 0)

return r;

fchmod_umask(fileno(f), 0644);

errno = 0;

if (fputs(line, f) < 0) {

r = -errno;

goto finish;

}

if (!endswith(line, "\n"))

fputc('\n', f);

fflush(f);

if (ferror(f)) {

if (errno != 0)

r = -errno;

else

r = -EIO;

} else {

if (rename(p, fn) < 0)

r = -errno;

else

r = 0;

}

finish:

if (r < 0)

unlink(p);

fclose(f);

free(p);

return r;

}

int read_one_line_file(const char *fn, char **line) {

_cleanup_fclose_ FILE *f = NULL;

char t[LINE_MAX], *c;

assert(fn);

assert(line);

f = fopen(fn, "re");

if (!f)

return -errno;

if (!fgets(t, sizeof(t), f)) {

if (ferror(f))

return errno ? -errno : -EIO;

t[0] = 0;

}

c = strdup(t);

if (!c)

return -ENOMEM;

truncate_nl(c);

*line = c;

return 0;

}

int read_full_file(const char *fn, char **contents, size_t *size) {

_cleanup_fclose_ FILE *f = NULL;

size_t n, l;

_cleanup_free_ char *buf = NULL;

struct stat st;

f = fopen(fn, "re");

if (!f)

return -errno;

if (fstat(fileno(f), &st) < 0)

return -errno;

/* Safety check */

if (st.st_size > 4*1024*1024)

return -E2BIG;

n = st.st_size > 0 ? st.st_size : LINE_MAX;

l = 0;

for (;;) {

char *t;

size_t k;

t = realloc(buf, n+1);

if (!t)

return -ENOMEM;

buf = t;

k = fread(buf + l, 1, n - l, f);

if (k <= 0) {

if (ferror(f))

return -errno;

break;

}

l += k;

n *= 2;

/* Safety check */

if (n > 4*1024*1024)

return -E2BIG;

}

buf[l] = 0;

*contents = buf;

buf = NULL;

if (size)

*size = l;

return 0;

}

int parse_env_file(

const char *fname,

const char *separator, ...) {

int r = 0;

char *contents = NULL, *p;

assert(fname);

assert(separator);

if ((r = read_full_file(fname, &contents, NULL)) < 0)

return r;

p = contents;

for (;;) {

const char *key = NULL;

p += strspn(p, separator);

p += strspn(p, WHITESPACE);

if (!*p)

break;

if (!strchr(COMMENTS, *p)) {

va_list ap;

char **value;

va_start(ap, separator);

while ((key = va_arg(ap, char *))) {

size_t n;

char *v;

value = va_arg(ap, char **);

n = strlen(key);

if (strncmp(p, key, n) != 0 ||

p[n] != '=')

continue;

p += n + 1;

n = strcspn(p, separator);

if (n >= 2 &&

strchr(QUOTES, p[0]) &&

p[n-1] == p[0])

v = strndup(p+1, n-2);

else

v = strndup(p, n);

if (!v) {

r = -ENOMEM;

va_end(ap);

goto fail;

}

if (v[0] == '\0') {

/* return empty value strings as NULL */

free(v);

v = NULL;

}

free(*value);

*value = v;

p += n;

r ++;

break;

}

va_end(ap);

}

if (!key)

p += strcspn(p, separator);

}

fail:

free(contents);

return r;

}

int load_env_file(

const char *fname,

char ***rl) {

FILE *f;

char **m = NULL;

int r;

assert(fname);

assert(rl);

if (!(f = fopen(fname, "re")))

return -errno;

while (!feof(f)) {

char l[LINE_MAX], *p, *u;

char **t;

if (!fgets(l, sizeof(l), f)) {

if (feof(f))

break;

r = -errno;

goto finish;

}

p = strstrip(l);

if (!*p)

continue;

if (strchr(COMMENTS, *p))

continue;

if (!(u = normalize_env_assignment(p))) {

r = log_oom();

goto finish;

}

t = strv_append(m, u);

free(u);

if (!t) {

r = log_oom();

goto finish;

}

strv_free(m);

m = t;

}

r = 0;

*rl = m;

m = NULL;

finish:

if (f)

fclose(f);

strv_free(m);

return r;

}

int write_env_file(const char *fname, char **l) {

char **i, *p;

FILE *f;

int r;

r = fopen_temporary(fname, &f, &p);

if (r < 0)

return r;

fchmod_umask(fileno(f), 0644);

errno = 0;

STRV_FOREACH(i, l) {

fputs(*i, f);

fputc('\n', f);

}

fflush(f);

if (ferror(f)) {

if (errno != 0)

r = -errno;

else

r = -EIO;

} else {

if (rename(p, fname) < 0)

r = -errno;

else

r = 0;

}

if (r < 0)

unlink(p);

fclose(f);

free(p);

return r;

}

char *truncate_nl(char *s) {

assert(s);

s[strcspn(s, NEWLINE)] = 0;

return s;

}

int get_process_comm(pid_t pid, char **name) {

int r;

assert(name);

if (pid == 0)

r = read_one_line_file("/proc/self/comm", name);

else {

char *p;

if (asprintf(&p, "/proc/%lu/comm", (unsigned long) pid) < 0)

return -ENOMEM;

r = read_one_line_file(p, name);

free(p);

}

return r;

}

int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {

char *r, *k;

int c;

bool space = false;

size_t left;

FILE *f;

assert(max_length > 0);

assert(line);

if (pid == 0)

f = fopen("/proc/self/cmdline", "re");

else {

char *p;

if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)

return -ENOMEM;

f = fopen(p, "re");

free(p);

}

if (!f)

return -errno;

r = new(char, max_length);

if (!r) {

fclose(f);

return -ENOMEM;

}

k = r;

left = max_length;

while ((c = getc(f)) != EOF) {

if (isprint(c)) {

if (space) {

if (left <= 4)

break;

*(k++) = ' ';

left--;

space = false;

}

if (left <= 4)

break;

*(k++) = (char) c;

left--;

} else

space = true;

}

if (left <= 4) {

size_t n = MIN(left-1, 3U);

memcpy(k, "...", n);

k[n] = 0;

} else

*k = 0;

fclose(f);

/* Kernel threads have no argv[] */

if (r[0] == 0) {

char *t;

int h;

free(r);

if (!comm_fallback)

return -ENOENT;

h = get_process_comm(pid, &t);

if (h < 0)

return h;

r = strjoin("[", t, "]", NULL);

free(t);

if (!r)

return -ENOMEM;

}

*line = r;

return 0;

}

int is_kernel_thread(pid_t pid) {

char *p;

size_t count;

char c;

bool eof;

FILE *f;

if (pid == 0)

return 0;

if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)

return -ENOMEM;

f = fopen(p, "re");

free(p);

if (!f)

return -errno;

count = fread(&c, 1, 1, f);

eof = feof(f);

fclose(f);

/* Kernel threads have an empty cmdline */

if (count <= 0)

return eof ? 1 : -errno;

return 0;

}

int get_process_exe(pid_t pid, char **name) {

int r;

assert(name);

if (pid == 0)

r = readlink_malloc("/proc/self/exe", name);

else {

char *p;

if (asprintf(&p, "/proc/%lu/exe", (unsigned long) pid) < 0)

return -ENOMEM;

r = readlink_malloc(p, name);

free(p);

}

return r;

}

static int get_process_id(pid_t pid, const char *field, uid_t *uid) {

char *p;

FILE *f;

int r;

assert(uid);

if (pid == 0)

return getuid();

if (asprintf(&p, "/proc/%lu/status", (unsigned long) pid) < 0)

return -ENOMEM;

f = fopen(p, "re");

free(p);

if (!f)

return -errno;

while (!feof(f)) {

char line[LINE_MAX], *l;

if (!fgets(line, sizeof(line), f)) {

if (feof(f))

break;

r = -errno;

goto finish;

}

l = strstrip(line);

if (startswith(l, field)) {

l += strlen(field);

l += strspn(l, WHITESPACE);

l[strcspn(l, WHITESPACE)] = 0;

r = parse_uid(l, uid);

goto finish;

}

}

r = -EIO;

finish:

fclose(f);

return r;

}

int get_process_uid(pid_t pid, uid_t *uid) {

return get_process_id(pid, "Uid:", uid);

}

int get_process_gid(pid_t pid, gid_t *gid) {

return get_process_id(pid, "Gid:", gid);

}

char *strnappend(const char *s, const char *suffix, size_t b) {

size_t a;

char *r;

if (!s && !suffix)

return strdup("");

if (!s)

return strndup(suffix, b);

if (!suffix)

return strdup(s);

assert(s);

assert(suffix);

a = strlen(s);

if (b > ((size_t) -1) - a)

return NULL;

r = new(char, a+b+1);

if (!r)

return NULL;

memcpy(r, s, a);

memcpy(r+a, suffix, b);

r[a+b] = 0;

return r;

}

char *strappend(const char *s, const char *suffix) {

return strnappend(s, suffix, suffix ? strlen(suffix) : 0);

}

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

size_t l = 100;

assert(p);

assert(r);

for (;;) {

char *c;

ssize_t n;

if (!(c = new(char, l)))

return -ENOMEM;

if ((n = readlink(p, c, l-1)) < 0) {

int ret = -errno;

free(c);

return ret;

}

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

c[n] = 0;

*r = c;

return 0;

}

free(c);

l *= 2;

}

}

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

char *target, *k;

int j;

assert(p);

assert(r);

if ((j = readlink_malloc(p, &target)) < 0)

return j;

k = file_in_same_dir(p, target);

free(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;

}

int reset_all_signal_handlers(void) {

int sig;

for (sig = 1; sig < _NSIG; sig++) {

struct sigaction sa;

if (sig == SIGKILL || sig == SIGSTOP)

continue;

zero(sa);

sa.sa_handler = SIG_DFL;

sa.sa_flags = SA_RESTART;

/* On Linux the first two RT signals are reserved by

if ((sigaction(sig, &sa, NULL) < 0))

if (errno != EINVAL)

return -errno;

}

return 0;

}

char *strstrip(char *s) {

char *e;

/* Drops trailing whitespace. Modifies the string in

s += strspn(s, WHITESPACE);

for (e = strchr(s, 0); e > s; e --)

if (!strchr(WHITESPACE, e[-1]))

break;

*e = 0;

return s;

}

char *delete_chars(char *s, const char *bad) {

char *f, *t;

/* Drops all whitespace, regardless where in the string */

for (f = s, t = s; *f; f++) {

if (strchr(bad, *f))

continue;

*(t++) = *f;

}

*t = 0;

return s;

}

bool in_charset(const char *s, const char* charset) {

const char *i;

assert(s);

assert(charset);

for (i = s; *i; i++)

if (!strchr(charset, *i))

return false;

return true;

}

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

char *e, *r;

size_t k;

assert(path);

assert(filename);

/* This removes the last component of path and appends

if (path_is_absolute(filename))

return strdup(filename);

if (!(e = strrchr(path, '/')))

return strdup(filename);

k = strlen(filename);

if (!(r = new(char, e-path+1+k+1)))

return NULL;

memcpy(r, path, e-path+1);

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

return r;

}

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 -1;

}

char octchar(int x) {

return '0' + (x & 7);

}

int unoctchar(char c) {

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

return c - '0';

return -1;

}

char decchar(int x) {

return '0' + (x % 10);

}

int undecchar(char c) {

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

return c - '0';

return -1;

}

char *cescape(const char *s) {

char *r, *t;

const char *f;

assert(s);

/* Does C style string escaping. */

r = new(char, strlen(s)*4 + 1);

if (!r)

return NULL;

for (f = s, t = r; *f; f++)

switch (*f) {

case '\a':

*(t++) = '\\';

*(t++) = 'a';

break;

case '\b':

*(t++) = '\\';

*(t++) = 'b';

break;

case '\f':

*(t++) = '\\';

*(t++) = 'f';

break;

case '\n':

*(t++) = '\\';

*(t++) = 'n';

break;

case '\r':

*(t++) = '\\';

*(t++) = 'r';

break;

case '\t':

*(t++) = '\\';

*(t++) = 't';

break;

case '\v':

*(t++) = '\\';

*(t++) = 'v';

break;

case '\\':

*(t++) = '\\';

*(t++) = '\\';

break;

case '"':

*(t++) = '\\';

*(t++) = '"';

break;

case '\'':

*(t++) = '\\';

*(t++) = '\'';

break;

default:

/* For special chars we prefer octal over

if ((*f < ' ') || (*f >= 127)) {

*(t++) = '\\';

*(t++) = octchar((unsigned char) *f >> 6);

*(t++) = octchar((unsigned char) *f >> 3);

*(t++) = octchar((unsigned char) *f);

} else

*(t++) = *f;

break;

}

*t = 0;

return r;

}

char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {

char *r, *t;

const char *f;

size_t pl;

assert(s);

/* Undoes C style string escaping, and optionally prefixes it. */

pl = prefix ? strlen(prefix) : 0;

r = new(char, pl+length+1);

if (!r)

return r;

if (prefix)

memcpy(r, prefix, pl);

for (f = s, t = r + pl; f < s + length; f++) {

if (*f != '\\') {

*(t++) = *f;

continue;

}

f++;

switch (*f) {

case 'a':

*(t++) = '\a';

break;

case 'b':

*(t++) = '\b';

break;

case 'f':

*(t++) = '\f';

break;

case 'n':

*(t++) = '\n';

break;

case 'r':

*(t++) = '\r';

break;

case 't':

*(t++) = '\t';

break;

case 'v':

*(t++) = '\v';

break;

case '\\':

*(t++) = '\\';

break;

case '"':

*(t++) = '"';

break;

case '\'':

*(t++) = '\'';

break;

case 's':

/* This is an extension of the XDG syntax files */

*(t++) = ' ';

break;

case 'x': {

/* hexadecimal encoding */

int a, b;

a = unhexchar(f[1]);

b = unhexchar(f[2]);

if (a < 0 || b < 0) {

/* Invalid escape code, let's take it literal then */

*(t++) = '\\';

*(t++) = 'x';

} else {

*(t++) = (char) ((a << 4) | b);

f += 2;

}

break;

}

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7': {

/* octal encoding */

int a, b, c;

a = unoctchar(f[0]);

b = unoctchar(f[1]);

c = unoctchar(f[2]);

if (a < 0 || b < 0 || c < 0) {

/* Invalid escape code, let's take it literal then */

*(t++) = '\\';

*(t++) = f[0];

} else {

*(t++) = (char) ((a << 6) | (b << 3) | c);

f += 2;

}

break;

}

case 0:

/* premature end of string.*/

*(t++) = '\\';

goto finish;

default:

/* Invalid escape code, let's take it literal then */

*(t++) = '\\';

*(t++) = *f;

break;

}

}

finish:

*t = 0;

return r;

}

char *cunescape_length(const char *s, size_t length) {

return cunescape_length_with_prefix(s, length, NULL);

}

char *cunescape(const char *s) {

assert(s);

return cunescape_length(s, strlen(s));

}

char *xescape(const char *s, const char *bad) {

char *r, *t;

const char *f;

/* Escapes all chars in bad, in addition to \ and all special

r = new(char, strlen(s) * 4 + 1);

if (!r)

return NULL;

for (f = s, t = r; *f; f++) {

if ((*f < ' ') || (*f >= 127) ||

(*f == '\\') || strchr(bad, *f)) {

*(t++) = '\\';

*(t++) = 'x';

*(t++) = hexchar(*f >> 4);

*(t++) = hexchar(*f);

} else

*(t++) = *f;

}

*t = 0;

return r;

}

char *bus_path_escape(const char *s) {

char *r, *t;

const char *f;

assert(s);

/* Escapes all chars that D-Bus' object path cannot deal

if (!(r = new(char, strlen(s)*3+1)))

return NULL;

for (f = s, t = r; *f; f++) {

if (!(*f >= 'A' && *f <= 'Z') &&

!(*f >= 'a' && *f <= 'z') &&

!(*f >= '0' && *f <= '9')) {

*(t++) = '_';

*(t++) = hexchar(*f >> 4);

*(t++) = hexchar(*f);

} else

*(t++) = *f;

}

*t = 0;

return r;

}

char *bus_path_unescape(const char *f) {

char *r, *t;

assert(f);

if (!(r = strdup(f)))

return NULL;

for (t = r; *f; f++) {

if (*f == '_') {

int a, b;

if ((a = unhexchar(f[1])) < 0 ||

(b = unhexchar(f[2])) < 0) {

/* Invalid escape code, let's take it literal then */

*(t++) = '_';

} else {

*(t++) = (char) ((a << 4) | b);

f += 2;

}

} else

*(t++) = *f;

}

*t = 0;

return r;

}

char *ascii_strlower(char *t) {

char *p;

assert(t);

for (p = t; *p; p++)

if (*p >= 'A' && *p <= 'Z')

*p = *p - 'A' + 'a';

return t;

}

static bool ignore_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, ".swp");

}

bool ignore_file(const char *filename) {

assert(filename);

if (endswith(filename, "~"))

return false;

return ignore_file_allow_backup(filename);

}

int fd_nonblock(int fd, bool nonblock) {

int flags;

assert(fd >= 0);

if ((flags = fcntl(fd, F_GETFL, 0)) < 0)

return -errno;

if (nonblock)

flags |= O_NONBLOCK;

else

flags &= ~O_NONBLOCK;

if (fcntl(fd, F_SETFL, flags) < 0)

return -errno;

return 0;

}

int fd_cloexec(int fd, bool cloexec) {

int flags;

assert(fd >= 0);

if ((flags = fcntl(fd, F_GETFD, 0)) < 0)

return -errno;

if (cloexec)

flags |= FD_CLOEXEC;

else

flags &= ~FD_CLOEXEC;

if (fcntl(fd, F_SETFD, flags) < 0)

return -errno;

return 0;

}

static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {

unsigned i;

assert(n_fdset == 0 || fdset);

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

if (fdset[i] == fd)

return true;

return false;

}

int close_all_fds(const int except[], unsigned n_except) {

DIR *d;

struct dirent *de;

int r = 0;

assert(n_except == 0 || except);

d = opendir("/proc/self/fd");

if (!d) {

int fd;

struct rlimit rl;

/* When /proc isn't available (for example in chroots)

assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);

for (fd = 3; fd < (int) rl.rlim_max; fd ++) {

if (fd_in_set(fd, except, n_except))

continue;

if (close_nointr(fd) < 0)

if (errno != EBADF && r == 0)

r = -errno;

}

return r;

}

while ((de = readdir(d))) {

int fd = -1;

if (ignore_file(de->d_name))

continue;

if (safe_atoi(de->d_name, &fd) < 0)

/* Let's better ignore this, just in case */

continue;

if (fd < 3)

continue;

if (fd == dirfd(d))

continue;

if (fd_in_set(fd, except, n_except))

continue;

if (close_nointr(fd) < 0) {

/* Valgrind has its own FD and doesn't want to have it closed */

if (errno != EBADF && r == 0)

r = -errno;

}

}

closedir(d);

return r;

}

bool chars_intersect(const char *a, const char *b) {

const char *p;

/* Returns true if any of the chars in a are in b. */

for (p = a; *p; p++)

if (strchr(b, *p))

return true;

return false;

}

bool fstype_is_network(const char *fstype) {

static const char table[] =

"cifs\0"

"smbfs\0"

"ncpfs\0"

"nfs\0"

"nfs4\0"

"gfs\0"

"gfs2\0";

return nulstr_contains(table, fstype);

}

int chvt(int vt) {

_cleanup_close_ int fd;

fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);

if (fd < 0)

return -errno;

if (vt < 0) {

int tiocl[2] = {

TIOCL_GETKMSGREDIRECT,

0

};

if (ioctl(fd, TIOCLINUX, tiocl) < 0)

return -errno;

vt = tiocl[0] <= 0 ? 1 : tiocl[0];

}

if (ioctl(fd, VT_ACTIVATE, vt) < 0)

return -errno;

return 0;

}

int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {

struct termios old_termios, new_termios;

char c;

char line[LINE_MAX];

assert(f);

assert(ret);

if (tcgetattr(fileno(f), &old_termios) >= 0) {

new_termios = old_termios;

new_termios.c_lflag &= ~ICANON;

new_termios.c_cc[VMIN] = 1;

new_termios.c_cc[VTIME] = 0;

if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {

size_t k;

if (t != (usec_t) -1) {

if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {

tcsetattr(fileno(f), TCSADRAIN, &old_termios);

return -ETIMEDOUT;

}

}

k = fread(&c, 1, 1, f);

tcsetattr(fileno(f), TCSADRAIN, &old_termios);

if (k <= 0)

return -EIO;

if (need_nl)

*need_nl = c != '\n';

*ret = c;

return 0;

}

}

if (t != (usec_t) -1)

if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)

return -ETIMEDOUT;

if (!fgets(line, sizeof(line), f))

return -EIO;

truncate_nl(line);

if (strlen(line) != 1)

return -EBADMSG;

if (need_nl)

*need_nl = false;

*ret = line[0];

return 0;

}

int ask(char *ret, const char *replies, const char *text, ...) {

assert(ret);

assert(replies);

assert(text);

for (;;) {

va_list ap;

char c;

int r;

bool need_nl = true;

if (on_tty())

fputs(ANSI_HIGHLIGHT_ON, stdout);

va_start(ap, text);

vprintf(text, ap);

va_end(ap);

if (on_tty())

fputs(ANSI_HIGHLIGHT_OFF, stdout);

fflush(stdout);

r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);

if (r < 0) {

if (r == -EBADMSG) {

puts("Bad input, please try again.");

continue;

}

putchar('\n');

return r;

}

if (need_nl)

putchar('\n');

if (strchr(replies, c)) {

*ret = c;

return 0;

}

puts("Read unexpected character, please try again.");

}

}

int reset_terminal_fd(int fd, bool switch_to_text) {

struct termios termios;

int r = 0;

/* Set terminal to some sane defaults */

assert(fd >= 0);

/* We leave locked terminal attributes untouched, so that

/* Disable exclusive mode, just in case */

ioctl(fd, TIOCNXCL);

/* Switch to text mode */

if (switch_to_text)

ioctl(fd, KDSETMODE, KD_TEXT);

/* Enable console unicode mode */

ioctl(fd, KDSKBMODE, K_UNICODE);

if (tcgetattr(fd, &termios) < 0) {

r = -errno;

goto finish;

}

/* We only reset the stuff that matters to the software. How

termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);

termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;

termios.c_oflag |= ONLCR;

termios.c_cflag |= CREAD;

termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;

termios.c_cc[VINTR] = 03; /* ^C */

termios.c_cc[VQUIT] = 034; /* ^\ */

termios.c_cc[VERASE] = 0177;

termios.c_cc[VKILL] = 025; /* ^X */

termios.c_cc[VEOF] = 04; /* ^D */

termios.c_cc[VSTART] = 021; /* ^Q */

termios.c_cc[VSTOP] = 023; /* ^S */

termios.c_cc[VSUSP] = 032; /* ^Z */

termios.c_cc[VLNEXT] = 026; /* ^V */

termios.c_cc[VWERASE] = 027; /* ^W */

termios.c_cc[VREPRINT] = 022; /* ^R */

termios.c_cc[VEOL] = 0;

termios.c_cc[VEOL2] = 0;

termios.c_cc[VTIME] = 0;

termios.c_cc[VMIN] = 1;

if (tcsetattr(fd, TCSANOW, &termios) < 0)

r = -errno;

finish:

/* Just in case, flush all crap out */

tcflush(fd, TCIOFLUSH);

return r;

}

int reset_terminal(const char *name) {

int fd, r;

fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);

if (fd < 0)

return fd;

r = reset_terminal_fd(fd, true);

close_nointr_nofail(fd);

return r;

}

int open_terminal(const char *name, int mode) {

int fd, r;

unsigned c = 0;

/*

for (;;) {

fd = open(name, mode);

if (fd >= 0)

break;

if (errno != EIO)

return -errno;

/* Max 1s in total */

if (c >= 20)

return -errno;

usleep(50 * USEC_PER_MSEC);

c++;

}

if (fd < 0)

return -errno;

r = isatty(fd);

if (r < 0) {

close_nointr_nofail(fd);

return -errno;

}

if (!r) {

close_nointr_nofail(fd);

return -ENOTTY;

}

return fd;

}

int flush_fd(int fd) {

struct pollfd pollfd;

zero(pollfd);

pollfd.fd = fd;

pollfd.events = POLLIN;

for (;;) {

char buf[LINE_MAX];

ssize_t l;

int r;

if ((r = poll(&pollfd, 1, 0)) < 0) {

if (errno == EINTR)

continue;

return -errno;

}

if (r == 0)

return 0;

if ((l = read(fd, buf, sizeof(buf))) < 0) {

if (errno == EINTR)

continue;

if (errno == EAGAIN)

return 0;

return -errno;

}

if (l <= 0)

return 0;

}

}

int acquire_terminal(

const char *name,

bool fail,

bool force,

bool ignore_tiocstty_eperm,

usec_t timeout) {

int fd = -1, notify = -1, r = 0, wd = -1;

usec_t ts = 0;

struct sigaction sa_old, sa_new;

assert(name);

/* We use inotify to be notified when the tty is closed. We

if (timeout != (usec_t) -1)

ts = now(CLOCK_MONOTONIC);

if (!fail && !force) {

notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));

if (notify < 0) {

r = -errno;

goto fail;

}

wd = inotify_add_watch(notify, name, IN_CLOSE);

if (wd < 0) {

r = -errno;

goto fail;

}

}

for (;;) {

if (notify >= 0) {

r = flush_fd(notify);

if (r < 0)

goto fail;

}

/* We pass here O_NOCTTY only so that we can check the return

fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);

if (fd < 0)

return fd;

/* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed

zero(sa_new);

sa_new.sa_handler = SIG_IGN;

sa_new.sa_flags = SA_RESTART;

assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);

/* First, try to get the tty */

if (ioctl(fd, TIOCSCTTY, force) < 0)

r = -errno;

assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);

/* Sometimes it makes sense to ignore TIOCSCTTY

if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)

r = 0;

if (r < 0 && (force || fail || r != -EPERM)) {

goto fail;

}

if (r >= 0)

break;

assert(!fail);

assert(!force);

assert(notify >= 0);

for (;;) {

uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];

ssize_t l;

struct inotify_event *e;

if (timeout != (usec_t) -1) {

usec_t n;

n = now(CLOCK_MONOTONIC);

if (ts + timeout < n) {

r = -ETIMEDOUT;

goto fail;

}

r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);

if (r < 0)

goto fail;

if (r == 0) {

r = -ETIMEDOUT;

goto fail;

}

}

l = read(notify, inotify_buffer, sizeof(inotify_buffer));

if (l < 0) {

if (errno == EINTR || errno == EAGAIN)

continue;

r = -errno;

goto fail;

}

e = (struct inotify_event*) inotify_buffer;

while (l > 0) {

size_t step;

if (e->wd != wd || !(e->mask & IN_CLOSE)) {

r = -EIO;

goto fail;

}

step = sizeof(struct inotify_event) + e->len;

assert(step <= (size_t) l);

e = (struct inotify_event*) ((uint8_t*) e + step);

l -= step;

}

break;

}

/* We close the tty fd here since if the old session

close_nointr_nofail(fd);

}

if (notify >= 0)

close_nointr_nofail(notify);

r = reset_terminal_fd(fd, true);

if (r < 0)

log_warning("Failed to reset terminal: %s", strerror(-r));

return fd;

fail:

if (fd >= 0)

close_nointr_nofail(fd);

if (notify >= 0)

close_nointr_nofail(notify);

return r;

}

int release_terminal(void) {

int r = 0, fd;

struct sigaction sa_old, sa_new;

if ((fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC)) < 0)

return -errno;

/* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed

zero(sa_new);

sa_new.sa_handler = SIG_IGN;

sa_new.sa_flags = SA_RESTART;

assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);

if (ioctl(fd, TIOCNOTTY) < 0)

r = -errno;

assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);

close_nointr_nofail(fd);

return r;

}

int sigaction_many(const struct sigaction *sa, ...) {

va_list ap;

int r = 0, sig;

va_start(ap, sa);

while ((sig = va_arg(ap, int)) > 0)

if (sigaction(sig, sa, NULL) < 0)

r = -errno;

va_end(ap);

return r;

}

int ignore_signals(int sig, ...) {

struct sigaction sa;

va_list ap;

int r = 0;

zero(sa);

sa.sa_handler = SIG_IGN;

sa.sa_flags = SA_RESTART;

if (sigaction(sig, &sa, NULL) < 0)

r = -errno;

va_start(ap, sig);

while ((sig = va_arg(ap, int)) > 0)

if (sigaction(sig, &sa, NULL) < 0)

r = -errno;

va_end(ap);

return r;

}

int default_signals(int sig, ...) {

struct sigaction sa;

va_list ap;

int r = 0;

zero(sa);

sa.sa_handler = SIG_DFL;

sa.sa_flags = SA_RESTART;

if (sigaction(sig, &sa, NULL) < 0)

r = -errno;

va_start(ap, sig);

while ((sig = va_arg(ap, int)) > 0)

if (sigaction(sig, &sa, NULL) < 0)

r = -errno;

va_end(ap);

return r;

}

int close_pipe(int p[]) {

int a = 0, b = 0;

assert(p);

if (p[0] >= 0) {

a = close_nointr(p[0]);

p[0] = -1;

}

if (p[1] >= 0) {

b = close_nointr(p[1]);

p[1] = -1;

}

return a < 0 ? a : b;

}

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

uint8_t *p;

ssize_t n = 0;

assert(fd >= 0);

assert(buf);

p = buf;

while (nbytes > 0) {

ssize_t k;

if ((k = read(fd, p, nbytes)) <= 0) {

if (k < 0 && errno == EINTR)

continue;

if (k < 0 && errno == EAGAIN && do_poll) {

struct pollfd pollfd;

zero(pollfd);

pollfd.fd = fd;

pollfd.events = POLLIN;

if (poll(&pollfd, 1, -1) < 0) {

if (errno == EINTR)

continue;

return n > 0 ? n : -errno;

}

if (pollfd.revents != POLLIN)

return n > 0 ? n : -EIO;

continue;

}

return n > 0 ? n : (k < 0 ? -errno : 0);

}

p += k;

nbytes -= k;

n += k;

}

return n;

}

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

const uint8_t *p;

ssize_t n = 0;

assert(fd >= 0);

assert(buf);

p = buf;

while (nbytes > 0) {

ssize_t k;

k = write(fd, p, nbytes);

if (k <= 0) {

if (k < 0 && errno == EINTR)

continue;

if (k < 0 && errno == EAGAIN && do_poll) {

struct pollfd pollfd;

zero(pollfd);

pollfd.fd = fd;

pollfd.events = POLLOUT;

if (poll(&pollfd, 1, -1) < 0) {

if (errno == EINTR)

continue;

return n > 0 ? n : -errno;

}

if (pollfd.revents != POLLOUT)

return n > 0 ? n : -EIO;

continue;

}

return n > 0 ? n : (k < 0 ? -errno : 0);

}

p += k;

nbytes -= k;

n += k;

}

return n;

}

int parse_bytes(const char *t, off_t *bytes) {

static const struct {

const char *suffix;

off_t factor;

} table[] = {

{ "B", 1 },

{ "K", 1024ULL },

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

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

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

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

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

{ "", 1 },

};

const char *p;

off_t r = 0;

assert(t);

assert(bytes);

p = t;

do {

long long l;

char *e;

unsigned i;

errno = 0;

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

if (errno != 0)

return -errno;

if (l < 0)

return -ERANGE;

if (e == p)

return -EINVAL;

e += strspn(e, WHITESPACE);

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

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

r += (off_t) l * table[i].factor;

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

break;

}

if (i >= ELEMENTSOF(table))

return -EINVAL;

} while (*p != 0);

*bytes = r;

return 0;

}

int make_stdio(int fd) {

int r, s, t;

assert(fd >= 0);

r = dup3(fd, STDIN_FILENO, 0);

s = dup3(fd, STDOUT_FILENO, 0);

t = dup3(fd, STDERR_FILENO, 0);

if (fd >= 3)

close_nointr_nofail(fd);

if (r < 0 || s < 0 || t < 0)

return -errno;

/* We rely here that the new fd has O_CLOEXEC not set */

return 0;

}

int make_null_stdio(void) {

int null_fd;

null_fd = open("/dev/null", O_RDWR|O_NOCTTY);

if (null_fd < 0)

return -errno;

return make_stdio(null_fd);

}

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;

int r;

d = opendir(path);

if (!d)

return -errno;

for (;;) {

struct dirent *de;

union dirent_storage buf;

r = readdir_r(d, &buf.de, &de);

if (r > 0)

return -r;

if (!de)

return 1;

if (!ignore_file(de->d_name))

return 0;

}

}

unsigned long long random_ull(void) {

_cleanup_close_ int fd;

uint64_t ull;

ssize_t r;

fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);

if (fd < 0)

goto fallback;

r = loop_read(fd, &ull, sizeof(ull), true);

if (r != sizeof(ull))

goto fallback;

return ull;

fallback:

return random() * RAND_MAX + random();

}

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;

memset(saved_argv[i], 0, strlen(saved_argv[i]));

}

}

}

void sigset_add_many(sigset_t *ss, ...) {

va_list ap;

int sig;

assert(ss);

va_start(ap, ss);

while ((sig = va_arg(ap, int)) > 0)

assert_se(sigaddset(ss, sig) == 0);

va_end(ap);

}

char* gethostname_malloc(void) {

struct utsname u;

assert_se(uname(&u) >= 0);

if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))

return strdup(u.nodename);

return strdup(u.sysname);

}

bool hostname_is_set(void) {

struct utsname u;

assert_se(uname(&u) >= 0);

return !isempty(u.nodename) && !streq(u.nodename, "(none)");

}

static 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, "%lu", (unsigned long) 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());

}

int getttyname_malloc(int fd, char **r) {

char path[PATH_MAX], *c;

int k;

assert(r);

k = ttyname_r(fd, path, sizeof(path));

if (k != 0)

return -k;

char_array_0(path);

c = strdup(startswith(path, "/dev/") ? path + 5 : path);

if (!c)

return -ENOMEM;

*r = c;

return 0;

}

int getttyname_harder(int fd, char **r) {

int k;

char *s;

k = getttyname_malloc(fd, &s);

if (k < 0)

return k;

if (streq(s, "tty")) {

free(s);

return get_ctty(0, NULL, r);

}

*r = s;

return 0;

}

int get_ctty_devnr(pid_t pid, dev_t *d) {

int k;

char line[LINE_MAX], *p, *fn;

unsigned long ttynr;

FILE *f;

if (asprintf(&fn, "/proc/%lu/stat", (unsigned long) (pid <= 0 ? getpid() : pid)) < 0)

return -ENOMEM;

f = fopen(fn, "re");

free(fn);

if (!f)

return -errno;

if (!fgets(line, sizeof(line), f)) {

k = feof(f) ? -EIO : -errno;

fclose(f);

return k;

}

fclose(f);

p = strrchr(line, ')');

if (!p)

return -EIO;

p++;

if (sscanf(p, " "

"%*c " /* state */

"%*d " /* ppid */

"%*d " /* pgrp */

"%*d " /* session */

"%lu ", /* ttynr */

&ttynr) != 1)

return -EIO;

if (major(ttynr) == 0 && minor(ttynr) == 0)

return -ENOENT;

*d = (dev_t) ttynr;

return 0;

}

int get_ctty(pid_t pid, dev_t *_devnr, char **r) {

int k;

char fn[PATH_MAX], *s, *b, *p;

dev_t devnr;

assert(r);

k = get_ctty_devnr(pid, &devnr);

if (k < 0)

return k;

snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));

char_array_0(fn);

k = readlink_malloc(fn, &s);

if (k < 0) {

if (k != -ENOENT)

return k;

/* This is an ugly hack */

if (major(devnr) == 136) {

if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)

return -ENOMEM;

*r = b;

if (_devnr)

*_devnr = devnr;

return 0;

}

/* Probably something like the ptys which have no

b = strdup(fn + 5);

if (!b)

return -ENOMEM;

*r = b;

if (_devnr)

*_devnr = devnr;

return 0;

}

if (startswith(s, "/dev/"))

p = s + 5;

else if (startswith(s, "../"))

p = s + 3;

else

p = s;

b = strdup(p);

free(s);

if (!b)

return -ENOMEM;

*r = b;

if (_devnr)

*_devnr = devnr;

return 0;

}

int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {

DIR *d;

int ret = 0;

assert(fd >= 0);

/* This returns the first error we run into, but nevertheless

d = fdopendir(fd);

if (!d) {

close_nointr_nofail(fd);

return errno == ENOENT ? 0 : -errno;

}

for (;;) {

struct dirent *de;

union dirent_storage buf;

bool is_dir, keep_around;

struct stat st;

int r;

r = readdir_r(d, &buf.de, &de);

if (r != 0 && ret == 0) {

ret = -r;

break;

}

if (!de)

break;

if (streq(de->d_name, ".") || streq(de->d_name, ".."))

continue;

if (de->d_type == DT_UNKNOWN ||

honour_sticky ||

(de->d_type == DT_DIR && root_dev)) {

if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {

if (ret == 0 && errno != ENOENT)

ret = -errno;

continue;

}

is_dir = S_ISDIR(st.st_mode);

keep_around =

honour_sticky &&

(st.st_uid == 0 || st.st_uid == getuid()) &&

(st.st_mode & S_ISVTX);

} else {

is_dir = de->d_type == DT_DIR;

keep_around = false;

}

if (is_dir) {

int subdir_fd;

/* if root_dev is set, remove subdirectories only, if device is same as dir */

if (root_dev && st.st_dev != root_dev->st_dev)

continue;

subdir_fd = openat(fd, de->d_name,

O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);

if (subdir_fd < 0) {

if (ret == 0 && errno != ENOENT)

ret = -errno;

continue;

}

r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);

if (r < 0 && ret == 0)

ret = r;

if (!keep_around)

if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {

if (ret == 0 && errno != ENOENT)

ret = -errno;

}

} else if (!only_dirs && !keep_around) {

if (unlinkat(fd, de->d_name, 0) < 0) {

if (ret == 0 && errno != ENOENT)

ret = -errno;

}

}

}

closedir(d);

return ret;

}

static int is_temporary_fs(struct statfs *s) {

assert(s);

return s->f_type == TMPFS_MAGIC ||

(long)s->f_type == (long)RAMFS_MAGIC;

}

int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {

struct statfs s;

assert(fd >= 0);

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

close_nointr_nofail(fd);

return -errno;

}

/* We refuse to clean disk file systems with this call. This

if (!is_temporary_fs(&s)) {

log_error("Attempted to remove disk file system, and we can't allow that.");

close_nointr_nofail(fd);

return -EPERM;

}

return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);

}

static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {

int fd, r;

struct statfs s;

assert(path);

/* We refuse to clean the root file system with this

if (path_equal(path, "/")) {

log_error("Attempted to remove entire root file system, and we can't allow that.");

return -EPERM;

}

fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);

if (fd < 0) {

if (errno != ENOTDIR)

return -errno;

if (!dangerous) {

if (statfs(path, &s) < 0)

return -errno;

if (!is_temporary_fs(&s)) {

log_error("Attempted to remove disk file system, and we can't allow that.");

return -EPERM;

}

}

if (delete_root && !only_dirs)

if (unlink(path) < 0 && errno != ENOENT)

return -errno;

return 0;

}

if (!dangerous) {

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

close_nointr_nofail(fd);

return -errno;

}

if (!is_temporary_fs(&s)) {

log_error("Attempted to remove disk file system, and we can't allow that.");

close_nointr_nofail(fd);

return -EPERM;

}

}

r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);

if (delete_root) {

if (honour_sticky && file_is_priv_sticky(path) > 0)

return r;

if (rmdir(path) < 0 && errno != ENOENT) {

if (r == 0)

r = -errno;

}

}

return r;

}

int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {

return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);

}

int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {

return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);

}

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_t) -1)

if (chmod(path, mode) < 0)

return -errno;

if (uid != (uid_t) -1 || gid != (gid_t) -1)

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);