[thirdparty/systemd.git] / src / journal / journald-syslog.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 <unistd.h>
#include <sys/epoll.h>

#include "socket-util.h"
#include "journald.h"
#include "journald-syslog.h"
#include "journald-kmsg.h"

static void forward_syslog_iovec(Server *s, const struct iovec *iovec, unsigned n_iovec, struct ucred *ucred, struct timeval *tv) {
        struct msghdr msghdr;
        struct cmsghdr *cmsg;
        union {
                struct cmsghdr cmsghdr;
                uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
        } control;
        union sockaddr_union sa;

        assert(s);
        assert(iovec);
        assert(n_iovec > 0);

        zero(msghdr);
        msghdr.msg_iov = (struct iovec*) iovec;
        msghdr.msg_iovlen = n_iovec;

        zero(sa);
        sa.un.sun_family = AF_UNIX;
        strncpy(sa.un.sun_path, "/run/systemd/journal/syslog", sizeof(sa.un.sun_path));
        msghdr.msg_name = &sa;
        msghdr.msg_namelen = offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path);

        if (ucred) {
                zero(control);
                msghdr.msg_control = &control;
                msghdr.msg_controllen = sizeof(control);

                cmsg = CMSG_FIRSTHDR(&msghdr);
                cmsg->cmsg_level = SOL_SOCKET;
                cmsg->cmsg_type = SCM_CREDENTIALS;
                cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
                memcpy(CMSG_DATA(cmsg), ucred, sizeof(struct ucred));
                msghdr.msg_controllen = cmsg->cmsg_len;
        }

        /* Forward the syslog message we received via /dev/log to
         * /run/systemd/syslog. Unfortunately we currently can't set
         * the SO_TIMESTAMP auxiliary data, and hence we don't. */

        if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
                return;

        /* The socket is full? I guess the syslog implementation is
         * too slow, and we shouldn't wait for that... */
        if (errno == EAGAIN)
                return;

        if (ucred && errno == ESRCH) {
                struct ucred u;

                /* Hmm, presumably the sender process vanished
                 * by now, so let's fix it as good as we
                 * can, and retry */

                u = *ucred;
                u.pid = getpid();
                memcpy(CMSG_DATA(cmsg), &u, sizeof(struct ucred));

                if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
                        return;

                if (errno == EAGAIN)
                        return;
        }

        if (errno != ENOENT)
                log_debug("Failed to forward syslog message: %m");
}

static void forward_syslog_raw(Server *s, int priority, const char *buffer, struct ucred *ucred, struct timeval *tv) {
        struct iovec iovec;

        assert(s);
        assert(buffer);

        if (LOG_PRI(priority) > s->max_level_syslog)
                return;

        IOVEC_SET_STRING(iovec, buffer);
        forward_syslog_iovec(s, &iovec, 1, ucred, tv);
}

void server_forward_syslog(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred, struct timeval *tv) {
        struct iovec iovec[5];
        char header_priority[6], header_time[64], header_pid[16];
        int n = 0;
        time_t t;
        struct tm *tm;
        char *ident_buf = NULL;

        assert(s);
        assert(priority >= 0);
        assert(priority <= 999);
        assert(message);

        if (LOG_PRI(priority) > s->max_level_syslog)
                return;

        /* First: priority field */
        snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
        char_array_0(header_priority);
        IOVEC_SET_STRING(iovec[n++], header_priority);

        /* Second: timestamp */
        t = tv ? tv->tv_sec : ((time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC));
        tm = localtime(&t);
        if (!tm)
                return;
        if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
                return;
        IOVEC_SET_STRING(iovec[n++], header_time);

        /* Third: identifier and PID */
        if (ucred) {
                if (!identifier) {
                        get_process_comm(ucred->pid, &ident_buf);
                        identifier = ident_buf;
                }

                snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
                char_array_0(header_pid);

                if (identifier)
                        IOVEC_SET_STRING(iovec[n++], identifier);

                IOVEC_SET_STRING(iovec[n++], header_pid);
        } else if (identifier) {
                IOVEC_SET_STRING(iovec[n++], identifier);
                IOVEC_SET_STRING(iovec[n++], ": ");
        }

        /* Fourth: message */
        IOVEC_SET_STRING(iovec[n++], message);

        forward_syslog_iovec(s, iovec, n, ucred, tv);

        free(ident_buf);
}

int syslog_fixup_facility(int priority) {

        if ((priority & LOG_FACMASK) == 0)
                return (priority & LOG_PRIMASK) | LOG_USER;

        return priority;
}

