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