implement proper logging for services

[elogind.git] / execute.c

diff --git a/execute.c b/execute.c
index 5def5ce1af5c8a553867168d9721ff3a1510852e..ccf951a25a437974f681ca0d12763237dfe9839c 100644 (file)
--- a/execute.c
+++ b/execute.c
@@ -6,6 +6,9 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <string.h>
+#include <signal.h>
+#include <sys/socket.h>
+#include <sys/un.h>
 
 #include "execute.h"
 #include "strv.h"
@@ -104,6 +107,146 @@ static int shift_fds(int fds[], unsigned n_fds) {
         return 0;
 }
 
+static int flags_fds(int fds[], unsigned n_fds) {
+        unsigned i;
+
+        if (n_fds <= 0)
+                return 0;
+
+        assert(fds);
+
+        /* Drops O_NONBLOCK and FD_CLOEXEC from the file flags */
+
+        for (i = 0; i < n_fds; i++) {
+                int flags;
+
+                if ((flags = fcntl(fds[i], F_GETFL, 0)) < 0)
+                        return -errno;
+
+                /* Since we are at it, let's make sure that nobody
+                 * forgot setting O_NONBLOCK for all our fds */
+
+                if (fcntl(fds[i], F_SETFL, flags &~O_NONBLOCK) < 0)
+                        return -errno;
+
+                if ((flags = fcntl(fds[i], F_GETFD, 0)) < 0)
+                        return -errno;
+
+                /* Also make sure nobody forgot O_CLOEXEC for all our
+                 * fds */
+                if (fcntl(fds[i], F_SETFD, flags &~FD_CLOEXEC) < 0)
+                        return -errno;
+        }
+
+        return 0;
+}
+
+static int replace_null_fd(int fd, int flags) {
+        int nfd;
+        assert(fd >= 0);
+
+        close_nointr(fd);
+
+        if ((nfd = open("/dev/null", flags|O_NOCTTY)) < 0)
+                return -errno;
+
+        if (nfd != fd) {
+                close_nointr_nofail(nfd);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int setup_output(const ExecContext *context, const char *ident) {
+        int r;
+
+        assert(context);
+
+        switch (context->output) {
+
+        case EXEC_CONSOLE:
+                return 0;
+
+        case EXEC_NULL:
+
+                if ((r = replace_null_fd(STDIN_FILENO, O_RDONLY)) < 0 ||
+                    (r = replace_null_fd(STDOUT_FILENO, O_WRONLY)) < 0 ||
+                    (r = replace_null_fd(STDERR_FILENO, O_WRONLY)) < 0)
+                        return r;
+
+                return 0;
+
+        case EXEC_KERNEL:
+        case EXEC_SYSLOG: {
+
+                int fd;
+                union {
+                        struct sockaddr sa;
+                        struct sockaddr_un un;
+                } sa;
+
+                if ((r = replace_null_fd(STDIN_FILENO, O_RDONLY)) < 0)
+                        return r;
+
+                close_nointr(STDOUT_FILENO);
+                close_nointr(STDERR_FILENO);
+
+                if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
+                        return -errno;
+
+                if (fd != STDOUT_FILENO) {
+                        close_nointr_nofail(fd);
+                        return -EIO;
+                }
+
+                zero(sa);
+                sa.sa.sa_family = AF_UNIX;
+                strncpy(sa.un.sun_path+1, LOGGER_SOCKET, sizeof(sa.un.sun_path)-1);
+
+                if (connect(fd, &sa.sa, sizeof(sa)) < 0) {
+                        close_nointr_nofail(fd);
+                        return -errno;
+                }
+
+                if (shutdown(fd, SHUT_RD) < 0) {
+                        close_nointr_nofail(fd);
+                        return -errno;
+                }
+
+                if ((fd = dup(fd)) < 0) {
+                        close_nointr_nofail(fd);
+                        return -errno;
+                }
+
+                if (fd != STDERR_FILENO) {
+                        close_nointr_nofail(fd);
+                        return -EIO;
+                }
+
+                /* We speak a very simple protocol between log server
+                 * and client: one line for the log destination (kmsg
+                 * or syslog), followed by the priority field,
+                 * followed by the process name. Since we replaced
+                 * stdin/stderr we simple use stdio to write to
+                 * it. Note that we use stderr, to minimize buffer
+                 * flushing issues. */
+
+                fprintf(stderr,
+                        "%s\n"
+                        "%i\n"
+                        "%s\n",
+                        context->output == EXEC_KERNEL ? "kmsg" : "syslog",
+                        context->syslog_priority,
+                        context->syslog_identifier ? context->syslog_identifier : ident);
+
+                return 0;
+        }
+        }
+
+        assert_not_reached("Unknown logging type");
+}
+
 int exec_spawn(const ExecCommand *command, const ExecContext *context, int *fds, unsigned n_fds, pid_t *ret) {
         pid_t pid;
 
@@ -121,8 +264,16 @@ int exec_spawn(const ExecCommand *command, const ExecContext *context, int *fds,
                 char **e, **f = NULL;
                 int i, r;
                 char t[16];
+                sigset_t ss;
+
                 /* child */
 
+                if (sigemptyset(&ss) < 0 ||
+                    sigprocmask(SIG_SETMASK, &ss, NULL) < 0) {
+                        r = EXIT_SIGNAL_MASK;
+                        goto fail;
+                }
+
                 umask(context->umask);
 
                 if (chdir(context->directory ? context->directory : "/") < 0) {
@@ -130,6 +281,11 @@ int exec_spawn(const ExecCommand *command, const ExecContext *context, int *fds,
                         goto fail;
                 }
 
+                if (setup_output(context, file_name_from_path(command->path)) < 0) {
+                        r = EXIT_OUTPUT;
+                        goto fail;
+                }
+
                 snprintf(t, sizeof(t), "%i", context->oom_adjust);
                 char_array_0(t);
 
@@ -144,7 +300,8 @@ int exec_spawn(const ExecCommand *command, const ExecContext *context, int *fds,
                 }
 
                 if (close_fds(fds, n_fds) < 0 ||
-                    shift_fds(fds, n_fds) < 0) {
+                    shift_fds(fds, n_fds) < 0 ||
+                    flags_fds(fds, n_fds) < 0) {
                         r = EXIT_FDS;
                         goto fail;
                 }
@@ -207,6 +364,9 @@ void exec_context_init(ExecContext *c) {
         cap_clear(c->capabilities);
         c->oom_adjust = 0;
         c->nice = 0;
+
+        c->output = 0;
+        c->syslog_priority = LOG_DAEMON|LOG_INFO;
 }
 
 void exec_context_done(ExecContext *c) {
@@ -225,6 +385,9 @@ void exec_context_done(ExecContext *c) {
         free(c->directory);
         c->directory = NULL;
 
+        free(c->syslog_identifier);
+        c->syslog_identifier = NULL;
+
         free(c->user);
         c->user = NULL;