[thirdparty/systemd.git] / src / journal / journald-stream.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <fcntl.h>
#include <unistd.h>
#include <stddef.h>

#ifdef HAVE_SELINUX
#include <selinux/selinux.h>
#endif

#include "sd-event.h"
#include "socket-util.h"
#include "selinux-util.h"
#include "journald-server.h"
#include "journald-stream.h"
#include "journald-syslog.h"
#include "journald-kmsg.h"
#include "journald-console.h"

#define STDOUT_STREAMS_MAX 4096

typedef enum StdoutStreamState {
        STDOUT_STREAM_IDENTIFIER,
        STDOUT_STREAM_UNIT_ID,
        STDOUT_STREAM_PRIORITY,
        STDOUT_STREAM_LEVEL_PREFIX,
        STDOUT_STREAM_FORWARD_TO_SYSLOG,
        STDOUT_STREAM_FORWARD_TO_KMSG,
        STDOUT_STREAM_FORWARD_TO_CONSOLE,
        STDOUT_STREAM_RUNNING
} StdoutStreamState;

struct StdoutStream {
        Server *server;
        StdoutStreamState state;

        int fd;

        struct ucred ucred;
#ifdef HAVE_SELINUX
        security_context_t security_context;
#endif

        char *identifier;
        char *unit_id;
        int priority;
        bool level_prefix:1;
        bool forward_to_syslog:1;
        bool forward_to_kmsg:1;
        bool forward_to_console:1;

        char buffer[LINE_MAX+1];
        size_t length;

        sd_event_source *event_source;

        LIST_FIELDS(StdoutStream, stdout_stream);
};

static int stdout_stream_log(StdoutStream *s, const char *p) {
        struct iovec iovec[N_IOVEC_META_FIELDS + 5];
        int priority;
        char syslog_priority[] = "PRIORITY=\0";
        char syslog_facility[sizeof("SYSLOG_FACILITY=") + DECIMAL_STR_MAX(priority)];
        _cleanup_free_ char *message = NULL, *syslog_identifier = NULL;
        unsigned n = 0;
        char *label = NULL;
        size_t label_len = 0;

        assert(s);
        assert(p);

        if (isempty(p))
                return 0;

        priority = s->priority;

        if (s->level_prefix)
                syslog_parse_priority(&p, &priority, false);

        if (s->forward_to_syslog || s->server->forward_to_syslog)
                server_forward_syslog(s->server, syslog_fixup_facility(priority), s->identifier, p, &s->ucred, NULL);

        if (s->forward_to_kmsg || s->server->forward_to_kmsg)
                server_forward_kmsg(s->server, priority, s->identifier, p, &s->ucred);

        if (s->forward_to_console || s->server->forward_to_console)
                server_forward_console(s->server, priority, s->identifier, p, &s->ucred);

        IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=stdout");

        syslog_priority[strlen("PRIORITY=")] = '0' + LOG_PRI(priority);
        IOVEC_SET_STRING(iovec[n++], syslog_priority);

        if (priority & LOG_FACMASK) {
                snprintf(syslog_facility, sizeof(syslog_facility), "SYSLOG_FACILITY=%i", LOG_FAC(priority));
                IOVEC_SET_STRING(iovec[n++], syslog_facility);
        }

        if (s->identifier) {
                syslog_identifier = strappend("SYSLOG_IDENTIFIER=", s->identifier);
                if (syslog_identifier)
                        IOVEC_SET_STRING(iovec[n++], syslog_identifier);
        }

        message = strappend("MESSAGE=", p);
        if (message)
                IOVEC_SET_STRING(iovec[n++], message);

#ifdef HAVE_SELINUX
        if (s->security_context) {
                label = (char*) s->security_context;
                label_len = strlen((char*) s->security_context);
        }
#endif

        server_dispatch_message(s->server, iovec, n, ELEMENTSOF(iovec), &s->ucred, NULL, label, label_len, s->unit_id, priority, 0);
        return 0;
}

