]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/journald.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
use "Out of memory." consistantly (or with "\n")
[thirdparty/systemd.git] / src / journal / journald.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 <sys/epoll.h>
23 #include <sys/socket.h>
24 #include <errno.h>
25 #include <sys/signalfd.h>
26 #include <unistd.h>
27 #include <fcntl.h>
28 #include <stddef.h>
29 #include <sys/ioctl.h>
30 #include <linux/sockios.h>
31 #include <sys/statvfs.h>
32
33 #include <systemd/sd-journal.h>
34 #include <systemd/sd-messages.h>
35 #include <systemd/sd-daemon.h>
36
37 #ifdef HAVE_LOGIND
38 #include <systemd/sd-login.h>
39 #endif
40
41 #include "mkdir.h"
42 #include "hashmap.h"
43 #include "journal-file.h"
44 #include "socket-util.h"
45 #include "cgroup-util.h"
46 #include "list.h"
47 #include "journal-rate-limit.h"
48 #include "journal-internal.h"
49 #include "conf-parser.h"
50 #include "journald.h"
51 #include "virt.h"
52 #include "missing.h"
53
54 #ifdef HAVE_ACL
55 #include <sys/acl.h>
56 #include <acl/libacl.h>
57 #include "acl-util.h"
58 #endif
59
60 #ifdef HAVE_SELINUX
61 #include <selinux/selinux.h>
62 #endif
63
64 #define USER_JOURNALS_MAX 1024
65 #define STDOUT_STREAMS_MAX 4096
66
67 #define DEFAULT_RATE_LIMIT_INTERVAL (10*USEC_PER_SEC)
68 #define DEFAULT_RATE_LIMIT_BURST 200
69
70 #define RECHECK_AVAILABLE_SPACE_USEC (30*USEC_PER_SEC)
71
72 #define N_IOVEC_META_FIELDS 17
73
74 #define ENTRY_SIZE_MAX (1024*1024*32)
75
76 typedef enum StdoutStreamState {
77 STDOUT_STREAM_IDENTIFIER,
78 STDOUT_STREAM_UNIT_ID,
79 STDOUT_STREAM_PRIORITY,
80 STDOUT_STREAM_LEVEL_PREFIX,
81 STDOUT_STREAM_FORWARD_TO_SYSLOG,
82 STDOUT_STREAM_FORWARD_TO_KMSG,
83 STDOUT_STREAM_FORWARD_TO_CONSOLE,
84 STDOUT_STREAM_RUNNING
85 } StdoutStreamState;
86
87 struct StdoutStream {
88 Server *server;
89 StdoutStreamState state;
90
91 int fd;
92
93 struct ucred ucred;
94 #ifdef HAVE_SELINUX
95 security_context_t security_context;
96 #endif
97
98 char *identifier;
99 char *unit_id;
100 int priority;
101 bool level_prefix:1;
102 bool forward_to_syslog:1;
103 bool forward_to_kmsg:1;
104 bool forward_to_console:1;
105
106 char buffer[LINE_MAX+1];
107 size_t length;
108
109 LIST_FIELDS(StdoutStream, stdout_stream);
110 };
111
112 static const char* const storage_table[] = {
113 [STORAGE_AUTO] = "auto",
114 [STORAGE_VOLATILE] = "volatile",
115 [STORAGE_PERSISTENT] = "persistent",
116 [STORAGE_NONE] = "none"
117 };
118
119 DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
120 DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
121
122 static uint64_t available_space(Server *s) {
123 char ids[33], *p;
124 const char *f;
125 sd_id128_t machine;
126 struct statvfs ss;
127 uint64_t sum = 0, avail = 0, ss_avail = 0;
128 int r;
129 DIR *d;
130 usec_t ts;
131 JournalMetrics *m;
132
133 ts = now(CLOCK_MONOTONIC);
134
135 if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts)
136 return s->cached_available_space;
137
138 r = sd_id128_get_machine(&machine);
139 if (r < 0)
140 return 0;
141
142 if (s->system_journal) {
143 f = "/var/log/journal/";
144 m = &s->system_metrics;
145 } else {
146 f = "/run/log/journal/";
147 m = &s->runtime_metrics;
148 }
149
150 assert(m);
151
152 p = strappend(f, sd_id128_to_string(machine, ids));
153 if (!p)
154 return 0;
155
156 d = opendir(p);
157 free(p);
158
159 if (!d)
160 return 0;
161
162 if (fstatvfs(dirfd(d), &ss) < 0)
163 goto finish;
164
165 for (;;) {
166 struct stat st;
167 struct dirent buf, *de;
168
169 r = readdir_r(d, &buf, &de);
170 if (r != 0)
171 break;
172
173 if (!de)
174 break;
175
176 if (!endswith(de->d_name, ".journal") &&
177 !endswith(de->d_name, ".journal~"))
178 continue;
179
180 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
181 continue;
182
183 if (!S_ISREG(st.st_mode))
184 continue;
185
186 sum += (uint64_t) st.st_blocks * 512UL;
187 }
188
189 avail = sum >= m->max_use ? 0 : m->max_use - sum;
190
191 ss_avail = ss.f_bsize * ss.f_bavail;
192
193 ss_avail = ss_avail < m->keep_free ? 0 : ss_avail - m->keep_free;
194
195 if (ss_avail < avail)
196 avail = ss_avail;
197
198 s->cached_available_space = avail;
199 s->cached_available_space_timestamp = ts;
200
201 finish:
202 closedir(d);
203
204 return avail;
205 }
206
207 static void server_read_file_gid(Server *s) {
208 const char *adm = "adm";
209 int r;
210
211 assert(s);
212
213 if (s->file_gid_valid)
214 return;
215
216 r = get_group_creds(&adm, &s->file_gid);
217 if (r < 0)
218 log_warning("Failed to resolve 'adm' group: %s", strerror(-r));
219
220 /* if we couldn't read the gid, then it will be 0, but that's
221 * fine and we shouldn't try to resolve the group again, so
222 * let's just pretend it worked right-away. */
223 s->file_gid_valid = true;
224 }
225
226 static void server_fix_perms(Server *s, JournalFile *f, uid_t uid) {
227 int r;
228 #ifdef HAVE_ACL
229 acl_t acl;
230 acl_entry_t entry;
231 acl_permset_t permset;
232 #endif
233
234 assert(f);
235
236 server_read_file_gid(s);
237
238 r = fchmod_and_fchown(f->fd, 0640, 0, s->file_gid);
239 if (r < 0)
240 log_warning("Failed to fix access mode/rights on %s, ignoring: %s", f->path, strerror(-r));
241
242 #ifdef HAVE_ACL
243 if (uid <= 0)
244 return;
245
246 acl = acl_get_fd(f->fd);
247 if (!acl) {
248 log_warning("Failed to read ACL on %s, ignoring: %m", f->path);
249 return;
250 }
251
252 r = acl_find_uid(acl, uid, &entry);
253 if (r <= 0) {
254
255 if (acl_create_entry(&acl, &entry) < 0 ||
256 acl_set_tag_type(entry, ACL_USER) < 0 ||
257 acl_set_qualifier(entry, &uid) < 0) {
258 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
259 goto finish;
260 }
261 }
262
263 if (acl_get_permset(entry, &permset) < 0 ||
264 acl_add_perm(permset, ACL_READ) < 0 ||
265 acl_calc_mask(&acl) < 0) {
266 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
267 goto finish;
268 }
269
270 if (acl_set_fd(f->fd, acl) < 0)
271 log_warning("Failed to set ACL on %s, ignoring: %m", f->path);
272
273 finish:
274 acl_free(acl);
275 #endif
276 }
277
278 static JournalFile* find_journal(Server *s, uid_t uid) {
279 char *p;
280 int r;
281 JournalFile *f;
282 char ids[33];
283 sd_id128_t machine;
284
285 assert(s);
286
287 /* We split up user logs only on /var, not on /run. If the
288 * runtime file is open, we write to it exclusively, in order
289 * to guarantee proper order as soon as we flush /run to
290 * /var and close the runtime file. */
291
292 if (s->runtime_journal)
293 return s->runtime_journal;
294
295 if (uid <= 0)
296 return s->system_journal;
297
298 r = sd_id128_get_machine(&machine);
299 if (r < 0)
300 return s->system_journal;
301
302 f = hashmap_get(s->user_journals, UINT32_TO_PTR(uid));
303 if (f)
304 return f;
305
306 if (asprintf(&p, "/var/log/journal/%s/user-%lu.journal", sd_id128_to_string(machine, ids), (unsigned long) uid) < 0)
307 return s->system_journal;
308
309 while (hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) {
310 /* Too many open? Then let's close one */
311 f = hashmap_steal_first(s->user_journals);
312 assert(f);
313 journal_file_close(f);
314 }
315
316 r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, &s->system_metrics, s->system_journal, &f);
317 free(p);
318
319 if (r < 0)
320 return s->system_journal;
321
322 server_fix_perms(s, f, uid);
323
324 r = hashmap_put(s->user_journals, UINT32_TO_PTR(uid), f);
325 if (r < 0) {
326 journal_file_close(f);
327 return s->system_journal;
328 }
329
330 return f;
331 }
332
333 static void server_rotate(Server *s) {
334 JournalFile *f;
335 void *k;
336 Iterator i;
337 int r;
338
339 log_info("Rotating...");
340
341 if (s->runtime_journal) {
342 r = journal_file_rotate(&s->runtime_journal);
343 if (r < 0)
344 if (s->runtime_journal)
345 log_error("Failed to rotate %s: %s", s->runtime_journal->path, strerror(-r));
346 else
347 log_error("Failed to create new runtime journal: %s", strerror(-r));
348 else
349 server_fix_perms(s, s->runtime_journal, 0);
350 }
351
352 if (s->system_journal) {
353 r = journal_file_rotate(&s->system_journal);
354 if (r < 0)
355 if (s->system_journal)
356 log_error("Failed to rotate %s: %s", s->system_journal->path, strerror(-r));
357 else
358 log_error("Failed to create new system journal: %s", strerror(-r));
359
360 else
361 server_fix_perms(s, s->system_journal, 0);
362 }
363
364 HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
365 r = journal_file_rotate(&f);
366 if (r < 0)
367 if (f->path)
368 log_error("Failed to rotate %s: %s", f->path, strerror(-r));
369 else
370 log_error("Failed to create user journal: %s", strerror(-r));
371 else {
372 hashmap_replace(s->user_journals, k, f);
373 server_fix_perms(s, s->system_journal, PTR_TO_UINT32(k));
374 }
375 }
376 }
377
378 static void server_vacuum(Server *s) {
379 char *p;
380 char ids[33];
381 sd_id128_t machine;
382 int r;
383
384 log_info("Vacuuming...");
385
386 r = sd_id128_get_machine(&machine);
387 if (r < 0) {
388 log_error("Failed to get machine ID: %s", strerror(-r));
389 return;
390 }
391
392 sd_id128_to_string(machine, ids);
393
394 if (s->system_journal) {
395 if (asprintf(&p, "/var/log/journal/%s", ids) < 0) {
396 log_error("Out of memory.");
397 return;
398 }
399
400 r = journal_directory_vacuum(p, s->system_metrics.max_use, s->system_metrics.keep_free);
401 if (r < 0 && r != -ENOENT)
402 log_error("Failed to vacuum %s: %s", p, strerror(-r));
403 free(p);
404 }
405
406 if (s->runtime_journal) {
407 if (asprintf(&p, "/run/log/journal/%s", ids) < 0) {
408 log_error("Out of memory.");
409 return;
410 }
411
412 r = journal_directory_vacuum(p, s->runtime_metrics.max_use, s->runtime_metrics.keep_free);
413 if (r < 0 && r != -ENOENT)
414 log_error("Failed to vacuum %s: %s", p, strerror(-r));
415 free(p);
416 }
417
418 s->cached_available_space_timestamp = 0;
419 }
420
421 static char *shortened_cgroup_path(pid_t pid) {
422 int r;
423 char *process_path, *init_path, *path;
424
425 assert(pid > 0);
426
427 r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, pid, &process_path);
428 if (r < 0)
429 return NULL;
430
431 r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 1, &init_path);
432 if (r < 0) {
433 free(process_path);
434 return NULL;
435 }
436
437 if (endswith(init_path, "/system"))
438 init_path[strlen(init_path) - 7] = 0;
439 else if (streq(init_path, "/"))
440 init_path[0] = 0;
441
442 if (startswith(process_path, init_path)) {
443 char *p;
444
445 p = strdup(process_path + strlen(init_path));
446 if (!p) {
447 free(process_path);
448 free(init_path);
449 return NULL;
450 }
451 path = p;
452 } else {
453 path = process_path;
454 process_path = NULL;
455 }
456
457 free(process_path);
458 free(init_path);
459
460 return path;
461 }
462
463 static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n) {
464 JournalFile *f;
465 bool vacuumed = false;
466 int r;
467
468 assert(s);
469 assert(iovec);
470 assert(n > 0);
471
472 f = find_journal(s, uid);
473 if (!f)
474 return;
475
476 if (journal_file_rotate_suggested(f)) {
477 log_info("Journal header limits reached or header out-of-date, rotating.");
478 server_rotate(s);
479 server_vacuum(s);
480 vacuumed = true;
481
482 f = find_journal(s, uid);
483 if (!f)
484 return;
485 }
486
487 for (;;) {
488 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
489 if (r >= 0)
490 return;
491
492 if (vacuumed ||
493 (r != -E2BIG && /* hit limit */
494 r != -EFBIG && /* hit fs limit */
495 r != -EDQUOT && /* quota hit */
496 r != -ENOSPC && /* disk full */
497 r != -EBADMSG && /* corrupted */
498 r != -ENODATA && /* truncated */
499 r != -EHOSTDOWN && /* other machine */
500 r != -EPROTONOSUPPORT && /* unsupported feature */
501 r != -EBUSY && /* unclean shutdown */
502 r != -ESHUTDOWN /* already archived */)) {
503 log_error("Failed to write entry, ignoring: %s", strerror(-r));
504 return;
505 }
506
507 if (r == -E2BIG || r == -EFBIG || r == EDQUOT || r == ENOSPC)
508 log_info("Allocation limit reached, rotating.");
509 else if (r == -EHOSTDOWN)
510 log_info("Journal file from other machine, rotating.");
511 else if (r == -EBUSY)
512 log_info("Unlcean shutdown, rotating.");
513 else
514 log_warning("Journal file corrupted, rotating.");
515
516 server_rotate(s);
517 server_vacuum(s);
518 vacuumed = true;
519
520 f = find_journal(s, uid);
521 if (!f)
522 return;
523
524 log_info("Retrying write.");
525 }
526 }
527
528 static void dispatch_message_real(
529 Server *s,
530 struct iovec *iovec, unsigned n, unsigned m,
531 struct ucred *ucred,
532 struct timeval *tv,
533 const char *label, size_t label_len,
534 const char *unit_id) {
535
536 char *pid = NULL, *uid = NULL, *gid = NULL,
537 *source_time = NULL, *boot_id = NULL, *machine_id = NULL,
538 *comm = NULL, *cmdline = NULL, *hostname = NULL,
539 *audit_session = NULL, *audit_loginuid = NULL,
540 *exe = NULL, *cgroup = NULL, *session = NULL,
541 *owner_uid = NULL, *unit = NULL, *selinux_context = NULL;
542
543 char idbuf[33];
544 sd_id128_t id;
545 int r;
546 char *t;
547 uid_t loginuid = 0, realuid = 0;
548
549 assert(s);
550 assert(iovec);
551 assert(n > 0);
552 assert(n + N_IOVEC_META_FIELDS <= m);
553
554 if (ucred) {
555 uint32_t audit;
556 #ifdef HAVE_LOGIND
557 uid_t owner;
558 #endif
559
560 realuid = ucred->uid;
561
562 if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0)
563 IOVEC_SET_STRING(iovec[n++], pid);
564
565 if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0)
566 IOVEC_SET_STRING(iovec[n++], uid);
567
568 if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0)
569 IOVEC_SET_STRING(iovec[n++], gid);
570
571 r = get_process_comm(ucred->pid, &t);
572 if (r >= 0) {
573 comm = strappend("_COMM=", t);
574 free(t);
575
576 if (comm)
577 IOVEC_SET_STRING(iovec[n++], comm);
578 }
579
580 r = get_process_exe(ucred->pid, &t);
581 if (r >= 0) {
582 exe = strappend("_EXE=", t);
583 free(t);
584
585 if (exe)
586 IOVEC_SET_STRING(iovec[n++], exe);
587 }
588
589 r = get_process_cmdline(ucred->pid, LINE_MAX, false, &t);
590 if (r >= 0) {
591 cmdline = strappend("_CMDLINE=", t);
592 free(t);
593
594 if (cmdline)
595 IOVEC_SET_STRING(iovec[n++], cmdline);
596 }
597
598 r = audit_session_from_pid(ucred->pid, &audit);
599 if (r >= 0)
600 if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0)
601 IOVEC_SET_STRING(iovec[n++], audit_session);
602
603 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
604 if (r >= 0)
605 if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0)
606 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
607
608 t = shortened_cgroup_path(ucred->pid);
609 if (t) {
610 cgroup = strappend("_SYSTEMD_CGROUP=", t);
611 free(t);
612
613 if (cgroup)
614 IOVEC_SET_STRING(iovec[n++], cgroup);
615 }
616
617 #ifdef HAVE_LOGIND
618 if (sd_pid_get_session(ucred->pid, &t) >= 0) {
619 session = strappend("_SYSTEMD_SESSION=", t);
620 free(t);
621
622 if (session)
623 IOVEC_SET_STRING(iovec[n++], session);
624 }
625
626 if (sd_pid_get_owner_uid(ucred->uid, &owner) >= 0)
627 if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0)
628 IOVEC_SET_STRING(iovec[n++], owner_uid);
629 #endif
630
631 if (cg_pid_get_unit(ucred->pid, &t) >= 0) {
632 unit = strappend("_SYSTEMD_UNIT=", t);
633 free(t);
634 } else if (unit_id)
635 unit = strappend("_SYSTEMD_UNIT=", unit_id);
636
637 if (unit)
638 IOVEC_SET_STRING(iovec[n++], unit);
639
640 #ifdef HAVE_SELINUX
641 if (label) {
642 selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len);
643 if (selinux_context) {
644 memcpy(selinux_context, "_SELINUX_CONTEXT=", sizeof("_SELINUX_CONTEXT=")-1);
645 memcpy(selinux_context+sizeof("_SELINUX_CONTEXT=")-1, label, label_len);
646 selinux_context[sizeof("_SELINUX_CONTEXT=")-1+label_len] = 0;
647 IOVEC_SET_STRING(iovec[n++], selinux_context);
648 }
649 } else {
650 security_context_t con;
651
652 if (getpidcon(ucred->pid, &con) >= 0) {
653 selinux_context = strappend("_SELINUX_CONTEXT=", con);
654 if (selinux_context)
655 IOVEC_SET_STRING(iovec[n++], selinux_context);
656
657 freecon(con);
658 }
659 }
660 #endif
661 }
662
663 if (tv) {
664 if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu",
665 (unsigned long long) timeval_load(tv)) >= 0)
666 IOVEC_SET_STRING(iovec[n++], source_time);
667 }
668
669 /* Note that strictly speaking storing the boot id here is
670 * redundant since the entry includes this in-line
671 * anyway. However, we need this indexed, too. */
672 r = sd_id128_get_boot(&id);
673 if (r >= 0)
674 if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
675 IOVEC_SET_STRING(iovec[n++], boot_id);
676
677 r = sd_id128_get_machine(&id);
678 if (r >= 0)
679 if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
680 IOVEC_SET_STRING(iovec[n++], machine_id);
681
682 t = gethostname_malloc();
683 if (t) {
684 hostname = strappend("_HOSTNAME=", t);
685 free(t);
686 if (hostname)
687 IOVEC_SET_STRING(iovec[n++], hostname);
688 }
689
690 assert(n <= m);
691
692 write_to_journal(s, realuid == 0 ? 0 : loginuid, iovec, n);
693
694 free(pid);
695 free(uid);
696 free(gid);
697 free(comm);
698 free(exe);
699 free(cmdline);
700 free(source_time);
701 free(boot_id);
702 free(machine_id);
703 free(hostname);
704 free(audit_session);
705 free(audit_loginuid);
706 free(cgroup);
707 free(session);
708 free(owner_uid);
709 free(unit);
710 free(selinux_context);
711 }
712
713 static void driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
714 char mid[11 + 32 + 1];
715 char buffer[16 + LINE_MAX + 1];
716 struct iovec iovec[N_IOVEC_META_FIELDS + 4];
717 int n = 0;
718 va_list ap;
719 struct ucred ucred;
720
721 assert(s);
722 assert(format);
723
724 IOVEC_SET_STRING(iovec[n++], "PRIORITY=5");
725 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
726
727 memcpy(buffer, "MESSAGE=", 8);
728 va_start(ap, format);
729 vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
730 va_end(ap);
731 char_array_0(buffer);
732 IOVEC_SET_STRING(iovec[n++], buffer);
733
734 snprintf(mid, sizeof(mid), "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(message_id));
735 char_array_0(mid);
736 IOVEC_SET_STRING(iovec[n++], mid);
737
738 zero(ucred);
739 ucred.pid = getpid();
740 ucred.uid = getuid();
741 ucred.gid = getgid();
742
743 dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
744 }
745
746 static void dispatch_message(Server *s,
747 struct iovec *iovec, unsigned n, unsigned m,
748 struct ucred *ucred,
749 struct timeval *tv,
750 const char *label, size_t label_len,
751 const char *unit_id,
752 int priority) {
753 int rl;
754 char *path = NULL, *c;
755
756 assert(s);
757 assert(iovec || n == 0);
758
759 if (n == 0)
760 return;
761
762 if (LOG_PRI(priority) > s->max_level_store)
763 return;
764
765 if (!ucred)
766 goto finish;
767
768 path = shortened_cgroup_path(ucred->pid);
769 if (!path)
770 goto finish;
771
772 /* example: /user/lennart/3/foobar
773 * /system/dbus.service/foobar
774 *
775 * So let's cut of everything past the third /, since that is
776 * wher user directories start */
777
778 c = strchr(path, '/');
779 if (c) {
780 c = strchr(c+1, '/');
781 if (c) {
782 c = strchr(c+1, '/');
783 if (c)
784 *c = 0;
785 }
786 }
787
788 rl = journal_rate_limit_test(s->rate_limit, path, priority & LOG_PRIMASK, available_space(s));
789
790 if (rl == 0) {
791 free(path);
792 return;
793 }
794
795 /* Write a suppression message if we suppressed something */
796 if (rl > 1)
797 driver_message(s, SD_MESSAGE_JOURNAL_DROPPED, "Suppressed %u messages from %s", rl - 1, path);
798
799 free(path);
800
801 finish:
802 dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
803 }
804
805 static void forward_syslog_iovec(Server *s, const struct iovec *iovec, unsigned n_iovec, struct ucred *ucred, struct timeval *tv) {
806 struct msghdr msghdr;
807 struct cmsghdr *cmsg;
808 union {
809 struct cmsghdr cmsghdr;
810 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
811 } control;
812 union sockaddr_union sa;
813
814 assert(s);
815 assert(iovec);
816 assert(n_iovec > 0);
817
818 zero(msghdr);
819 msghdr.msg_iov = (struct iovec*) iovec;
820 msghdr.msg_iovlen = n_iovec;
821
822 zero(sa);
823 sa.un.sun_family = AF_UNIX;
824 strncpy(sa.un.sun_path, "/run/systemd/journal/syslog", sizeof(sa.un.sun_path));
825 msghdr.msg_name = &sa;
826 msghdr.msg_namelen = offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path);
827
828 if (ucred) {
829 zero(control);
830 msghdr.msg_control = &control;
831 msghdr.msg_controllen = sizeof(control);
832
833 cmsg = CMSG_FIRSTHDR(&msghdr);
834 cmsg->cmsg_level = SOL_SOCKET;
835 cmsg->cmsg_type = SCM_CREDENTIALS;
836 cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
837 memcpy(CMSG_DATA(cmsg), ucred, sizeof(struct ucred));
838 msghdr.msg_controllen = cmsg->cmsg_len;
839 }
840
841 /* Forward the syslog message we received via /dev/log to
842 * /run/systemd/syslog. Unfortunately we currently can't set
843 * the SO_TIMESTAMP auxiliary data, and hence we don't. */
844
845 if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
846 return;
847
848 /* The socket is full? I guess the syslog implementation is
849 * too slow, and we shouldn't wait for that... */
850 if (errno == EAGAIN)
851 return;
852
853 if (ucred && errno == ESRCH) {
854 struct ucred u;
855
856 /* Hmm, presumably the sender process vanished
857 * by now, so let's fix it as good as we
858 * can, and retry */
859
860 u = *ucred;
861 u.pid = getpid();
862 memcpy(CMSG_DATA(cmsg), &u, sizeof(struct ucred));
863
864 if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
865 return;
866
867 if (errno == EAGAIN)
868 return;
869 }
870
871 if (errno != ENOENT)
872 log_debug("Failed to forward syslog message: %m");
873 }
874
875 static void forward_syslog_raw(Server *s, int priority, const char *buffer, struct ucred *ucred, struct timeval *tv) {
876 struct iovec iovec;
877
878 assert(s);
879 assert(buffer);
880
881 if (LOG_PRI(priority) > s->max_level_syslog)
882 return;
883
884 IOVEC_SET_STRING(iovec, buffer);
885 forward_syslog_iovec(s, &iovec, 1, ucred, tv);
886 }
887
888 static void forward_syslog(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred, struct timeval *tv) {
889 struct iovec iovec[5];
890 char header_priority[6], header_time[64], header_pid[16];
891 int n = 0;
892 time_t t;
893 struct tm *tm;
894 char *ident_buf = NULL;
895
896 assert(s);
897 assert(priority >= 0);
898 assert(priority <= 999);
899 assert(message);
900
901 if (LOG_PRI(priority) > s->max_level_syslog)
902 return;
903
904 /* First: priority field */
905 snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
906 char_array_0(header_priority);
907 IOVEC_SET_STRING(iovec[n++], header_priority);
908
909 /* Second: timestamp */
910 t = tv ? tv->tv_sec : ((time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC));
911 tm = localtime(&t);
912 if (!tm)
913 return;
914 if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
915 return;
916 IOVEC_SET_STRING(iovec[n++], header_time);
917
918 /* Third: identifier and PID */
919 if (ucred) {
920 if (!identifier) {
921 get_process_comm(ucred->pid, &ident_buf);
922 identifier = ident_buf;
923 }
924
925 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
926 char_array_0(header_pid);
927
928 if (identifier)
929 IOVEC_SET_STRING(iovec[n++], identifier);
930
931 IOVEC_SET_STRING(iovec[n++], header_pid);
932 } else if (identifier) {
933 IOVEC_SET_STRING(iovec[n++], identifier);
934 IOVEC_SET_STRING(iovec[n++], ": ");
935 }
936
937 /* Fourth: message */
938 IOVEC_SET_STRING(iovec[n++], message);
939
940 forward_syslog_iovec(s, iovec, n, ucred, tv);
941
942 free(ident_buf);
943 }
944
945 static int fixup_priority(int priority) {
946
947 if ((priority & LOG_FACMASK) == 0)
948 return (priority & LOG_PRIMASK) | LOG_USER;
949
950 return priority;
951 }
952
953 static void forward_kmsg(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred) {
954 struct iovec iovec[5];
955 char header_priority[6], header_pid[16];
956 int n = 0;
957 char *ident_buf = NULL;
958 int fd;
959
960 assert(s);
961 assert(priority >= 0);
962 assert(priority <= 999);
963 assert(message);
964
965 if (LOG_PRI(priority) > s->max_level_kmsg)
966 return;
967
968 /* Never allow messages with kernel facility to be written to
969 * kmsg, regardless where the data comes from. */
970 priority = fixup_priority(priority);
971
972 /* First: priority field */
973 snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
974 char_array_0(header_priority);
975 IOVEC_SET_STRING(iovec[n++], header_priority);
976
977 /* Second: identifier and PID */
978 if (ucred) {
979 if (!identifier) {
980 get_process_comm(ucred->pid, &ident_buf);
981 identifier = ident_buf;
982 }
983
984 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
985 char_array_0(header_pid);
986
987 if (identifier)
988 IOVEC_SET_STRING(iovec[n++], identifier);
989
990 IOVEC_SET_STRING(iovec[n++], header_pid);
991 } else if (identifier) {
992 IOVEC_SET_STRING(iovec[n++], identifier);
993 IOVEC_SET_STRING(iovec[n++], ": ");
994 }
995
996 /* Fourth: message */
997 IOVEC_SET_STRING(iovec[n++], message);
998 IOVEC_SET_STRING(iovec[n++], "\n");
999
1000 fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
1001 if (fd < 0) {
1002 log_debug("Failed to open /dev/kmsg for logging: %s", strerror(errno));
1003 goto finish;
1004 }
1005
1006 if (writev(fd, iovec, n) < 0)
1007 log_debug("Failed to write to /dev/kmsg for logging: %s", strerror(errno));
1008
1009 close_nointr_nofail(fd);
1010
1011 finish:
1012 free(ident_buf);
1013 }
1014
1015 static void forward_console(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred) {
1016 struct iovec iovec[4];
1017 char header_pid[16];
1018 int n = 0, fd;
1019 char *ident_buf = NULL;
1020 const char *tty;
1021
1022 assert(s);
1023 assert(message);
1024
1025 if (LOG_PRI(priority) > s->max_level_console)
1026 return;
1027
1028 /* First: identifier and PID */
1029 if (ucred) {
1030 if (!identifier) {
1031 get_process_comm(ucred->pid, &ident_buf);
1032 identifier = ident_buf;
1033 }
1034
1035 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
1036 char_array_0(header_pid);
1037
1038 if (identifier)
1039 IOVEC_SET_STRING(iovec[n++], identifier);
1040
1041 IOVEC_SET_STRING(iovec[n++], header_pid);
1042 } else if (identifier) {
1043 IOVEC_SET_STRING(iovec[n++], identifier);
1044 IOVEC_SET_STRING(iovec[n++], ": ");
1045 }
1046
1047 /* Third: message */
1048 IOVEC_SET_STRING(iovec[n++], message);
1049 IOVEC_SET_STRING(iovec[n++], "\n");
1050
1051 tty = s->tty_path ? s->tty_path : "/dev/console";
1052
1053 fd = open_terminal(tty, O_WRONLY|O_NOCTTY|O_CLOEXEC);
1054 if (fd < 0) {
1055 log_debug("Failed to open %s for logging: %s", tty, strerror(errno));
1056 goto finish;
1057 }
1058
1059 if (writev(fd, iovec, n) < 0)
1060 log_debug("Failed to write to %s for logging: %s", tty, strerror(errno));
1061
1062 close_nointr_nofail(fd);
1063
1064 finish:
1065 free(ident_buf);
1066 }
1067
1068 static void read_identifier(const char **buf, char **identifier, char **pid) {
1069 const char *p;
1070 char *t;
1071 size_t l, e;
1072
1073 assert(buf);
1074 assert(identifier);
1075 assert(pid);
1076
1077 p = *buf;
1078
1079 p += strspn(p, WHITESPACE);
1080 l = strcspn(p, WHITESPACE);
1081
1082 if (l <= 0 ||
1083 p[l-1] != ':')
1084 return;
1085
1086 e = l;
1087 l--;
1088
1089 if (p[l-1] == ']') {
1090 size_t k = l-1;
1091
1092 for (;;) {
1093
1094 if (p[k] == '[') {
1095 t = strndup(p+k+1, l-k-2);
1096 if (t)
1097 *pid = t;
1098
1099 l = k;
1100 break;
1101 }
1102
1103 if (k == 0)
1104 break;
1105
1106 k--;
1107 }
1108 }
1109
1110 t = strndup(p, l);
1111 if (t)
1112 *identifier = t;
1113
1114 *buf = p + e;
1115 *buf += strspn(*buf, WHITESPACE);
1116 }
1117
1118 static void process_syslog_message(Server *s, const char *buf, struct ucred *ucred, struct timeval *tv, const char *label, size_t label_len) {
1119 char *message = NULL, *syslog_priority = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *syslog_pid = NULL;
1120 struct iovec iovec[N_IOVEC_META_FIELDS + 6];
1121 unsigned n = 0;
1122 int priority = LOG_USER | LOG_INFO;
1123 char *identifier = NULL, *pid = NULL;
1124 const char *orig;
1125
1126 assert(s);
1127 assert(buf);
1128
1129 orig = buf;
1130 parse_syslog_priority((char**) &buf, &priority);
1131
1132 if (s->forward_to_syslog)
1133 forward_syslog_raw(s, priority, orig, ucred, tv);
1134
1135 skip_syslog_date((char**) &buf);
1136 read_identifier(&buf, &identifier, &pid);
1137
1138 if (s->forward_to_kmsg)
1139 forward_kmsg(s, priority, identifier, buf, ucred);
1140
1141 if (s->forward_to_console)
1142 forward_console(s, priority, identifier, buf, ucred);
1143
1144 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=syslog");
1145
1146 if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1147 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1148
1149 if (priority & LOG_FACMASK)
1150 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1151 IOVEC_SET_STRING(iovec[n++], syslog_facility);
1152
1153 if (identifier) {
1154 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
1155 if (syslog_identifier)
1156 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1157 }
1158
1159 if (pid) {
1160 syslog_pid = strappend("SYSLOG_PID=", pid);
1161 if (syslog_pid)
1162 IOVEC_SET_STRING(iovec[n++], syslog_pid);
1163 }
1164
1165 message = strappend("MESSAGE=", buf);
1166 if (message)
1167 IOVEC_SET_STRING(iovec[n++], message);
1168
1169 dispatch_message(s, iovec, n, ELEMENTSOF(iovec), ucred, tv, label, label_len, NULL, priority);
1170
1171 free(message);
1172 free(identifier);
1173 free(pid);
1174 free(syslog_priority);
1175 free(syslog_facility);
1176 free(syslog_identifier);
1177 }
1178
1179 static bool valid_user_field(const char *p, size_t l) {
1180 const char *a;
1181
1182 /* We kinda enforce POSIX syntax recommendations for
1183 environment variables here, but make a couple of additional
1184 requirements.
1185
1186 http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html */
1187
1188 /* No empty field names */
1189 if (l <= 0)
1190 return false;
1191
1192 /* Don't allow names longer than 64 chars */
1193 if (l > 64)
1194 return false;
1195
1196 /* Variables starting with an underscore are protected */
1197 if (p[0] == '_')
1198 return false;
1199
1200 /* Don't allow digits as first character */
1201 if (p[0] >= '0' && p[0] <= '9')
1202 return false;
1203
1204 /* Only allow A-Z0-9 and '_' */
1205 for (a = p; a < p + l; a++)
1206 if (!((*a >= 'A' && *a <= 'Z') ||
1207 (*a >= '0' && *a <= '9') ||
1208 *a == '_'))
1209 return false;
1210
1211 return true;
1212 }
1213
1214 static void process_native_message(
1215 Server *s,
1216 const void *buffer, size_t buffer_size,
1217 struct ucred *ucred,
1218 struct timeval *tv,
1219 const char *label, size_t label_len) {
1220
1221 struct iovec *iovec = NULL;
1222 unsigned n = 0, m = 0, j, tn = (unsigned) -1;
1223 const char *p;
1224 size_t remaining;
1225 int priority = LOG_INFO;
1226 char *identifier = NULL, *message = NULL;
1227
1228 assert(s);
1229 assert(buffer || buffer_size == 0);
1230
1231 p = buffer;
1232 remaining = buffer_size;
1233
1234 while (remaining > 0) {
1235 const char *e, *q;
1236
1237 e = memchr(p, '\n', remaining);
1238
1239 if (!e) {
1240 /* Trailing noise, let's ignore it, and flush what we collected */
1241 log_debug("Received message with trailing noise, ignoring.");
1242 break;
1243 }
1244
1245 if (e == p) {
1246 /* Entry separator */
1247 dispatch_message(s, iovec, n, m, ucred, tv, label, label_len, NULL, priority);
1248 n = 0;
1249 priority = LOG_INFO;
1250
1251 p++;
1252 remaining--;
1253 continue;
1254 }
1255
1256 if (*p == '.' || *p == '#') {
1257 /* Ignore control commands for now, and
1258 * comments too. */
1259 remaining -= (e - p) + 1;
1260 p = e + 1;
1261 continue;
1262 }
1263
1264 /* A property follows */
1265
1266 if (n+N_IOVEC_META_FIELDS >= m) {
1267 struct iovec *c;
1268 unsigned u;
1269
1270 u = MAX((n+N_IOVEC_META_FIELDS+1) * 2U, 4U);
1271 c = realloc(iovec, u * sizeof(struct iovec));
1272 if (!c) {
1273 log_error("Out of memory.");
1274 break;
1275 }
1276
1277 iovec = c;
1278 m = u;
1279 }
1280
1281 q = memchr(p, '=', e - p);
1282 if (q) {
1283 if (valid_user_field(p, q - p)) {
1284 size_t l;
1285
1286 l = e - p;
1287
1288 /* If the field name starts with an
1289 * underscore, skip the variable,
1290 * since that indidates a trusted
1291 * field */
1292 iovec[n].iov_base = (char*) p;
1293 iovec[n].iov_len = l;
1294 n++;
1295
1296 /* We need to determine the priority
1297 * of this entry for the rate limiting
1298 * logic */
1299 if (l == 10 &&
1300 memcmp(p, "PRIORITY=", 9) == 0 &&
1301 p[9] >= '0' && p[9] <= '9')
1302 priority = (priority & LOG_FACMASK) | (p[9] - '0');
1303
1304 else if (l == 17 &&
1305 memcmp(p, "SYSLOG_FACILITY=", 16) == 0 &&
1306 p[16] >= '0' && p[16] <= '9')
1307 priority = (priority & LOG_PRIMASK) | ((p[16] - '0') << 3);
1308
1309 else if (l == 18 &&
1310 memcmp(p, "SYSLOG_FACILITY=", 16) == 0 &&
1311 p[16] >= '0' && p[16] <= '9' &&
1312 p[17] >= '0' && p[17] <= '9')
1313 priority = (priority & LOG_PRIMASK) | (((p[16] - '0')*10 + (p[17] - '0')) << 3);
1314
1315 else if (l >= 19 &&
1316 memcmp(p, "SYSLOG_IDENTIFIER=", 18) == 0) {
1317 char *t;
1318
1319 t = strndup(p + 18, l - 18);
1320 if (t) {
1321 free(identifier);
1322 identifier = t;
1323 }
1324 } else if (l >= 8 &&
1325 memcmp(p, "MESSAGE=", 8) == 0) {
1326 char *t;
1327
1328 t = strndup(p + 8, l - 8);
1329 if (t) {
1330 free(message);
1331 message = t;
1332 }
1333 }
1334 }
1335
1336 remaining -= (e - p) + 1;
1337 p = e + 1;
1338 continue;
1339 } else {
1340 le64_t l_le;
1341 uint64_t l;
1342 char *k;
1343
1344 if (remaining < e - p + 1 + sizeof(uint64_t) + 1) {
1345 log_debug("Failed to parse message, ignoring.");
1346 break;
1347 }
1348
1349 memcpy(&l_le, e + 1, sizeof(uint64_t));
1350 l = le64toh(l_le);
1351
1352 if (remaining < e - p + 1 + sizeof(uint64_t) + l + 1 ||
1353 e[1+sizeof(uint64_t)+l] != '\n') {
1354 log_debug("Failed to parse message, ignoring.");
1355 break;
1356 }
1357
1358 k = malloc((e - p) + 1 + l);
1359 if (!k) {
1360 log_error("Out of memory.");
1361 break;
1362 }
1363
1364 memcpy(k, p, e - p);
1365 k[e - p] = '=';
1366 memcpy(k + (e - p) + 1, e + 1 + sizeof(uint64_t), l);
1367
1368 if (valid_user_field(p, e - p)) {
1369 iovec[n].iov_base = k;
1370 iovec[n].iov_len = (e - p) + 1 + l;
1371 n++;
1372 } else
1373 free(k);
1374
1375 remaining -= (e - p) + 1 + sizeof(uint64_t) + l + 1;
1376 p = e + 1 + sizeof(uint64_t) + l + 1;
1377 }
1378 }
1379
1380 if (n <= 0)
1381 goto finish;
1382
1383 tn = n++;
1384 IOVEC_SET_STRING(iovec[tn], "_TRANSPORT=journal");
1385
1386 if (message) {
1387 if (s->forward_to_syslog)
1388 forward_syslog(s, priority, identifier, message, ucred, tv);
1389
1390 if (s->forward_to_kmsg)
1391 forward_kmsg(s, priority, identifier, message, ucred);
1392
1393 if (s->forward_to_console)
1394 forward_console(s, priority, identifier, message, ucred);
1395 }
1396
1397 dispatch_message(s, iovec, n, m, ucred, tv, label, label_len, NULL, priority);
1398
1399 finish:
1400 for (j = 0; j < n; j++) {
1401 if (j == tn)
1402 continue;
1403
1404 if (iovec[j].iov_base < buffer ||
1405 (const uint8_t*) iovec[j].iov_base >= (const uint8_t*) buffer + buffer_size)
1406 free(iovec[j].iov_base);
1407 }
1408
1409 free(iovec);
1410 free(identifier);
1411 free(message);
1412 }
1413
1414 static void process_native_file(
1415 Server *s,
1416 int fd,
1417 struct ucred *ucred,
1418 struct timeval *tv,
1419 const char *label, size_t label_len) {
1420
1421 struct stat st;
1422 void *p;
1423 ssize_t n;
1424
1425 assert(s);
1426 assert(fd >= 0);
1427
1428 /* Data is in the passed file, since it didn't fit in a
1429 * datagram. We can't map the file here, since clients might
1430 * then truncate it and trigger a SIGBUS for us. So let's
1431 * stupidly read it */
1432
1433 if (fstat(fd, &st) < 0) {
1434 log_error("Failed to stat passed file, ignoring: %m");
1435 return;
1436 }
1437
1438 if (!S_ISREG(st.st_mode)) {
1439 log_error("File passed is not regular. Ignoring.");
1440 return;
1441 }
1442
1443 if (st.st_size <= 0)
1444 return;
1445
1446 if (st.st_size > ENTRY_SIZE_MAX) {
1447 log_error("File passed too large. Ignoring.");
1448 return;
1449 }
1450
1451 p = malloc(st.st_size);
1452 if (!p) {
1453 log_error("Out of memory.");
1454 return;
1455 }
1456
1457 n = pread(fd, p, st.st_size, 0);
1458 if (n < 0)
1459 log_error("Failed to read file, ignoring: %s", strerror(-n));
1460 else if (n > 0)
1461 process_native_message(s, p, n, ucred, tv, label, label_len);
1462
1463 free(p);
1464 }
1465
1466 static int stdout_stream_log(StdoutStream *s, const char *p) {
1467 struct iovec iovec[N_IOVEC_META_FIELDS + 5];
1468 char *message = NULL, *syslog_priority = NULL, *syslog_facility = NULL, *syslog_identifier = NULL;
1469 unsigned n = 0;
1470 int priority;
1471 char *label = NULL;
1472 size_t label_len = 0;
1473
1474 assert(s);
1475 assert(p);
1476
1477 if (isempty(p))
1478 return 0;
1479
1480 priority = s->priority;
1481
1482 if (s->level_prefix)
1483 parse_syslog_priority((char**) &p, &priority);
1484
1485 if (s->forward_to_syslog || s->server->forward_to_syslog)
1486 forward_syslog(s->server, fixup_priority(priority), s->identifier, p, &s->ucred, NULL);
1487
1488 if (s->forward_to_kmsg || s->server->forward_to_kmsg)
1489 forward_kmsg(s->server, priority, s->identifier, p, &s->ucred);
1490
1491 if (s->forward_to_console || s->server->forward_to_console)
1492 forward_console(s->server, priority, s->identifier, p, &s->ucred);
1493
1494 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=stdout");
1495
1496 if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1497 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1498
1499 if (priority & LOG_FACMASK)
1500 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1501 IOVEC_SET_STRING(iovec[n++], syslog_facility);
1502
1503 if (s->identifier) {
1504 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", s->identifier);
1505 if (syslog_identifier)
1506 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1507 }
1508
1509 message = strappend("MESSAGE=", p);
1510 if (message)
1511 IOVEC_SET_STRING(iovec[n++], message);
1512
1513 #ifdef HAVE_SELINUX
1514 if (s->security_context) {
1515 label = (char*) s->security_context;
1516 label_len = strlen((char*) s->security_context);
1517 }
1518 #endif
1519
1520 dispatch_message(s->server, iovec, n, ELEMENTSOF(iovec), &s->ucred, NULL, label, label_len, s->unit_id, priority);
1521
1522 free(message);
1523 free(syslog_priority);
1524 free(syslog_facility);
1525 free(syslog_identifier);
1526
1527 return 0;
1528 }
1529
1530 static int stdout_stream_line(StdoutStream *s, char *p) {
1531 int r;
1532
1533 assert(s);
1534 assert(p);
1535
1536 p = strstrip(p);
1537
1538 switch (s->state) {
1539
1540 case STDOUT_STREAM_IDENTIFIER:
1541 if (isempty(p))
1542 s->identifier = NULL;
1543 else {
1544 s->identifier = strdup(p);
1545 if (!s->identifier) {
1546 log_error("Out of memory.");
1547 return -ENOMEM;
1548 }
1549 }
1550
1551 s->state = STDOUT_STREAM_UNIT_ID;
1552 return 0;
1553
1554 case STDOUT_STREAM_UNIT_ID:
1555 if (s->ucred.uid == 0) {
1556 if (isempty(p))
1557 s->unit_id = NULL;
1558 else {
1559 s->unit_id = strdup(p);
1560 if (!s->unit_id) {
1561 log_error("Out of memory.");
1562 return -ENOMEM;
1563 }
1564 }
1565 }
1566
1567 s->state = STDOUT_STREAM_PRIORITY;
1568 return 0;
1569
1570 case STDOUT_STREAM_PRIORITY:
1571 r = safe_atoi(p, &s->priority);
1572 if (r < 0 || s->priority <= 0 || s->priority >= 999) {
1573 log_warning("Failed to parse log priority line.");
1574 return -EINVAL;
1575 }
1576
1577 s->state = STDOUT_STREAM_LEVEL_PREFIX;
1578 return 0;
1579
1580 case STDOUT_STREAM_LEVEL_PREFIX:
1581 r = parse_boolean(p);
1582 if (r < 0) {
1583 log_warning("Failed to parse level prefix line.");
1584 return -EINVAL;
1585 }
1586
1587 s->level_prefix = !!r;
1588 s->state = STDOUT_STREAM_FORWARD_TO_SYSLOG;
1589 return 0;
1590
1591 case STDOUT_STREAM_FORWARD_TO_SYSLOG:
1592 r = parse_boolean(p);
1593 if (r < 0) {
1594 log_warning("Failed to parse forward to syslog line.");
1595 return -EINVAL;
1596 }
1597
1598 s->forward_to_syslog = !!r;
1599 s->state = STDOUT_STREAM_FORWARD_TO_KMSG;
1600 return 0;
1601
1602 case STDOUT_STREAM_FORWARD_TO_KMSG:
1603 r = parse_boolean(p);
1604 if (r < 0) {
1605 log_warning("Failed to parse copy to kmsg line.");
1606 return -EINVAL;
1607 }
1608
1609 s->forward_to_kmsg = !!r;
1610 s->state = STDOUT_STREAM_FORWARD_TO_CONSOLE;
1611 return 0;
1612
1613 case STDOUT_STREAM_FORWARD_TO_CONSOLE:
1614 r = parse_boolean(p);
1615 if (r < 0) {
1616 log_warning("Failed to parse copy to console line.");
1617 return -EINVAL;
1618 }
1619
1620 s->forward_to_console = !!r;
1621 s->state = STDOUT_STREAM_RUNNING;
1622 return 0;
1623
1624 case STDOUT_STREAM_RUNNING:
1625 return stdout_stream_log(s, p);
1626 }
1627
1628 assert_not_reached("Unknown stream state");
1629 }
1630
1631 static int stdout_stream_scan(StdoutStream *s, bool force_flush) {
1632 char *p;
1633 size_t remaining;
1634 int r;
1635
1636 assert(s);
1637
1638 p = s->buffer;
1639 remaining = s->length;
1640 for (;;) {
1641 char *end;
1642 size_t skip;
1643
1644 end = memchr(p, '\n', remaining);
1645 if (end)
1646 skip = end - p + 1;
1647 else if (remaining >= sizeof(s->buffer) - 1) {
1648 end = p + sizeof(s->buffer) - 1;
1649 skip = remaining;
1650 } else
1651 break;
1652
1653 *end = 0;
1654
1655 r = stdout_stream_line(s, p);
1656 if (r < 0)
1657 return r;
1658
1659 remaining -= skip;
1660 p += skip;
1661 }
1662
1663 if (force_flush && remaining > 0) {
1664 p[remaining] = 0;
1665 r = stdout_stream_line(s, p);
1666 if (r < 0)
1667 return r;
1668
1669 p += remaining;
1670 remaining = 0;
1671 }
1672
1673 if (p > s->buffer) {
1674 memmove(s->buffer, p, remaining);
1675 s->length = remaining;
1676 }
1677
1678 return 0;
1679 }
1680
1681 static int stdout_stream_process(StdoutStream *s) {
1682 ssize_t l;
1683 int r;
1684
1685 assert(s);
1686
1687 l = read(s->fd, s->buffer+s->length, sizeof(s->buffer)-1-s->length);
1688 if (l < 0) {
1689
1690 if (errno == EAGAIN)
1691 return 0;
1692
1693 log_warning("Failed to read from stream: %m");
1694 return -errno;
1695 }
1696
1697 if (l == 0) {
1698 r = stdout_stream_scan(s, true);
1699 if (r < 0)
1700 return r;
1701
1702 return 0;
1703 }
1704
1705 s->length += l;
1706 r = stdout_stream_scan(s, false);
1707 if (r < 0)
1708 return r;
1709
1710 return 1;
1711
1712 }
1713
1714 static void stdout_stream_free(StdoutStream *s) {
1715 assert(s);
1716
1717 if (s->server) {
1718 assert(s->server->n_stdout_streams > 0);
1719 s->server->n_stdout_streams --;
1720 LIST_REMOVE(StdoutStream, stdout_stream, s->server->stdout_streams, s);
1721 }
1722
1723 if (s->fd >= 0) {
1724 if (s->server)
1725 epoll_ctl(s->server->epoll_fd, EPOLL_CTL_DEL, s->fd, NULL);
1726
1727 close_nointr_nofail(s->fd);
1728 }
1729
1730 #ifdef HAVE_SELINUX
1731 if (s->security_context)
1732 freecon(s->security_context);
1733 #endif
1734
1735 free(s->identifier);
1736 free(s);
1737 }
1738
1739 static int stdout_stream_new(Server *s) {
1740 StdoutStream *stream;
1741 int fd, r;
1742 socklen_t len;
1743 struct epoll_event ev;
1744
1745 assert(s);
1746
1747 fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1748 if (fd < 0) {
1749 if (errno == EAGAIN)
1750 return 0;
1751
1752 log_error("Failed to accept stdout connection: %m");
1753 return -errno;
1754 }
1755
1756 if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) {
1757 log_warning("Too many stdout streams, refusing connection.");
1758 close_nointr_nofail(fd);
1759 return 0;
1760 }
1761
1762 stream = new0(StdoutStream, 1);
1763 if (!stream) {
1764 log_error("Out of memory.");
1765 close_nointr_nofail(fd);
1766 return -ENOMEM;
1767 }
1768
1769 stream->fd = fd;
1770
1771 len = sizeof(stream->ucred);
1772 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &stream->ucred, &len) < 0) {
1773 log_error("Failed to determine peer credentials: %m");
1774 r = -errno;
1775 goto fail;
1776 }
1777
1778 #ifdef HAVE_SELINUX
1779 if (getpeercon(fd, &stream->security_context) < 0 && errno != ENOPROTOOPT)
1780 log_error("Failed to determine peer security context: %m");
1781 #endif
1782
1783 if (shutdown(fd, SHUT_WR) < 0) {
1784 log_error("Failed to shutdown writing side of socket: %m");
1785 r = -errno;
1786 goto fail;
1787 }
1788
1789 zero(ev);
1790 ev.data.ptr = stream;
1791 ev.events = EPOLLIN;
1792 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
1793 log_error("Failed to add stream to event loop: %m");
1794 r = -errno;
1795 goto fail;
1796 }
1797
1798 stream->server = s;
1799 LIST_PREPEND(StdoutStream, stdout_stream, s->stdout_streams, stream);
1800 s->n_stdout_streams ++;
1801
1802 return 0;
1803
1804 fail:
1805 stdout_stream_free(stream);
1806 return r;
1807 }
1808
1809 static int parse_kernel_timestamp(char **_p, usec_t *t) {
1810 usec_t r;
1811 int k, i;
1812 char *p;
1813
1814 assert(_p);
1815 assert(*_p);
1816 assert(t);
1817
1818 p = *_p;
1819
1820 if (strlen(p) < 14 || p[0] != '[' || p[13] != ']' || p[6] != '.')
1821 return 0;
1822
1823 r = 0;
1824
1825 for (i = 1; i <= 5; i++) {
1826 r *= 10;
1827
1828 if (p[i] == ' ')
1829 continue;
1830
1831 k = undecchar(p[i]);
1832 if (k < 0)
1833 return 0;
1834
1835 r += k;
1836 }
1837
1838 for (i = 7; i <= 12; i++) {
1839 r *= 10;
1840
1841 k = undecchar(p[i]);
1842 if (k < 0)
1843 return 0;
1844
1845 r += k;
1846 }
1847
1848 *t = r;
1849 *_p += 14;
1850 *_p += strspn(*_p, WHITESPACE);
1851
1852 return 1;
1853 }
1854
1855 static bool is_us(const char *pid) {
1856 pid_t t;
1857
1858 assert(pid);
1859
1860 if (parse_pid(pid, &t) < 0)
1861 return false;
1862
1863 return t == getpid();
1864 }
1865
1866 static void proc_kmsg_line(Server *s, const char *p) {
1867 struct iovec iovec[N_IOVEC_META_FIELDS + 7];
1868 char *message = NULL, *syslog_priority = NULL, *syslog_pid = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *source_time = NULL;
1869 int priority = LOG_KERN | LOG_INFO;
1870 unsigned n = 0;
1871 usec_t usec;
1872 char *identifier = NULL, *pid = NULL;
1873
1874 assert(s);
1875 assert(p);
1876
1877 if (isempty(p))
1878 return;
1879
1880 parse_syslog_priority((char **) &p, &priority);
1881
1882 if (s->forward_to_kmsg && (priority & LOG_FACMASK) != LOG_KERN)
1883 return;
1884
1885 if (parse_kernel_timestamp((char **) &p, &usec) > 0) {
1886 if (asprintf(&source_time, "_SOURCE_MONOTONIC_TIMESTAMP=%llu",
1887 (unsigned long long) usec) >= 0)
1888 IOVEC_SET_STRING(iovec[n++], source_time);
1889 }
1890
1891 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=kernel");
1892
1893 if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1894 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1895
1896 if ((priority & LOG_FACMASK) == LOG_KERN) {
1897
1898 if (s->forward_to_syslog)
1899 forward_syslog(s, priority, "kernel", p, NULL, NULL);
1900
1901 IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=kernel");
1902 } else {
1903 read_identifier(&p, &identifier, &pid);
1904
1905 /* Avoid any messages we generated ourselves via
1906 * log_info() and friends. */
1907 if (pid && is_us(pid))
1908 goto finish;
1909
1910 if (s->forward_to_syslog)
1911 forward_syslog(s, priority, identifier, p, NULL, NULL);
1912
1913 if (identifier) {
1914 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
1915 if (syslog_identifier)
1916 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1917 }
1918
1919 if (pid) {
1920 syslog_pid = strappend("SYSLOG_PID=", pid);
1921 if (syslog_pid)
1922 IOVEC_SET_STRING(iovec[n++], syslog_pid);
1923 }
1924
1925 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1926 IOVEC_SET_STRING(iovec[n++], syslog_facility);
1927 }
1928
1929 message = strappend("MESSAGE=", p);
1930 if (message)
1931 IOVEC_SET_STRING(iovec[n++], message);
1932
1933 dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, NULL, NULL, 0, NULL, priority);
1934
1935 finish:
1936 free(message);
1937 free(syslog_priority);
1938 free(syslog_identifier);
1939 free(syslog_pid);
1940 free(syslog_facility);
1941 free(source_time);
1942 free(identifier);
1943 free(pid);
1944 }
1945
1946 static void proc_kmsg_scan(Server *s) {
1947 char *p;
1948 size_t remaining;
1949
1950 assert(s);
1951
1952 p = s->proc_kmsg_buffer;
1953 remaining = s->proc_kmsg_length;
1954 for (;;) {
1955 char *end;
1956 size_t skip;
1957
1958 end = memchr(p, '\n', remaining);
1959 if (end)
1960 skip = end - p + 1;
1961 else if (remaining >= sizeof(s->proc_kmsg_buffer) - 1) {
1962 end = p + sizeof(s->proc_kmsg_buffer) - 1;
1963 skip = remaining;
1964 } else
1965 break;
1966
1967 *end = 0;
1968
1969 proc_kmsg_line(s, p);
1970
1971 remaining -= skip;
1972 p += skip;
1973 }
1974
1975 if (p > s->proc_kmsg_buffer) {
1976 memmove(s->proc_kmsg_buffer, p, remaining);
1977 s->proc_kmsg_length = remaining;
1978 }
1979 }
1980
1981 static int system_journal_open(Server *s) {
1982 int r;
1983 char *fn;
1984 sd_id128_t machine;
1985 char ids[33];
1986
1987 r = sd_id128_get_machine(&machine);
1988 if (r < 0)
1989 return r;
1990
1991 sd_id128_to_string(machine, ids);
1992
1993 if (!s->system_journal &&
1994 (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
1995 access("/run/systemd/journal/flushed", F_OK) >= 0) {
1996
1997 /* If in auto mode: first try to create the machine
1998 * path, but not the prefix.
1999 *
2000 * If in persistent mode: create /var/log/journal and
2001 * the machine path */
2002
2003 if (s->storage == STORAGE_PERSISTENT)
2004 (void) mkdir("/var/log/journal/", 0755);
2005
2006 fn = strappend("/var/log/journal/", ids);
2007 if (!fn)
2008 return -ENOMEM;
2009
2010 (void) mkdir(fn, 0755);
2011 free(fn);
2012
2013 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
2014 if (!fn)
2015 return -ENOMEM;
2016
2017 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, &s->system_metrics, NULL, &s->system_journal);
2018 free(fn);
2019
2020 if (r >= 0) {
2021 s->system_journal->compress = s->compress;
2022
2023 server_fix_perms(s, s->system_journal, 0);
2024 } else if (r < 0) {
2025
2026 if (r != -ENOENT && r != -EROFS)
2027 log_warning("Failed to open system journal: %s", strerror(-r));
2028
2029 r = 0;
2030 }
2031 }
2032
2033 if (!s->runtime_journal &&
2034 (s->storage != STORAGE_NONE)) {
2035
2036 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
2037 if (!fn)
2038 return -ENOMEM;
2039
2040 if (s->system_journal) {
2041
2042 /* Try to open the runtime journal, but only
2043 * if it already exists, so that we can flush
2044 * it into the system journal */
2045
2046 r = journal_file_open(fn, O_RDWR, 0640, &s->runtime_metrics, NULL, &s->runtime_journal);
2047 free(fn);
2048
2049 if (r < 0) {
2050 if (r != -ENOENT)
2051 log_warning("Failed to open runtime journal: %s", strerror(-r));
2052
2053 r = 0;
2054 }
2055
2056 } else {
2057
2058 /* OK, we really need the runtime journal, so create
2059 * it if necessary. */
2060
2061 (void) mkdir_parents(fn, 0755);
2062 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, &s->runtime_metrics, NULL, &s->runtime_journal);
2063 free(fn);
2064
2065 if (r < 0) {
2066 log_error("Failed to open runtime journal: %s", strerror(-r));
2067 return r;
2068 }
2069 }
2070
2071 if (s->runtime_journal) {
2072 s->runtime_journal->compress = s->compress;
2073
2074 server_fix_perms(s, s->runtime_journal, 0);
2075 }
2076 }
2077
2078 return r;
2079 }
2080
2081 static int server_flush_to_var(Server *s) {
2082 Object *o = NULL;
2083 int r;
2084 sd_id128_t machine;
2085 sd_journal *j;
2086
2087 assert(s);
2088
2089 if (s->storage != STORAGE_AUTO &&
2090 s->storage != STORAGE_PERSISTENT)
2091 return 0;
2092
2093 if (!s->runtime_journal)
2094 return 0;
2095
2096 system_journal_open(s);
2097
2098 if (!s->system_journal)
2099 return 0;
2100
2101 log_info("Flushing to /var...");
2102
2103 r = sd_id128_get_machine(&machine);
2104 if (r < 0) {
2105 log_error("Failed to get machine id: %s", strerror(-r));
2106 return r;
2107 }
2108
2109 r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
2110 if (r < 0) {
2111 log_error("Failed to read runtime journal: %s", strerror(-r));
2112 return r;
2113 }
2114
2115 SD_JOURNAL_FOREACH(j) {
2116 JournalFile *f;
2117
2118 f = j->current_file;
2119 assert(f && f->current_offset > 0);
2120
2121 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
2122 if (r < 0) {
2123 log_error("Can't read entry: %s", strerror(-r));
2124 goto finish;
2125 }
2126
2127 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
2128 if (r == -E2BIG) {
2129 log_info("Allocation limit reached.");
2130
2131 journal_file_post_change(s->system_journal);
2132 server_rotate(s);
2133 server_vacuum(s);
2134
2135 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
2136 }
2137
2138 if (r < 0) {
2139 log_error("Can't write entry: %s", strerror(-r));
2140 goto finish;
2141 }
2142 }
2143
2144 finish:
2145 journal_file_post_change(s->system_journal);
2146
2147 journal_file_close(s->runtime_journal);
2148 s->runtime_journal = NULL;
2149
2150 if (r >= 0)
2151 rm_rf("/run/log/journal", false, true, false);
2152
2153 return r;
2154 }
2155
2156 static int server_read_proc_kmsg(Server *s) {
2157 ssize_t l;
2158 assert(s);
2159 assert(s->proc_kmsg_fd >= 0);
2160
2161 l = read(s->proc_kmsg_fd, s->proc_kmsg_buffer + s->proc_kmsg_length, sizeof(s->proc_kmsg_buffer) - 1 - s->proc_kmsg_length);
2162 if (l == 0) /* the kernel is stupid and in some race
2163 * conditions returns 0 in the middle of the
2164 * stream. */
2165 return 0;
2166 if (l < 0) {
2167
2168 if (errno == EAGAIN || errno == EINTR)
2169 return 0;
2170
2171 log_error("Failed to read from kernel: %m");
2172 return -errno;
2173 }
2174
2175 s->proc_kmsg_length += l;
2176
2177 proc_kmsg_scan(s);
2178 return 1;
2179 }
2180
2181 static int server_flush_proc_kmsg(Server *s) {
2182 int r;
2183
2184 assert(s);
2185
2186 if (s->proc_kmsg_fd < 0)
2187 return 0;
2188
2189 log_info("Flushing /proc/kmsg...");
2190
2191 for (;;) {
2192 r = server_read_proc_kmsg(s);
2193 if (r < 0)
2194 return r;
2195
2196 if (r == 0)
2197 break;
2198 }
2199
2200 return 0;
2201 }
2202
2203 static int process_event(Server *s, struct epoll_event *ev) {
2204 assert(s);
2205 assert(ev);
2206
2207 if (ev->data.fd == s->signal_fd) {
2208 struct signalfd_siginfo sfsi;
2209 ssize_t n;
2210
2211 if (ev->events != EPOLLIN) {
2212 log_info("Got invalid event from epoll.");
2213 return -EIO;
2214 }
2215
2216 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
2217 if (n != sizeof(sfsi)) {
2218
2219 if (n >= 0)
2220 return -EIO;
2221
2222 if (errno == EINTR || errno == EAGAIN)
2223 return 1;
2224
2225 return -errno;
2226 }
2227
2228 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
2229
2230 if (sfsi.ssi_signo == SIGUSR1) {
2231 touch("/run/systemd/journal/flushed");
2232 server_flush_to_var(s);
2233 return 1;
2234 }
2235
2236 if (sfsi.ssi_signo == SIGUSR2) {
2237 server_rotate(s);
2238 server_vacuum(s);
2239 return 1;
2240 }
2241
2242 return 0;
2243
2244 } else if (ev->data.fd == s->proc_kmsg_fd) {
2245 int r;
2246
2247 if (ev->events != EPOLLIN) {
2248 log_info("Got invalid event from epoll.");
2249 return -EIO;
2250 }
2251
2252 r = server_read_proc_kmsg(s);
2253 if (r < 0)
2254 return r;
2255
2256 return 1;
2257
2258 } else if (ev->data.fd == s->native_fd ||
2259 ev->data.fd == s->syslog_fd) {
2260
2261 if (ev->events != EPOLLIN) {
2262 log_info("Got invalid event from epoll.");
2263 return -EIO;
2264 }
2265
2266 for (;;) {
2267 struct msghdr msghdr;
2268 struct iovec iovec;
2269 struct ucred *ucred = NULL;
2270 struct timeval *tv = NULL;
2271 struct cmsghdr *cmsg;
2272 char *label = NULL;
2273 size_t label_len = 0;
2274 union {
2275 struct cmsghdr cmsghdr;
2276
2277 /* We use NAME_MAX space for the
2278 * SELinux label here. The kernel
2279 * currently enforces no limit, but
2280 * according to suggestions from the
2281 * SELinux people this will change and
2282 * it will probably be identical to
2283 * NAME_MAX. For now we use that, but
2284 * this should be updated one day when
2285 * the final limit is known.*/
2286 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
2287 CMSG_SPACE(sizeof(struct timeval)) +
2288 CMSG_SPACE(sizeof(int)) + /* fd */
2289 CMSG_SPACE(NAME_MAX)]; /* selinux label */
2290 } control;
2291 ssize_t n;
2292 int v;
2293 int *fds = NULL;
2294 unsigned n_fds = 0;
2295
2296 if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
2297 log_error("SIOCINQ failed: %m");
2298 return -errno;
2299 }
2300
2301 if (s->buffer_size < (size_t) v) {
2302 void *b;
2303 size_t l;
2304
2305 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
2306 b = realloc(s->buffer, l+1);
2307
2308 if (!b) {
2309 log_error("Couldn't increase buffer.");
2310 return -ENOMEM;
2311 }
2312
2313 s->buffer_size = l;
2314 s->buffer = b;
2315 }
2316
2317 zero(iovec);
2318 iovec.iov_base = s->buffer;
2319 iovec.iov_len = s->buffer_size;
2320
2321 zero(control);
2322 zero(msghdr);
2323 msghdr.msg_iov = &iovec;
2324 msghdr.msg_iovlen = 1;
2325 msghdr.msg_control = &control;
2326 msghdr.msg_controllen = sizeof(control);
2327
2328 n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
2329 if (n < 0) {
2330
2331 if (errno == EINTR || errno == EAGAIN)
2332 return 1;
2333
2334 log_error("recvmsg() failed: %m");
2335 return -errno;
2336 }
2337
2338 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
2339
2340 if (cmsg->cmsg_level == SOL_SOCKET &&
2341 cmsg->cmsg_type == SCM_CREDENTIALS &&
2342 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
2343 ucred = (struct ucred*) CMSG_DATA(cmsg);
2344 else if (cmsg->cmsg_level == SOL_SOCKET &&
2345 cmsg->cmsg_type == SCM_SECURITY) {
2346 label = (char*) CMSG_DATA(cmsg);
2347 label_len = cmsg->cmsg_len - CMSG_LEN(0);
2348 } else if (cmsg->cmsg_level == SOL_SOCKET &&
2349 cmsg->cmsg_type == SO_TIMESTAMP &&
2350 cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
2351 tv = (struct timeval*) CMSG_DATA(cmsg);
2352 else if (cmsg->cmsg_level == SOL_SOCKET &&
2353 cmsg->cmsg_type == SCM_RIGHTS) {
2354 fds = (int*) CMSG_DATA(cmsg);
2355 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
2356 }
2357 }
2358
2359 if (ev->data.fd == s->syslog_fd) {
2360 char *e;
2361
2362 if (n > 0 && n_fds == 0) {
2363 e = memchr(s->buffer, '\n', n);
2364 if (e)
2365 *e = 0;
2366 else
2367 s->buffer[n] = 0;
2368
2369 process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
2370 } else if (n_fds > 0)
2371 log_warning("Got file descriptors via syslog socket. Ignoring.");
2372
2373 } else {
2374 if (n > 0 && n_fds == 0)
2375 process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
2376 else if (n == 0 && n_fds == 1)
2377 process_native_file(s, fds[0], ucred, tv, label, label_len);
2378 else if (n_fds > 0)
2379 log_warning("Got too many file descriptors via native socket. Ignoring.");
2380 }
2381
2382 close_many(fds, n_fds);
2383 }
2384
2385 return 1;
2386
2387 } else if (ev->data.fd == s->stdout_fd) {
2388
2389 if (ev->events != EPOLLIN) {
2390 log_info("Got invalid event from epoll.");
2391 return -EIO;
2392 }
2393
2394 stdout_stream_new(s);
2395 return 1;
2396
2397 } else {
2398 StdoutStream *stream;
2399
2400 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
2401 log_info("Got invalid event from epoll.");
2402 return -EIO;
2403 }
2404
2405 /* If it is none of the well-known fds, it must be an
2406 * stdout stream fd. Note that this is a bit ugly here
2407 * (since we rely that none of the well-known fds
2408 * could be interpreted as pointer), but nonetheless
2409 * safe, since the well-known fds would never get an
2410 * fd > 4096, i.e. beyond the first memory page */
2411
2412 stream = ev->data.ptr;
2413
2414 if (stdout_stream_process(stream) <= 0)
2415 stdout_stream_free(stream);
2416
2417 return 1;
2418 }
2419
2420 log_error("Unknown event.");
2421 return 0;
2422 }
2423
2424 static int open_syslog_socket(Server *s) {
2425 union sockaddr_union sa;
2426 int one, r;
2427 struct epoll_event ev;
2428
2429 assert(s);
2430
2431 if (s->syslog_fd < 0) {
2432
2433 s->syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2434 if (s->syslog_fd < 0) {
2435 log_error("socket() failed: %m");
2436 return -errno;
2437 }
2438
2439 zero(sa);
2440 sa.un.sun_family = AF_UNIX;
2441 strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));
2442
2443 unlink(sa.un.sun_path);
2444
2445 r = bind(s->syslog_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2446 if (r < 0) {
2447 log_error("bind() failed: %m");
2448 return -errno;
2449 }
2450
2451 chmod(sa.un.sun_path, 0666);
2452 } else
2453 fd_nonblock(s->syslog_fd, 1);
2454
2455 one = 1;
2456 r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
2457 if (r < 0) {
2458 log_error("SO_PASSCRED failed: %m");
2459 return -errno;
2460 }
2461
2462 #ifdef HAVE_SELINUX
2463 one = 1;
2464 r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
2465 if (r < 0)
2466 log_warning("SO_PASSSEC failed: %m");
2467 #endif
2468
2469 one = 1;
2470 r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
2471 if (r < 0) {
2472 log_error("SO_TIMESTAMP failed: %m");
2473 return -errno;
2474 }
2475
2476 zero(ev);
2477 ev.events = EPOLLIN;
2478 ev.data.fd = s->syslog_fd;
2479 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->syslog_fd, &ev) < 0) {
2480 log_error("Failed to add syslog server fd to epoll object: %m");
2481 return -errno;
2482 }
2483
2484 return 0;
2485 }
2486
2487 static int open_native_socket(Server*s) {
2488 union sockaddr_union sa;
2489 int one, r;
2490 struct epoll_event ev;
2491
2492 assert(s);
2493
2494 if (s->native_fd < 0) {
2495
2496 s->native_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2497 if (s->native_fd < 0) {
2498 log_error("socket() failed: %m");
2499 return -errno;
2500 }
2501
2502 zero(sa);
2503 sa.un.sun_family = AF_UNIX;
2504 strncpy(sa.un.sun_path, "/run/systemd/journal/socket", sizeof(sa.un.sun_path));
2505
2506 unlink(sa.un.sun_path);
2507
2508 r = bind(s->native_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2509 if (r < 0) {
2510 log_error("bind() failed: %m");
2511 return -errno;
2512 }
2513
2514 chmod(sa.un.sun_path, 0666);
2515 } else
2516 fd_nonblock(s->native_fd, 1);
2517
2518 one = 1;
2519 r = setsockopt(s->native_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
2520 if (r < 0) {
2521 log_error("SO_PASSCRED failed: %m");
2522 return -errno;
2523 }
2524
2525 #ifdef HAVE_SELINUX
2526 one = 1;
2527 r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
2528 if (r < 0)
2529 log_warning("SO_PASSSEC failed: %m");
2530 #endif
2531
2532 one = 1;
2533 r = setsockopt(s->native_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
2534 if (r < 0) {
2535 log_error("SO_TIMESTAMP failed: %m");
2536 return -errno;
2537 }
2538
2539 zero(ev);
2540 ev.events = EPOLLIN;
2541 ev.data.fd = s->native_fd;
2542 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->native_fd, &ev) < 0) {
2543 log_error("Failed to add native server fd to epoll object: %m");
2544 return -errno;
2545 }
2546
2547 return 0;
2548 }
2549
2550 static int open_stdout_socket(Server *s) {
2551 union sockaddr_union sa;
2552 int r;
2553 struct epoll_event ev;
2554
2555 assert(s);
2556
2557 if (s->stdout_fd < 0) {
2558
2559 s->stdout_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2560 if (s->stdout_fd < 0) {
2561 log_error("socket() failed: %m");
2562 return -errno;
2563 }
2564
2565 zero(sa);
2566 sa.un.sun_family = AF_UNIX;
2567 strncpy(sa.un.sun_path, "/run/systemd/journal/stdout", sizeof(sa.un.sun_path));
2568
2569 unlink(sa.un.sun_path);
2570
2571 r = bind(s->stdout_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2572 if (r < 0) {
2573 log_error("bind() failed: %m");
2574 return -errno;
2575 }
2576
2577 chmod(sa.un.sun_path, 0666);
2578
2579 if (listen(s->stdout_fd, SOMAXCONN) < 0) {
2580 log_error("liste() failed: %m");
2581 return -errno;
2582 }
2583 } else
2584 fd_nonblock(s->stdout_fd, 1);
2585
2586 zero(ev);
2587 ev.events = EPOLLIN;
2588 ev.data.fd = s->stdout_fd;
2589 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->stdout_fd, &ev) < 0) {
2590 log_error("Failed to add stdout server fd to epoll object: %m");
2591 return -errno;
2592 }
2593
2594 return 0;
2595 }
2596
2597 static int open_proc_kmsg(Server *s) {
2598 struct epoll_event ev;
2599
2600 assert(s);
2601
2602 if (!s->import_proc_kmsg)
2603 return 0;
2604
2605 s->proc_kmsg_fd = open("/proc/kmsg", O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
2606 if (s->proc_kmsg_fd < 0) {
2607 log_warning("Failed to open /proc/kmsg, ignoring: %m");
2608 return 0;
2609 }
2610
2611 zero(ev);
2612 ev.events = EPOLLIN;
2613 ev.data.fd = s->proc_kmsg_fd;
2614 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->proc_kmsg_fd, &ev) < 0) {
2615 log_error("Failed to add /proc/kmsg fd to epoll object: %m");
2616 return -errno;
2617 }
2618
2619 return 0;
2620 }
2621
2622 static int open_signalfd(Server *s) {
2623 sigset_t mask;
2624 struct epoll_event ev;
2625
2626 assert(s);
2627
2628 assert_se(sigemptyset(&mask) == 0);
2629 sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
2630 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
2631
2632 s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
2633 if (s->signal_fd < 0) {
2634 log_error("signalfd(): %m");
2635 return -errno;
2636 }
2637
2638 zero(ev);
2639 ev.events = EPOLLIN;
2640 ev.data.fd = s->signal_fd;
2641
2642 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
2643 log_error("epoll_ctl(): %m");
2644 return -errno;
2645 }
2646
2647 return 0;
2648 }
2649
2650 static int server_parse_proc_cmdline(Server *s) {
2651 char *line, *w, *state;
2652 int r;
2653 size_t l;
2654
2655 if (detect_container(NULL) > 0)
2656 return 0;
2657
2658 r = read_one_line_file("/proc/cmdline", &line);
2659 if (r < 0) {
2660 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
2661 return 0;
2662 }
2663
2664 FOREACH_WORD_QUOTED(w, l, line, state) {
2665 char *word;
2666
2667 word = strndup(w, l);
2668 if (!word) {
2669 r = -ENOMEM;
2670 goto finish;
2671 }
2672
2673 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
2674 r = parse_boolean(word + 35);
2675 if (r < 0)
2676 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
2677 else
2678 s->forward_to_syslog = r;
2679 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
2680 r = parse_boolean(word + 33);
2681 if (r < 0)
2682 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
2683 else
2684 s->forward_to_kmsg = r;
2685 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
2686 r = parse_boolean(word + 36);
2687 if (r < 0)
2688 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
2689 else
2690 s->forward_to_console = r;
2691 } else if (startswith(word, "systemd.journald"))
2692 log_warning("Invalid systemd.journald parameter. Ignoring.");
2693
2694 free(word);
2695 }
2696
2697 r = 0;
2698
2699 finish:
2700 free(line);
2701 return r;
2702 }
2703
2704 static int server_parse_config_file(Server *s) {
2705 FILE *f;
2706 const char *fn;
2707 int r;
2708
2709 assert(s);
2710
2711 fn = "/etc/systemd/journald.conf";
2712 f = fopen(fn, "re");
2713 if (!f) {
2714 if (errno == ENOENT)
2715 return 0;
2716
2717 log_warning("Failed to open configuration file %s: %m", fn);
2718 return -errno;
2719 }
2720
2721 r = config_parse(fn, f, "Journal\0", config_item_perf_lookup, (void*) journald_gperf_lookup, false, s);
2722 if (r < 0)
2723 log_warning("Failed to parse configuration file: %s", strerror(-r));
2724
2725 fclose(f);
2726
2727 return r;
2728 }
2729
2730 static int server_init(Server *s) {
2731 int n, r, fd;
2732
2733 assert(s);
2734
2735 zero(*s);
2736 s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->proc_kmsg_fd = -1;
2737 s->compress = true;
2738
2739 s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
2740 s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
2741
2742 s->forward_to_syslog = true;
2743
2744 s->max_level_store = LOG_DEBUG;
2745 s->max_level_syslog = LOG_DEBUG;
2746 s->max_level_kmsg = LOG_NOTICE;
2747 s->max_level_console = LOG_INFO;
2748
2749 memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
2750 memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
2751
2752 server_parse_config_file(s);
2753 server_parse_proc_cmdline(s);
2754
2755 s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
2756 if (!s->user_journals) {
2757 log_error("Out of memory.");
2758 return -ENOMEM;
2759 }
2760
2761 s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2762 if (s->epoll_fd < 0) {
2763 log_error("Failed to create epoll object: %m");
2764 return -errno;
2765 }
2766
2767 n = sd_listen_fds(true);
2768 if (n < 0) {
2769 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
2770 return n;
2771 }
2772
2773 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
2774
2775 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
2776
2777 if (s->native_fd >= 0) {
2778 log_error("Too many native sockets passed.");
2779 return -EINVAL;
2780 }
2781
2782 s->native_fd = fd;
2783
2784 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
2785
2786 if (s->stdout_fd >= 0) {
2787 log_error("Too many stdout sockets passed.");
2788 return -EINVAL;
2789 }
2790
2791 s->stdout_fd = fd;
2792
2793 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
2794
2795 if (s->syslog_fd >= 0) {
2796 log_error("Too many /dev/log sockets passed.");
2797 return -EINVAL;
2798 }
2799
2800 s->syslog_fd = fd;
2801
2802 } else {
2803 log_error("Unknown socket passed.");
2804 return -EINVAL;
2805 }
2806 }
2807
2808 r = open_syslog_socket(s);
2809 if (r < 0)
2810 return r;
2811
2812 r = open_native_socket(s);
2813 if (r < 0)
2814 return r;
2815
2816 r = open_stdout_socket(s);
2817 if (r < 0)
2818 return r;
2819
2820 r = open_proc_kmsg(s);
2821 if (r < 0)
2822 return r;
2823
2824 r = open_signalfd(s);
2825 if (r < 0)
2826 return r;
2827
2828 s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
2829 if (!s->rate_limit)
2830 return -ENOMEM;
2831
2832 r = system_journal_open(s);
2833 if (r < 0)
2834 return r;
2835
2836 return 0;
2837 }
2838
2839 static void server_done(Server *s) {
2840 JournalFile *f;
2841 assert(s);
2842
2843 while (s->stdout_streams)
2844 stdout_stream_free(s->stdout_streams);
2845
2846 if (s->system_journal)
2847 journal_file_close(s->system_journal);
2848
2849 if (s->runtime_journal)
2850 journal_file_close(s->runtime_journal);
2851
2852 while ((f = hashmap_steal_first(s->user_journals)))
2853 journal_file_close(f);
2854
2855 hashmap_free(s->user_journals);
2856
2857 if (s->epoll_fd >= 0)
2858 close_nointr_nofail(s->epoll_fd);
2859
2860 if (s->signal_fd >= 0)
2861 close_nointr_nofail(s->signal_fd);
2862
2863 if (s->syslog_fd >= 0)
2864 close_nointr_nofail(s->syslog_fd);
2865
2866 if (s->native_fd >= 0)
2867 close_nointr_nofail(s->native_fd);
2868
2869 if (s->stdout_fd >= 0)
2870 close_nointr_nofail(s->stdout_fd);
2871
2872 if (s->proc_kmsg_fd >= 0)
2873 close_nointr_nofail(s->proc_kmsg_fd);
2874
2875 if (s->rate_limit)
2876 journal_rate_limit_free(s->rate_limit);
2877
2878 free(s->buffer);
2879 free(s->tty_path);
2880 }
2881
2882 int main(int argc, char *argv[]) {
2883 Server server;
2884 int r;
2885
2886 /* if (getppid() != 1) { */
2887 /* log_error("This program should be invoked by init only."); */
2888 /* return EXIT_FAILURE; */
2889 /* } */
2890
2891 if (argc > 1) {
2892 log_error("This program does not take arguments.");
2893 return EXIT_FAILURE;
2894 }
2895
2896 log_set_target(LOG_TARGET_SAFE);
2897 log_set_facility(LOG_SYSLOG);
2898 log_parse_environment();
2899 log_open();
2900
2901 umask(0022);
2902
2903 r = server_init(&server);
2904 if (r < 0)
2905 goto finish;
2906
2907 server_vacuum(&server);
2908 server_flush_to_var(&server);
2909 server_flush_proc_kmsg(&server);
2910
2911 log_debug("systemd-journald running as pid %lu", (unsigned long) getpid());
2912 driver_message(&server, SD_MESSAGE_JOURNAL_START, "Journal started");
2913
2914 sd_notify(false,
2915 "READY=1\n"
2916 "STATUS=Processing requests...");
2917
2918 for (;;) {
2919 struct epoll_event event;
2920
2921 r = epoll_wait(server.epoll_fd, &event, 1, -1);
2922 if (r < 0) {
2923
2924 if (errno == EINTR)
2925 continue;
2926
2927 log_error("epoll_wait() failed: %m");
2928 r = -errno;
2929 goto finish;
2930 } else if (r == 0)
2931 break;
2932
2933 r = process_event(&server, &event);
2934 if (r < 0)
2935 goto finish;
2936 else if (r == 0)
2937 break;
2938 }
2939
2940 log_debug("systemd-journald stopped as pid %lu", (unsigned long) getpid());
2941 driver_message(&server, SD_MESSAGE_JOURNAL_STOP, "Journal stopped");
2942
2943 finish:
2944 sd_notify(false,
2945 "STATUS=Shutting down...");
2946
2947 server_done(&server);
2948
2949 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
2950 }
Unnamed repository; edit this file 'description' to name the repository.