void syslog_read_identifier(const char **buf, char **identifier, char **pid) {
        const char *p;
        char *t;
        size_t l, e;

        assert(buf);
        assert(identifier);
        assert(pid);

        p = *buf;

        p += strspn(p, WHITESPACE);
        l = strcspn(p, WHITESPACE);

        if (l <= 0 ||
            p[l-1] != ':')
                return;

        e = l;
        l--;

        if (p[l-1] == ']') {
                size_t k = l-1;

                for (;;) {

                        if (p[k] == '[') {
                                t = strndup(p+k+1, l-k-2);
                                if (t)
                                        *pid = t;

                                l = k;
                                break;
                        }

                        if (k == 0)
                                break;

                        k--;
                }
        }

        t = strndup(p, l);
        if (t)
                *identifier = t;

        *buf = p + e;
        *buf += strspn(*buf, WHITESPACE);
}

void server_process_syslog_message(
        Server *s,
        const char *buf,
        struct ucred *ucred,
        struct timeval *tv,
        const char *label,
        size_t label_len) {

        char *message = NULL, *syslog_priority = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *syslog_pid = NULL;
        struct iovec iovec[N_IOVEC_META_FIELDS + 6];
        unsigned n = 0;
        int priority = LOG_USER | LOG_INFO;
        char *identifier = NULL, *pid = NULL;
        const char *orig;

        assert(s);
        assert(buf);

        orig = buf;
        syslog_parse_priority((char**) &buf, &priority);

        if (s->forward_to_syslog)
                forward_syslog_raw(s, priority, orig, ucred, tv);

        syslog_skip_date((char**) &buf);
        syslog_read_identifier(&buf, &identifier, &pid);

        if (s->forward_to_kmsg)
                server_forward_kmsg(s, priority, identifier, buf, ucred);

        if (s->forward_to_console)
                server_forward_console(s, priority, identifier, buf, ucred);

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

        if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
                IOVEC_SET_STRING(iovec[n++], syslog_priority);

        if (priority & LOG_FACMASK)
                if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
                        IOVEC_SET_STRING(iovec[n++], syslog_facility);

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

        if (pid) {
                syslog_pid = strappend("SYSLOG_PID=", pid);
                if (syslog_pid)
                        IOVEC_SET_STRING(iovec[n++], syslog_pid);
        }

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

        server_dispatch_message(s, iovec, n, ELEMENTSOF(iovec), ucred, tv, label, label_len, NULL, priority);

        free(message);
        free(identifier);
        free(pid);
        free(syslog_priority);
        free(syslog_facility);
        free(syslog_identifier);
        free(syslog_pid);
}

int server_open_syslog_socket(Server *s) {
        union sockaddr_union sa;
        int one, r;
        struct epoll_event ev;

        assert(s);

        if (s->syslog_fd < 0) {

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

                zero(sa);
                sa.un.sun_family = AF_UNIX;
                strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));

                unlink(sa.un.sun_path);

                r = bind(s->syslog_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);
        } else
                fd_nonblock(s->syslog_fd, 1);

        one = 1;
        r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
        if (r < 0) {
                log_error("SO_PASSCRED failed: %m");
                return -errno;
        }

#ifdef HAVE_SELINUX
        one = 1;
        r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
        if (r < 0)
                log_warning("SO_PASSSEC failed: %m");
#endif

        one = 1;
        r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
        if (r < 0) {
                log_error("SO_TIMESTAMP failed: %m");
                return -errno;
        }

        zero(ev);
        ev.events = EPOLLIN;
        ev.data.fd = s->syslog_fd;
        if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->syslog_fd, &ev) < 0) {
                log_error("Failed to add syslog server fd to epoll object: %m");
                return -errno;
        }

        return 0;
}
Commit	Line	Data
35e2e347 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 <unistd.h>
	23	#include <sys/epoll.h>
	24
	25	#include "socket-util.h"
	26	#include "journald.h"
	27	#include "journald-syslog.h"
	28	#include "journald-kmsg.h"
	29
	30	static void forward_syslog_iovec(Server s, const struct iovec iovec, unsigned n_iovec, struct ucred ucred, struct timeval tv) {
	31	struct msghdr msghdr;
	32	struct cmsghdr *cmsg;
	33	union {
	34	struct cmsghdr cmsghdr;
	35	uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
	36	} control;
	37	union sockaddr_union sa;
	38
	39	assert(s);
	40	assert(iovec);
	41	assert(n_iovec > 0);
	42
	43	zero(msghdr);
	44	msghdr.msg_iov = (struct iovec*) iovec;
	45	msghdr.msg_iovlen = n_iovec;
	46
	47	zero(sa);
	48	sa.un.sun_family = AF_UNIX;
	49	strncpy(sa.un.sun_path, "/run/systemd/journal/syslog", sizeof(sa.un.sun_path));
	50	msghdr.msg_name = &sa;
	51	msghdr.msg_namelen = offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path);
	52
	53	if (ucred) {
	54	zero(control);
	55	msghdr.msg_control = &control;
	56	msghdr.msg_controllen = sizeof(control);
	57
	58	cmsg = CMSG_FIRSTHDR(&msghdr);
	59	cmsg->cmsg_level = SOL_SOCKET;
	60	cmsg->cmsg_type = SCM_CREDENTIALS;
	61	cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
	62	memcpy(CMSG_DATA(cmsg), ucred, sizeof(struct ucred));
	63	msghdr.msg_controllen = cmsg->cmsg_len;
	64	}