static int stdout_stream_line(StdoutStream *s, char *p) {
        int r;

        assert(s);
        assert(p);

        p = strstrip(p);

        switch (s->state) {

        case STDOUT_STREAM_IDENTIFIER:
                if (isempty(p))
                        s->identifier = NULL;
                else  {
                        s->identifier = strdup(p);
                        if (!s->identifier)
                                return log_oom();
                }

                s->state = STDOUT_STREAM_UNIT_ID;
                return 0;

        case STDOUT_STREAM_UNIT_ID:
                if (s->ucred.uid == 0) {
                        if (isempty(p))
                                s->unit_id = NULL;
                        else  {
                                s->unit_id = strdup(p);
                                if (!s->unit_id)
                                        return log_oom();
                        }
                }

                s->state = STDOUT_STREAM_PRIORITY;
                return 0;

        case STDOUT_STREAM_PRIORITY:
                r = safe_atoi(p, &s->priority);
                if (r < 0 || s->priority < 0 || s->priority > 999) {
                        log_warning("Failed to parse log priority line.");
                        return -EINVAL;
                }

                s->state = STDOUT_STREAM_LEVEL_PREFIX;
                return 0;

        case STDOUT_STREAM_LEVEL_PREFIX:
                r = parse_boolean(p);
                if (r < 0) {
                        log_warning("Failed to parse level prefix line.");
                        return -EINVAL;
                }

                s->level_prefix = !!r;
                s->state = STDOUT_STREAM_FORWARD_TO_SYSLOG;
                return 0;

        case STDOUT_STREAM_FORWARD_TO_SYSLOG:
                r = parse_boolean(p);
                if (r < 0) {
                        log_warning("Failed to parse forward to syslog line.");
                        return -EINVAL;
                }

                s->forward_to_syslog = !!r;
                s->state = STDOUT_STREAM_FORWARD_TO_KMSG;
                return 0;

        case STDOUT_STREAM_FORWARD_TO_KMSG:
                r = parse_boolean(p);
                if (r < 0) {
                        log_warning("Failed to parse copy to kmsg line.");
                        return -EINVAL;
                }

                s->forward_to_kmsg = !!r;
                s->state = STDOUT_STREAM_FORWARD_TO_CONSOLE;
                return 0;

        case STDOUT_STREAM_FORWARD_TO_CONSOLE:
                r = parse_boolean(p);
                if (r < 0) {
                        log_warning("Failed to parse copy to console line.");
                        return -EINVAL;
                }

                s->forward_to_console = !!r;
                s->state = STDOUT_STREAM_RUNNING;
                return 0;

        case STDOUT_STREAM_RUNNING:
                return stdout_stream_log(s, p);
        }

        assert_not_reached("Unknown stream state");
}

static int stdout_stream_scan(StdoutStream *s, bool force_flush) {
        char *p;
        size_t remaining;
        int r;

        assert(s);

        p = s->buffer;
        remaining = s->length;
        for (;;) {
                char *end;
                size_t skip;

                end = memchr(p, '\n', remaining);
                if (end)
                        skip = end - p + 1;
                else if (remaining >= sizeof(s->buffer) - 1) {
                        end = p + sizeof(s->buffer) - 1;
                        skip = remaining;
                } else
                        break;

                *end = 0;

                r = stdout_stream_line(s, p);
                if (r < 0)
                        return r;

                remaining -= skip;
                p += skip;
        }

        if (force_flush && remaining > 0) {
                p[remaining] = 0;
                r = stdout_stream_line(s, p);
                if (r < 0)
                        return r;

                p += remaining;
                remaining = 0;
        }

        if (p > s->buffer) {
                memmove(s->buffer, p, remaining);
                s->length = remaining;
        }

        return 0;
}

