#include "log.h"
#include "strv.h"
#include "label.h"
+#include "mkdir.h"
#include "path-util.h"
#include "exit-status.h"
#include "hashmap.h"
#include "gunicode.h"
#include "virt.h"
#include "def.h"
-#include "missing.h"
int saved_argc = 0;
char **saved_argv = NULL;
assert(fd >= 0);
r = close(fd);
-
- /* Just ignore EINTR; a retry loop is the wrong
- * thing to do on Linux.
- *
- * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
- * https://bugzilla.gnome.org/show_bug.cgi?id=682819
- * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
- * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
- */
- if (_unlikely_(r < 0 && errno == EINTR))
- return 0;
- else if (r >= 0)
+ if (r >= 0)
return r;
+ else if (errno == EINTR)
+ /*
+ * Just ignore EINTR; a retry loop is the wrong
+ * thing to do on Linux.
+ *
+ * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
+ * https://bugzilla.gnome.org/show_bug.cgi?id=682819
+ * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
+ * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
+ */
+ return 0;
else
return -errno;
}
-void close_nointr_nofail(int fd) {
- PROTECT_ERRNO;
+int safe_close(int fd) {
- /* like close_nointr() but cannot fail, and guarantees errno
- * is unchanged */
+ /*
+ * Like close_nointr() but cannot fail. Guarantees errno is
+ * unchanged. Is a NOP with negative fds passed, and returns
+ * -1, so that it can be used in this syntax:
+ *
+ * fd = safe_close(fd);
+ */
+
+ if (fd >= 0) {
+ PROTECT_ERRNO;
+
+ /* The kernel might return pretty much any error code
+ * via close(), but the fd will be closed anyway. The
+ * only condition we want to check for here is whether
+ * the fd was invalid at all... */
- assert_se(close_nointr(fd) == 0);
+ assert_se(close_nointr(fd) != -EBADF);
+ }
+
+ return -1;
}
void close_many(const int fds[], unsigned n_fd) {
assert(fds || n_fd <= 0);
for (i = 0; i < n_fd; i++)
- close_nointr_nofail(fds[i]);
+ safe_close(fds[i]);
}
int unlink_noerrno(const char *path) {
return s;
}
-bool in_charset(const char *s, const char* charset) {
- assert(s);
- assert(charset);
- return s[strspn(s, charset)] == '\0';
-}
-
char *file_in_same_dir(const char *path, const char *filename) {
char *e, *r;
size_t k;
"nfs\0"
"nfs4\0"
"gfs\0"
- "gfs2\0";
+ "gfs2\0"
+ "glusterfs\0";
+
+ const char *x;
+
+ x = startswith(fstype, "fuse.");
+ if (x)
+ fstype = x;
return nulstr_contains(table, fstype);
}
}
int reset_terminal(const char *name) {
- int fd, r;
+ _cleanup_close_ int fd = -1;
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;
+ return reset_terminal_fd(fd, true);
}
int open_terminal(const char *name, int mode) {
r = isatty(fd);
if (r < 0) {
- close_nointr_nofail(fd);
+ safe_close(fd);
return -errno;
}
if (!r) {
- close_nointr_nofail(fd);
+ safe_close(fd);
return -ENOTTY;
}
* ended our handle will be dead. It's important that
* we do this after sleeping, so that we don't enter
* an endless loop. */
- close_nointr_nofail(fd);
+ safe_close(fd);
}
- if (notify >= 0)
- close_nointr_nofail(notify);
+ safe_close(notify);
r = reset_terminal_fd(fd, true);
if (r < 0)
return fd;
fail:
- if (fd >= 0)
- close_nointr_nofail(fd);
-
- if (notify >= 0)
- close_nointr_nofail(notify);
+ safe_close(fd);
+ safe_close(notify);
return r;
}
va_list ap;
int r = 0;
-
if (sigaction(sig, &sa, NULL) < 0)
r = -errno;
return r;
}
-int close_pipe(int p[]) {
- int a = 0, b = 0;
-
+void safe_close_pair(int p[]) {
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;
+ if (p[0] == p[1]) {
+ /* Special case pairs which use the same fd in both
+ * directions... */
+ p[0] = p[1] = safe_close(p[0]);
+ return;
}
- return a < 0 ? a : b;
+ p[0] = safe_close(p[0]);
+ p[1] = safe_close(p[1]);
}
ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
t = dup3(fd, STDERR_FILENO, 0);
if (fd >= 3)
- close_nointr_nofail(fd);
+ safe_close(fd);
if (r < 0 || s < 0 || t < 0)
return -errno;
va_end(ap);
}
+int sigprocmask_many(int how, ...) {
+ va_list ap;
+ sigset_t ss;
+ int sig;
+
+ assert_se(sigemptyset(&ss) == 0);
+
+ va_start(ap, how);
+ while ((sig = va_arg(ap, int)) > 0)
+ assert_se(sigaddset(&ss, sig) == 0);
+ va_end(ap);
+
+ if (sigprocmask(how, &ss, NULL) < 0)
+ return -errno;
+
+ return 0;
+}
+
char* gethostname_malloc(void) {
struct utsname u;
if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
return strdup(pw->pw_name);
- if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
+ if (asprintf(&name, UID_FMT, uid) < 0)
return NULL;
return name;
/* This is an ugly hack */
if (major(devnr) == 136) {
- asprintf(&b, "pts/%lu", (unsigned long) minor(devnr));
+ asprintf(&b, "pts/%u", minor(devnr));
goto finish;
}
d = fdopendir(fd);
if (!d) {
- close_nointr_nofail(fd);
+ safe_close(fd);
return errno == ENOENT ? 0 : -errno;
}
assert(fd >= 0);
if (fstatfs(fd, &s) < 0) {
- close_nointr_nofail(fd);
+ safe_close(fd);
return -errno;
}
* non-state data */
if (!is_temporary_fs(&s)) {
log_error("Attempted to remove disk file system, and we can't allow that.");
- close_nointr_nofail(fd);
+ safe_close(fd);
return -EPERM;
}
if (!dangerous) {
if (fstatfs(fd, &s) < 0) {
- close_nointr_nofail(fd);
+ safe_close(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);
+ safe_close(fd);
return -EPERM;
}
}
return ellipsize_mem(s, strlen(s), length, percent);
}
-int touch(const char *path) {
- int fd;
+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);
- /* This just opens the file for writing, ensuring it
- * exists. It doesn't call utimensat() the way /usr/bin/touch
- * does it. */
+ if (parents)
+ mkdir_parents(path, 0755);
- fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
+ fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
if (fd < 0)
return -errno;
- close_nointr_nofail(fd);
+ if (mode > 0) {
+ r = fchmod(fd, mode);
+ if (r < 0)
+ return -errno;
+ }
+
+ if (uid != (uid_t) -1 || gid != (gid_t) -1) {
+ r = fchown(fd, uid, gid);
+ if (r < 0)
+ return -errno;
+ }
+
+ if (stamp != (usec_t) -1) {
+ 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_t) -1, (uid_t) -1, (gid_t) -1, 0);
+}
+
char *unquote(const char *s, const char* quotes) {
size_t l;
assert(s);
d = fdopendir(nfd);
if (!d) {
- close_nointr_nofail(nfd);
+ safe_close(nfd);
return NULL;
}
}
int terminal_vhangup(const char *name) {
- int fd, r;
+ _cleanup_close_ int fd;
fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
if (fd < 0)
return fd;
- r = terminal_vhangup_fd(fd);
- close_nointr_nofail(fd);
-
- return r;
+ return terminal_vhangup_fd(fd);
}
int vt_disallocate(const char *name) {
"\033[H" /* move home */
"\033[2J", /* clear screen */
10, false);
- close_nointr_nofail(fd);
+ safe_close(fd);
return 0;
}
return fd;
r = ioctl(fd, VT_DISALLOCATE, u);
- close_nointr_nofail(fd);
+ safe_close(fd);
if (r >= 0)
return 0;
"\033[H" /* move home */
"\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
10, false);
- close_nointr_nofail(fd);
+ safe_close(fd);
return 0;
}
k = strspn(display+1, "0123456789");
- f = new(char, sizeof("/tmp/.X11-unix/X") + k);
+ f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
if (!f)
return -ENOMEM;
if (p)
return strdup(p->pw_name);
- if (asprintf(&r, "%lu", (unsigned long) uid) < 0)
+ if (asprintf(&r, UID_FMT, uid) < 0)
return NULL;
return r;
if (p)
return strdup(p->gr_name);
- if (asprintf(&r, "%lu", (unsigned long) gid) < 0)
+ if (asprintf(&r, GID_FMT, gid) < 0)
return NULL;
return r;
const char *draw_special_char(DrawSpecialChar ch) {
static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
+
/* UTF-8 */ {
- [DRAW_TREE_VERT] = "\342\224\202 ", /* │ */
+ [DRAW_TREE_VERTICAL] = "\342\224\202 ", /* │ */
[DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
[DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
[DRAW_TREE_SPACE] = " ", /* */
- [DRAW_TRIANGULAR_BULLET] = "\342\200\243 ", /* ‣ */
- [DRAW_BLACK_CIRCLE] = "\342\227\217 ", /* ● */
+ [DRAW_TRIANGULAR_BULLET] = "\342\200\243", /* ‣ */
+ [DRAW_BLACK_CIRCLE] = "\342\227\217", /* ● */
+ [DRAW_ARROW] = "\342\206\222", /* → */
},
+
/* ASCII fallback */ {
- [DRAW_TREE_VERT] = "| ",
+ [DRAW_TREE_VERTICAL] = "| ",
[DRAW_TREE_BRANCH] = "|-",
[DRAW_TREE_RIGHT] = "`-",
[DRAW_TREE_SPACE] = " ",
- [DRAW_TRIANGULAR_BULLET] = "> ",
- [DRAW_BLACK_CIRCLE] = "* ",
+ [DRAW_TRIANGULAR_BULLET] = ">",
+ [DRAW_BLACK_CIRCLE] = "*",
+ [DRAW_ARROW] = "->",
}
};
if (n != 6 || memcmp(contents, "Mains\n", 6))
continue;
- close_nointr_nofail(fd);
+ safe_close(fd);
fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
if (fd < 0) {
if (errno == ENOENT)
return found_online || !found_offline;
}
-static int search_and_fopen_internal(const char *path, const char *mode, char **search, FILE **_f) {
+static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
char **i;
assert(path);
assert(mode);
assert(_f);
- if (!path_strv_canonicalize_absolute_uniq(search, NULL))
+ if (!path_strv_canonicalize_absolute_uniq(search, root))
return -ENOMEM;
STRV_FOREACH(i, search) {
return -ENOENT;
}
-int search_and_fopen(const char *path, const char *mode, const char **search, FILE **_f) {
+int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
_cleanup_strv_free_ char **copy = NULL;
assert(path);
if (!copy)
return -ENOMEM;
- return search_and_fopen_internal(path, mode, copy, _f);
+ return search_and_fopen_internal(path, mode, root, copy, _f);
}
-int search_and_fopen_nulstr(const char *path, const char *mode, const char *search, FILE **_f) {
+int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
_cleanup_strv_free_ char **s = NULL;
if (path_is_absolute(path)) {
if (!s)
return -ENOMEM;
- return search_and_fopen_internal(path, mode, s, _f);
+ return search_and_fopen_internal(path, mode, root, s, _f);
}
char *strextend(char **x, ...) {
return r;
}
-void* greedy_realloc(void **p, size_t *allocated, size_t need) {
- size_t a;
+void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
+ size_t a, newalloc;
void *q;
assert(p);
if (*allocated >= need)
return *p;
- a = MAX(64u, need * 2);
+ newalloc = MAX(need * 2, 64u / size);
+ a = newalloc * size;
/* check for overflows */
- if (a < need)
+ if (a < size * need)
return NULL;
q = realloc(*p, a);
return NULL;
*p = q;
- *allocated = a;
+ *allocated = newalloc;
return q;
}
-void* greedy_realloc0(void **p, size_t *allocated, size_t need) {
+void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
size_t prev;
uint8_t *q;
prev = *allocated;
- q = greedy_realloc(p, allocated, need);
+ q = greedy_realloc(p, allocated, need, size);
if (!q)
return NULL;
if (*allocated > prev)
- memzero(&q[prev], *allocated - prev);
+ memzero(q + prev * size, (*allocated - prev) * size);
return q;
}
return 0;
}
-int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *root_fd) {
- _cleanup_close_ int pidnsfd = -1, mntnsfd = -1;
- const char *pidns, *mntns, *root;
- int rfd;
+int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
+ _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
+ int rfd = -1;
assert(pid >= 0);
- assert(pidns_fd);
- assert(mntns_fd);
- assert(root_fd);
- mntns = procfs_file_alloca(pid, "ns/mnt");
- mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
- if (mntnsfd < 0)
- return -errno;
+ if (mntns_fd) {
+ const char *mntns;
- pidns = procfs_file_alloca(pid, "ns/pid");
- pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
- if (pidnsfd < 0)
- return -errno;
+ mntns = procfs_file_alloca(pid, "ns/mnt");
+ mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
+ if (mntnsfd < 0)
+ return -errno;
+ }
- root = procfs_file_alloca(pid, "root");
- rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
- if (rfd < 0)
- return -errno;
+ if (pidns_fd) {
+ const char *pidns;
+
+ pidns = procfs_file_alloca(pid, "ns/pid");
+ pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
+ if (pidnsfd < 0)
+ return -errno;
+ }
+
+ if (netns_fd) {
+ const char *netns;
+
+ netns = procfs_file_alloca(pid, "ns/net");
+ netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
+ if (netnsfd < 0)
+ return -errno;
+ }
- *pidns_fd = pidnsfd;
- *mntns_fd = mntnsfd;
- *root_fd = rfd;
- pidnsfd = -1;
- mntnsfd = -1;
+ if (root_fd) {
+ const char *root;
+
+ root = procfs_file_alloca(pid, "root");
+ rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
+ if (rfd < 0)
+ return -errno;
+ }
+
+ if (pidns_fd)
+ *pidns_fd = pidnsfd;
+
+ if (mntns_fd)
+ *mntns_fd = mntnsfd;
+
+ if (netns_fd)
+ *netns_fd = netnsfd;
+
+ if (root_fd)
+ *root_fd = rfd;
+
+ pidnsfd = mntnsfd = netnsfd = -1;
return 0;
}
-int namespace_enter(int pidns_fd, int mntns_fd, int root_fd) {
- assert(pidns_fd >= 0);
- assert(mntns_fd >= 0);
- assert(root_fd >= 0);
+int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
- if (setns(pidns_fd, CLONE_NEWPID) < 0)
- return -errno;
+ if (pidns_fd >= 0)
+ if (setns(pidns_fd, CLONE_NEWPID) < 0)
+ return -errno;
- if (setns(mntns_fd, CLONE_NEWNS) < 0)
- return -errno;
+ if (mntns_fd >= 0)
+ if (setns(mntns_fd, CLONE_NEWNS) < 0)
+ return -errno;
- if (fchdir(root_fd) < 0)
- return -errno;
+ if (netns_fd >= 0)
+ if (setns(netns_fd, CLONE_NEWNET) < 0)
+ return -errno;
- if (chroot(".") < 0)
- return -errno;
+ if (root_fd >= 0) {
+ if (fchdir(root_fd) < 0)
+ return -errno;
+
+ if (chroot(".") < 0)
+ return -errno;
+ }
if (setresgid(0, 0, 0) < 0)
return -errno;
+ if (setgroups(0, NULL) < 0)
+ return -errno;
+
if (setresuid(0, 0, 0) < 0)
return -errno;
return hasmntopt(&me, needle);
}
+
+void hexdump(FILE *f, const void *p, size_t s) {
+ const uint8_t *b = p;
+ unsigned n = 0;
+
+ assert(s == 0 || b);
+
+ while (s > 0) {
+ size_t i;
+
+ fprintf(f, "%04x ", n);
+
+ for (i = 0; i < 16; i++) {
+
+ if (i >= s)
+ fputs(" ", f);
+ else
+ fprintf(f, "%02x ", b[i]);
+
+ if (i == 7)
+ fputc(' ', f);
+ }
+
+ fputc(' ', f);
+
+ for (i = 0; i < 16; i++) {
+
+ if (i >= s)
+ fputc(' ', f);
+ else
+ fputc(isprint(b[i]) ? (char) b[i] : '.', f);
+ }
+
+ fputc('\n', f);
+
+ if (s < 16)
+ break;
+
+ n += 16;
+ b += 16;
+ s -= 16;
+ }
+}
+
+int update_reboot_param_file(const char *param)
+{
+ int r = 0;
+
+ if (param) {
+
+ r = write_string_file(REBOOT_PARAM_FILE, param);
+ if (r < 0)
+ log_error("Failed to write reboot param to "
+ REBOOT_PARAM_FILE": %s", strerror(-r));
+ } else
+ unlink(REBOOT_PARAM_FILE);
+
+ return r;
+}
~ianmdlvl / elogind.git / blobdiff