65
66	/* Forward the syslog message we received via /dev/log to
67	* /run/systemd/syslog. Unfortunately we currently can't set
68	* the SO_TIMESTAMP auxiliary data, and hence we don't. */
69
70	if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
71	return;
72
73	/* The socket is full? I guess the syslog implementation is
74	* too slow, and we shouldn't wait for that... */
75	if (errno == EAGAIN)
76	return;
77
78	if (ucred && errno == ESRCH) {
79	struct ucred u;
80
81	/* Hmm, presumably the sender process vanished
82	* by now, so let's fix it as good as we
83	* can, and retry */
84
85	u = *ucred;
86	u.pid = getpid();
87	memcpy(CMSG_DATA(cmsg), &u, sizeof(struct ucred));
88
89	if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
90	return;
91
92	if (errno == EAGAIN)
93	return;
94	}
95
96	if (errno != ENOENT)
97	log_debug("Failed to forward syslog message: %m");
98	}
99
100	static void forward_syslog_raw(Server s, int priority, const char buffer, struct ucred ucred, struct timeval tv) {
101	struct iovec iovec;
102
103	assert(s);
104	assert(buffer);
105
106	if (LOG_PRI(priority) > s->max_level_syslog)
107	return;
108
109	IOVEC_SET_STRING(iovec, buffer);
110	forward_syslog_iovec(s, &iovec, 1, ucred, tv);
111	}
112
113	void server_forward_syslog(Server s, int priority, const char identifier, const char message, struct ucred ucred, struct timeval *tv) {
114	struct iovec iovec[5];
115	char header_priority[6], header_time[64], header_pid[16];
116	int n = 0;
117	time_t t;
118	struct tm *tm;
119	char *ident_buf = NULL;
120
121	assert(s);
122	assert(priority >= 0);
123	assert(priority <= 999);
124	assert(message);
125
126	if (LOG_PRI(priority) > s->max_level_syslog)
127	return;
128
129	/* First: priority field */
130	snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
131	char_array_0(header_priority);
132	IOVEC_SET_STRING(iovec[n++], header_priority);
133
134	/* Second: timestamp */
135	t = tv ? tv->tv_sec : ((time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC));
136	tm = localtime(&t);
137	if (!tm)
138	return;
139	if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
140	return;
141	IOVEC_SET_STRING(iovec[n++], header_time);
142
143	/* Third: identifier and PID */
144	if (ucred) {
145	if (!identifier) {
146	get_process_comm(ucred->pid, &ident_buf);
147	identifier = ident_buf;
148	}
149
150	snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
151	char_array_0(header_pid);
152
153	if (identifier)
154	IOVEC_SET_STRING(iovec[n++], identifier);
155
156	IOVEC_SET_STRING(iovec[n++], header_pid);
157	} else if (identifier) {
158	IOVEC_SET_STRING(iovec[n++], identifier);
159	IOVEC_SET_STRING(iovec[n++], ": ");
160	}
161
162	/* Fourth: message */
163	IOVEC_SET_STRING(iovec[n++], message);
164
165	forward_syslog_iovec(s, iovec, n, ucred, tv);
166
167	free(ident_buf);
168	}
169
170	int syslog_fixup_facility(int priority) {
171
172	if ((priority & LOG_FACMASK) == 0)
173	return (priority & LOG_PRIMASK) \| LOG_USER;
174
175	return priority;
176	}
177
178	void syslog_read_identifier(const char buf, char identifier, char **pid) {
179	const char *p;
180	char *t;
181	size_t l, e;
182
183	assert(buf);
184	assert(identifier);
185	assert(pid);
186
187	p = *buf;
188
189	p += strspn(p, WHITESPACE);
190	l = strcspn(p, WHITESPACE);
191
192	if (l <= 0 \|\|
193	p[l-1] != ':')
194	return;
195
196	e = l;
197	l--;
198
199	if (p[l-1] == ']') {
200	size_t k = l-1;
201
202	for (;;) {
203
204	if (p[k] == '[') {
205	t = strndup(p+k+1, l-k-2);
206	if (t)
207	*pid = t;
208
209	l = k;
210	break;
211	}
212
213	if (k == 0)
214	break;
215
216	k--;
217	}
218	}
219
220	t = strndup(p, l);
221	if (t)
222	*identifier = t;
223
224	*buf = p + e;
225	buf += strspn(buf, WHITESPACE);
226	}
227
228	void server_process_syslog_message(
229	Server *s,
230	const char *buf,
231	struct ucred *ucred,
232	struct timeval *tv,
233	const char *label,
234	size_t label_len) {
235
236	char message = NULL, syslog_priority = NULL, syslog_facility = NULL, syslog_identifier = NULL, *syslog_pid = NULL;
237	struct iovec iovec[N_IOVEC_META_FIELDS + 6];
238	unsigned n = 0;
239	int priority = LOG_USER \| LOG_INFO;
240	char identifier = NULL, pid = NULL;
241	const char *orig;
242
243	assert(s);
244	assert(buf);
245
246	orig = buf;
247	syslog_parse_priority((char**) &buf, &priority);
248
249	if (s->forward_to_syslog)
250	forward_syslog_raw(s, priority, orig, ucred, tv);
251
252	syslog_skip_date((char**) &buf);
253	syslog_read_identifier(&buf, &identifier, &pid);
254
255	if (s->forward_to_kmsg)
256	server_forward_kmsg(s, priority, identifier, buf, ucred);
257
258	if (s->forward_to_console)
259	server_forward_console(s, priority, identifier, buf, ucred);
260
261	IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=syslog");
262
263	if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
264	IOVEC_SET_STRING(iovec[n++], syslog_priority);
265
266	if (priority & LOG_FACMASK)
267	if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
268	IOVEC_SET_STRING(iovec[n++], syslog_facility);
269
270	if (identifier) {
271	syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
272	if (syslog_identifier)
273	IOVEC_SET_STRING(iovec[n++], syslog_identifier);
274	}
275
276	if (pid) {
277	syslog_pid = strappend("SYSLOG_PID=", pid);
278	if (syslog_pid)
279	IOVEC_SET_STRING(iovec[n++], syslog_pid);
280	}
281
282	message = strappend("MESSAGE=", buf);
283	if (message)
284	IOVEC_SET_STRING(iovec[n++], message);
285
286	server_dispatch_message(s, iovec, n, ELEMENTSOF(iovec), ucred, tv, label, label_len, NULL, priority);
287
288	free(message);
289	free(identifier);
290	free(pid);
291	free(syslog_priority);
292	free(syslog_facility);
293	free(syslog_identifier);
294	free(syslog_pid);
295	}
296
297	int server_open_syslog_socket(Server *s) {
298	union sockaddr_union sa;
299	int one, r;
300	struct epoll_event ev;
301
302	assert(s);
303
304	if (s->syslog_fd < 0) {
305
306	s->syslog_fd = socket(AF_UNIX, SOCK_DGRAM\|SOCK_CLOEXEC\|SOCK_NONBLOCK, 0);
307	if (s->syslog_fd < 0) {
308	log_error("socket() failed: %m");
309	return -errno;
310	}
311
312	zero(sa);
313	sa.un.sun_family = AF_UNIX;
314	strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));
315
316	unlink(sa.un.sun_path);
317
318	r = bind(s->syslog_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
319	if (r < 0) {
320	log_error("bind() failed: %m");
321	return -errno;
322	}
323
324	chmod(sa.un.sun_path, 0666);
325	} else
326	fd_nonblock(s->syslog_fd, 1);
327
328	one = 1;
329	r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
330	if (r < 0) {
331	log_error("SO_PASSCRED failed: %m");
332	return -errno;
333	}
334
335	#ifdef HAVE_SELINUX
336	one = 1;
337	r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
338	if (r < 0)
339	log_warning("SO_PASSSEC failed: %m");
340	#endif
341
342	one = 1;
343	r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
344	if (r < 0) {
345	log_error("SO_TIMESTAMP failed: %m");
346	return -errno;
347	}
348
349	zero(ev);
350	ev.events = EPOLLIN;
351	ev.data.fd = s->syslog_fd;
352	if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->syslog_fd, &ev) < 0) {
353	log_error("Failed to add syslog server fd to epoll object: %m");
354	return -errno;
355	}
356
357	return 0;
358	}