static int stdout_stream_process(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
        StdoutStream *s = userdata;
        ssize_t l;
        int r;

        assert(s);

        if ((revents|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
                log_error("Got invalid event from epoll for stdout stream: %"PRIx32, revents);
                goto terminate;
        }

        l = read(s->fd, s->buffer+s->length, sizeof(s->buffer)-1-s->length);
        if (l < 0) {

                if (errno == EAGAIN)
                        return 0;

                log_warning("Failed to read from stream: %m");
                goto terminate;
        }

        if (l == 0) {
                stdout_stream_scan(s, true);
                goto terminate;
        }

        s->length += l;
        r = stdout_stream_scan(s, false);
        if (r < 0)
                goto terminate;

        return 1;

terminate:
        stdout_stream_free(s);
        return 0;
}

void stdout_stream_free(StdoutStream *s) {
        assert(s);

        if (s->server) {
                assert(s->server->n_stdout_streams > 0);
                s->server->n_stdout_streams --;
                LIST_REMOVE(stdout_stream, s->server->stdout_streams, s);
        }

        if (s->event_source) {
                sd_event_source_set_enabled(s->event_source, SD_EVENT_OFF);
                s->event_source = sd_event_source_unref(s->event_source);
        }

        if (s->fd >= 0)
                close_nointr_nofail(s->fd);

#ifdef HAVE_SELINUX
        if (s->security_context)
                freecon(s->security_context);
#endif

        free(s->identifier);
        free(s->unit_id);
        free(s);
}

static int stdout_stream_new(sd_event_source *es, int listen_fd, uint32_t revents, void *userdata) {
        Server *s = userdata;
        StdoutStream *stream;
        int fd, r;

        assert(s);

        if (revents != EPOLLIN) {
                log_error("Got invalid event from epoll for stdout server fd: %"PRIx32, revents);
                return -EIO;
        }

        fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
        if (fd < 0) {
                if (errno == EAGAIN)
                        return 0;

                log_error("Failed to accept stdout connection: %m");
                return -errno;
        }

        if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) {
                log_warning("Too many stdout streams, refusing connection.");
                close_nointr_nofail(fd);
                return 0;
        }

        stream = new0(StdoutStream, 1);
        if (!stream) {
                close_nointr_nofail(fd);
                return log_oom();
        }

        stream->fd = fd;

        r = getpeercred(fd, &stream->ucred);
        if (r < 0) {
                log_error("Failed to determine peer credentials: %m");
                goto fail;
        }

#ifdef HAVE_SELINUX
        if (use_selinux()) {
                if (getpeercon(fd, &stream->security_context) < 0 && errno != ENOPROTOOPT)
                        log_error("Failed to determine peer security context: %m");
        }
#endif

        if (shutdown(fd, SHUT_WR) < 0) {
                log_error("Failed to shutdown writing side of socket: %m");
                goto fail;
        }

        r = sd_event_add_io(s->event, &stream->event_source, fd, EPOLLIN, stdout_stream_process, stream);
        if (r < 0) {
                log_error("Failed to add stream to event loop: %s", strerror(-r));
                goto fail;
        }

        r = sd_event_source_set_priority(stream->event_source, SD_EVENT_PRIORITY_NORMAL+5);
        if (r < 0) {
                log_error("Failed to adjust stdout event source priority: %s", strerror(-r));
                goto fail;
        }

        stream->server = s;
        LIST_PREPEND(stdout_stream, s->stdout_streams, stream);
        s->n_stdout_streams ++;

        return 0;

fail:
        stdout_stream_free(stream);
        return 0;
}

