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