int server_open_stdout_socket(Server *s) {
        int r;

        assert(s);

        if (s->stdout_fd < 0) {
                union sockaddr_union sa = {
                        .un.sun_family = AF_UNIX,
                        .un.sun_path = "/run/systemd/journal/stdout",
                };

                s->stdout_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
                if (s->stdout_fd < 0) {
                        log_error("socket() failed: %m");
                        return -errno;
                }

                unlink(sa.un.sun_path);

                r = bind(s->stdout_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
                if (r < 0) {
                        log_error("bind() failed: %m");
                        return -errno;
                }

                chmod(sa.un.sun_path, 0666);

                if (listen(s->stdout_fd, SOMAXCONN) < 0) {
                        log_error("listen() failed: %m");
                        return -errno;
                }
        } else
                fd_nonblock(s->stdout_fd, 1);

        r = sd_event_add_io(s->event, &s->stdout_event_source, s->stdout_fd, EPOLLIN, stdout_stream_new, s);
        if (r < 0) {
                log_error("Failed to add stdout server fd to event source: %s", strerror(-r));
                return r;
        }

        r = sd_event_source_set_priority(s->stdout_event_source, SD_EVENT_PRIORITY_NORMAL+10);
        if (r < 0) {
                log_error("Failed to adjust priority of stdout server event source: %s", strerror(-r));
                return r;
        }

        return 0;
}
Commit	Line	Data
a45b9fca LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2011 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <fcntl.h>
	23	#include <unistd.h>
4871690d	24	#include <stddef.h>
a45b9fca LP	25
	26	#ifdef HAVE_SELINUX
	27	#include <selinux/selinux.h>
	28	#endif
	29
f9a810be	30	#include "sd-event.h"
a45b9fca	31	#include "socket-util.h"
d682b3a7	32	#include "selinux-util.h"
d025f1e4	33	#include "journald-server.h"
a45b9fca LP	34	#include "journald-stream.h"
	35	#include "journald-syslog.h"
	36	#include "journald-kmsg.h"
3b7124a8	37	#include "journald-console.h"
a45b9fca LP	38
	39	#define STDOUT_STREAMS_MAX 4096
	40
	41	typedef enum StdoutStreamState {
	42	STDOUT_STREAM_IDENTIFIER,
	43	STDOUT_STREAM_UNIT_ID,
	44	STDOUT_STREAM_PRIORITY,
	45	STDOUT_STREAM_LEVEL_PREFIX,
	46	STDOUT_STREAM_FORWARD_TO_SYSLOG,
	47	STDOUT_STREAM_FORWARD_TO_KMSG,
	48	STDOUT_STREAM_FORWARD_TO_CONSOLE,
	49	STDOUT_STREAM_RUNNING
	50	} StdoutStreamState;
	51
	52	struct StdoutStream {
	53	Server *server;
	54	StdoutStreamState state;
	55
	56	int fd;
	57
	58	struct ucred ucred;
	59	#ifdef HAVE_SELINUX
	60	security_context_t security_context;
	61	#endif
	62
	63	char *identifier;
	64	char *unit_id;
	65	int priority;
	66	bool level_prefix:1;
	67	bool forward_to_syslog:1;
	68	bool forward_to_kmsg:1;
	69	bool forward_to_console:1;
	70
	71	char buffer[LINE_MAX+1];
	72	size_t length;
	73
f9a810be LP	74	sd_event_source *event_source;
f9a810be LP	75
a45b9fca LP	76	LIST_FIELDS(StdoutStream, stdout_stream);
	77	};
	78
	79	static int stdout_stream_log(StdoutStream s, const char p) {
	80	struct iovec iovec[N_IOVEC_META_FIELDS + 5];
a45b9fca	81	int priority;
e3bfb7be ZJS	82	char syslog_priority[] = "PRIORITY=\0";
	83	char syslog_facility[sizeof("SYSLOG_FACILITY=") + DECIMAL_STR_MAX(priority)];
	84	_cleanup_free_ char message = NULL, syslog_identifier = NULL;
	85	unsigned n = 0;
a45b9fca LP	86	char *label = NULL;
	87	size_t label_len = 0;
	88
	89	assert(s);
	90	assert(p);
	91
	92	if (isempty(p))
	93	return 0;
	94
	95	priority = s->priority;
	96
	97	if (s->level_prefix)
e3bfb7be	98	syslog_parse_priority(&p, &priority, false);
a45b9fca LP	99
	100	if (s->forward_to_syslog \|\| s->server->forward_to_syslog)
	101	server_forward_syslog(s->server, syslog_fixup_facility(priority), s->identifier, p, &s->ucred, NULL);
	102
	103	if (s->forward_to_kmsg \|\| s->server->forward_to_kmsg)
	104	server_forward_kmsg(s->server, priority, s->identifier, p, &s->ucred);
	105
	106	if (s->forward_to_console \|\| s->server->forward_to_console)
	107	server_forward_console(s->server, priority, s->identifier, p, &s->ucred);
	108
	109	IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=stdout");
	110
e3bfb7be ZJS	111	syslog_priority[strlen("PRIORITY=")] = '0' + LOG_PRI(priority);
e3bfb7be ZJS	112	IOVEC_SET_STRING(iovec[n++], syslog_priority);
a45b9fca	113
e3bfb7be ZJS	114	if (priority & LOG_FACMASK) {
	115	snprintf(syslog_facility, sizeof(syslog_facility), "SYSLOG_FACILITY=%i", LOG_FAC(priority));
	116	IOVEC_SET_STRING(iovec[n++], syslog_facility);
	117	}
a45b9fca LP	118
	119	if (s->identifier) {
	120	syslog_identifier = strappend("SYSLOG_IDENTIFIER=", s->identifier);
	121	if (syslog_identifier)
	122	IOVEC_SET_STRING(iovec[n++], syslog_identifier);
	123	}
	124
	125	message = strappend("MESSAGE=", p);
	126	if (message)
	127	IOVEC_SET_STRING(iovec[n++], message);
	128
	129	#ifdef HAVE_SELINUX
	130	if (s->security_context) {
	131	label = (char*) s->security_context;
	132	label_len = strlen((char*) s->security_context);
	133	}
	134	#endif
	135
968f3196	136	server_dispatch_message(s->server, iovec, n, ELEMENTSOF(iovec), &s->ucred, NULL, label, label_len, s->unit_id, priority, 0);
a45b9fca LP	137	return 0;
	138	}
	139
	140	static int stdout_stream_line(StdoutStream s, char p) {
	141	int r;
	142
	143	assert(s);
	144	assert(p);
	145
	146	p = strstrip(p);
	147
	148	switch (s->state) {
	149
	150	case STDOUT_STREAM_IDENTIFIER:
	151	if (isempty(p))
	152	s->identifier = NULL;
	153	else {
	154	s->identifier = strdup(p);
	155	if (!s->identifier)
	156	return log_oom();
	157	}
	158
	159	s->state = STDOUT_STREAM_UNIT_ID;
	160	return 0;
	161
	162	case STDOUT_STREAM_UNIT_ID:
	163	if (s->ucred.uid == 0) {
	164	if (isempty(p))
	165	s->unit_id = NULL;
	166	else {
	167	s->unit_id = strdup(p);
	168	if (!s->unit_id)
	169	return log_oom();
	170	}
	171	}
	172
	173	s->state = STDOUT_STREAM_PRIORITY;
	174	return 0;
	175
	176	case STDOUT_STREAM_PRIORITY:
	177	r = safe_atoi(p, &s->priority);
41891700	178	if (r < 0 \|\| s->priority < 0 \|\| s->priority > 999) {
a45b9fca LP	179	log_warning("Failed to parse log priority line.");
	180	return -EINVAL;
	181	}
	182
	183	s->state = STDOUT_STREAM_LEVEL_PREFIX;
	184	return 0;
	185
	186	case STDOUT_STREAM_LEVEL_PREFIX:
	187	r = parse_boolean(p);
	188	if (r < 0) {
	189	log_warning("Failed to parse level prefix line.");
	190	return -EINVAL;
	191	}
	192
	193	s->level_prefix = !!r;
	194	s->state = STDOUT_STREAM_FORWARD_TO_SYSLOG;
	195	return 0;
	196
	197	case STDOUT_STREAM_FORWARD_TO_SYSLOG:
	198	r = parse_boolean(p);
	199	if (r < 0) {
	200	log_warning("Failed to parse forward to syslog line.");
	201	return -EINVAL;
	202	}
	203
	204	s->forward_to_syslog = !!r;
	205	s->state = STDOUT_STREAM_FORWARD_TO_KMSG;
	206	return 0;
	207
	208	case STDOUT_STREAM_FORWARD_TO_KMSG:
	209	r = parse_boolean(p);
	210	if (r < 0) {
	211	log_warning("Failed to parse copy to kmsg line.");
	212	return -EINVAL;
	213	}
	214
	215	s->forward_to_kmsg = !!r;
	216	s->state = STDOUT_STREAM_FORWARD_TO_CONSOLE;
	217	return 0;
	218
	219	case STDOUT_STREAM_FORWARD_TO_CONSOLE:
	220	r = parse_boolean(p);
	221	if (r < 0) {
	222	log_warning("Failed to parse copy to console line.");
	223	return -EINVAL;
	224	}
	225
	226	s->forward_to_console = !!r;
	227	s->state = STDOUT_STREAM_RUNNING;
	228	return 0;
	229
	230	case STDOUT_STREAM_RUNNING:
	231	return stdout_stream_log(s, p);
	232	}
	233
	234	assert_not_reached("Unknown stream state");
	235	}
	236
	237	static int stdout_stream_scan(StdoutStream *s, bool force_flush) {
	238	char *p;
	239	size_t remaining;
	240	int r;
	241
	242	assert(s);
243
244	p = s->buffer;
245	remaining = s->length;
246	for (;;) {
247	char *end;
248	size_t skip;
249
250	end = memchr(p, '\n', remaining);
251	if (end)
252	skip = end - p + 1;
253	else if (remaining >= sizeof(s->buffer) - 1) {
254	end = p + sizeof(s->buffer) - 1;
255	skip = remaining;
256	} else
257	break;
258
259	*end = 0;
260
261	r = stdout_stream_line(s, p);
262	if (r < 0)
263	return r;
264
265	remaining -= skip;
266	p += skip;
267	}
268
269	if (force_flush && remaining > 0) {
270	p[remaining] = 0;
271	r = stdout_stream_line(s, p);
272	if (r < 0)
273	return r;
274
275	p += remaining;
276	remaining = 0;
277	}
278
279	if (p > s->buffer) {
280	memmove(s->buffer, p, remaining);
281	s->length = remaining;
282	}
283
284	return 0;
285	}
286
f9a810be LP	287	static int stdout_stream_process(sd_event_source es, int fd, uint32_t revents, void userdata) {
f9a810be LP	288	StdoutStream *s = userdata;
a45b9fca LP	289	ssize_t l;
	290	int r;
	291
	292	assert(s);
	293
f9a810be LP	294	if ((revents\|EPOLLIN\|EPOLLHUP) != (EPOLLIN\|EPOLLHUP)) {
f9a810be LP	295	log_error("Got invalid event from epoll for stdout stream: %"PRIx32, revents);
91bf3b3e	296	goto terminate;
f9a810be LP	297	}
f9a810be LP	298
a45b9fca LP	299	l = read(s->fd, s->buffer+s->length, sizeof(s->buffer)-1-s->length);
	300	if (l < 0) {
	301
	302	if (errno == EAGAIN)
	303	return 0;
	304
	305	log_warning("Failed to read from stream: %m");
91bf3b3e	306	goto terminate;
a45b9fca LP	307	}
	308
	309	if (l == 0) {
7b77ed8c	310	stdout_stream_scan(s, true);
91bf3b3e	311	goto terminate;
a45b9fca LP	312	}
	313
	314	s->length += l;
	315	r = stdout_stream_scan(s, false);
	316	if (r < 0)
91bf3b3e	317	goto terminate;
a45b9fca LP	318
	319	return 1;
	320
91bf3b3e	321	terminate:
f9a810be LP	322	stdout_stream_free(s);
f9a810be LP	323	return 0;
a45b9fca LP	324	}
	325
	326	void stdout_stream_free(StdoutStream *s) {
	327	assert(s);
	328
	329	if (s->server) {
	330	assert(s->server->n_stdout_streams > 0);
	331	s->server->n_stdout_streams --;
71fda00f	332	LIST_REMOVE(stdout_stream, s->server->stdout_streams, s);
a45b9fca LP	333	}
a45b9fca LP	334
21c6dc33 LP	335	if (s->event_source) {
21c6dc33 LP	336	sd_event_source_set_enabled(s->event_source, SD_EVENT_OFF);
f9a810be	337	s->event_source = sd_event_source_unref(s->event_source);
21c6dc33	338	}
a45b9fca	339
f9a810be	340	if (s->fd >= 0)
a45b9fca	341	close_nointr_nofail(s->fd);
a45b9fca LP	342
	343	#ifdef HAVE_SELINUX
	344	if (s->security_context)
	345	freecon(s->security_context);
	346	#endif
	347
	348	free(s->identifier);
f92ae496	349	free(s->unit_id);
a45b9fca LP	350	free(s);
	351	}
	352
f9a810be LP	353	static int stdout_stream_new(sd_event_source es, int listen_fd, uint32_t revents, void userdata) {
f9a810be LP	354	Server *s = userdata;
a45b9fca LP	355	StdoutStream *stream;
a45b9fca LP	356	int fd, r;
a45b9fca LP	357
	358	assert(s);
	359
f9a810be LP	360	if (revents != EPOLLIN) {
	361	log_error("Got invalid event from epoll for stdout server fd: %"PRIx32, revents);
	362	return -EIO;
	363	}
	364
a45b9fca LP	365	fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK\|SOCK_CLOEXEC);
	366	if (fd < 0) {
	367	if (errno == EAGAIN)
	368	return 0;
	369
	370	log_error("Failed to accept stdout connection: %m");
	371	return -errno;
	372	}
	373
	374	if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) {
	375	log_warning("Too many stdout streams, refusing connection.");
	376	close_nointr_nofail(fd);
	377	return 0;
	378	}
	379
	380	stream = new0(StdoutStream, 1);
	381	if (!stream) {
	382	close_nointr_nofail(fd);
	383	return log_oom();
	384	}
	385
	386	stream->fd = fd;
	387
eff05270 LP	388	r = getpeercred(fd, &stream->ucred);
eff05270 LP	389	if (r < 0) {
a45b9fca	390	log_error("Failed to determine peer credentials: %m");
a45b9fca LP	391	goto fail;
	392	}
	393
	394	#ifdef HAVE_SELINUX
d682b3a7 LP	395	if (use_selinux()) {
	396	if (getpeercon(fd, &stream->security_context) < 0 && errno != ENOPROTOOPT)
	397	log_error("Failed to determine peer security context: %m");
	398	}
a45b9fca LP	399	#endif
	400
	401	if (shutdown(fd, SHUT_WR) < 0) {
	402	log_error("Failed to shutdown writing side of socket: %m");
a45b9fca LP	403	goto fail;
	404	}
	405
151b9b96	406	r = sd_event_add_io(s->event, &stream->event_source, fd, EPOLLIN, stdout_stream_process, stream);
f9a810be LP	407	if (r < 0) {
	408	log_error("Failed to add stream to event loop: %s", strerror(-r));
	409	goto fail;
	410	}
	411
	412	r = sd_event_source_set_priority(stream->event_source, SD_EVENT_PRIORITY_NORMAL+5);
	413	if (r < 0) {
	414	log_error("Failed to adjust stdout event source priority: %s", strerror(-r));
a45b9fca LP	415	goto fail;
	416	}
	417
	418	stream->server = s;
71fda00f	419	LIST_PREPEND(stdout_stream, s->stdout_streams, stream);
a45b9fca LP	420	s->n_stdout_streams ++;
	421
	422	return 0;
	423
	424	fail:
	425	stdout_stream_free(stream);
7b77ed8c	426	return 0;
a45b9fca LP	427	}
	428
	429	int server_open_stdout_socket(Server *s) {
a45b9fca	430	int r;
a45b9fca LP	431
	432	assert(s);
	433
	434	if (s->stdout_fd < 0) {
b92bea5d ZJS	435	union sockaddr_union sa = {
	436	.un.sun_family = AF_UNIX,
	437	.un.sun_path = "/run/systemd/journal/stdout",
	438	};
a45b9fca LP	439
	440	s->stdout_fd = socket(AF_UNIX, SOCK_STREAM\|SOCK_CLOEXEC\|SOCK_NONBLOCK, 0);
	441	if (s->stdout_fd < 0) {
	442	log_error("socket() failed: %m");
	443	return -errno;
	444	}
	445
a45b9fca LP	446	unlink(sa.un.sun_path);
	447
	448	r = bind(s->stdout_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
	449	if (r < 0) {
	450	log_error("bind() failed: %m");
	451	return -errno;
	452	}
	453
	454	chmod(sa.un.sun_path, 0666);
	455
	456	if (listen(s->stdout_fd, SOMAXCONN) < 0) {
8060a8b3	457	log_error("listen() failed: %m");
a45b9fca LP	458	return -errno;
	459	}
	460	} else
	461	fd_nonblock(s->stdout_fd, 1);
	462
151b9b96	463	r = sd_event_add_io(s->event, &s->stdout_event_source, s->stdout_fd, EPOLLIN, stdout_stream_new, s);
f9a810be LP	464	if (r < 0) {
	465	log_error("Failed to add stdout server fd to event source: %s", strerror(-r));
	466	return r;
	467	}
	468
	469	r = sd_event_source_set_priority(s->stdout_event_source, SD_EVENT_PRIORITY_NORMAL+10);
	470	if (r < 0) {
	471	log_error("Failed to adjust priority of stdout server event source: %s", strerror(-r));
	472	return r;
a45b9fca LP	473	}
	474
	475	return 0;
	476	}