src/journal/journald-server.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/signalfd.h>
  23 #include <sys/ioctl.h>
  24 #include <linux/sockios.h>
  25 #include <sys/statvfs.h>
  26 #include <sys/mman.h>
  27
  28 #include <libudev.h>
  29 #include <systemd/sd-journal.h>
  30 #include <systemd/sd-messages.h>
  31 #include <systemd/sd-daemon.h>
  32
  33 #ifdef HAVE_LOGIND
  34 #include <systemd/sd-login.h>
  35 #endif
  36
  37 #include "mkdir.h"
  38 #include "hashmap.h"
  39 #include "journal-file.h"
  40 #include "socket-util.h"
  41 #include "cgroup-util.h"
  42 #include "list.h"
  43 #include "virt.h"
  44 #include "missing.h"
  45 #include "conf-parser.h"
  46 #include "journal-internal.h"
  47 #include "journal-vacuum.h"
  48 #include "journal-authenticate.h"
  49 #include "journald-server.h"
  50 #include "journald-rate-limit.h"
  51 #include "journald-kmsg.h"
  52 #include "journald-syslog.h"
  53 #include "journald-stream.h"
  54 #include "journald-console.h"
  55 #include "journald-native.h"
  56
  57 #ifdef HAVE_ACL
  58 #include <sys/acl.h>
  59 #include <acl/libacl.h>
  60 #include "acl-util.h"
  61 #endif
  62
  63 #ifdef HAVE_SELINUX
  64 #include <selinux/selinux.h>
  65 #endif
  66
  67 #define USER_JOURNALS_MAX 1024
  68
  69 #define DEFAULT_RATE_LIMIT_INTERVAL (10*USEC_PER_SEC)
  70 #define DEFAULT_RATE_LIMIT_BURST 200
  71
  72 #define RECHECK_AVAILABLE_SPACE_USEC (30*USEC_PER_SEC)
  73
  74 static const char* const storage_table[] = {
  75         [STORAGE_AUTO] = "auto",
  76         [STORAGE_VOLATILE] = "volatile",
  77         [STORAGE_PERSISTENT] = "persistent",
  78         [STORAGE_NONE] = "none"
  79 };
  80
  81 DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
  82 DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
  83
  84 static const char* const split_mode_table[] = {
  85         [SPLIT_NONE] = "none",
  86         [SPLIT_UID] = "uid",
  87         [SPLIT_LOGIN] = "login"
  88 };
  89
  90 DEFINE_STRING_TABLE_LOOKUP(split_mode, SplitMode);
  91 DEFINE_CONFIG_PARSE_ENUM(config_parse_split_mode, split_mode, SplitMode, "Failed to parse split mode setting");
  92
  93 static uint64_t available_space(Server *s) {
  94         char ids[33];
  95         char _cleanup_free_ *p = NULL;
  96         const char *f;
  97         sd_id128_t machine;
  98         struct statvfs ss;
  99         uint64_t sum = 0, avail = 0, ss_avail = 0;
 100         int r;
 101         DIR _cleanup_closedir_ *d = NULL;
 102         usec_t ts;
 103         JournalMetrics *m;
 104
 105         ts = now(CLOCK_MONOTONIC);
 106
 107         if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts)
 108                 return s->cached_available_space;
 109
 110         r = sd_id128_get_machine(&machine);
 111         if (r < 0)
 112                 return 0;
 113
 114         if (s->system_journal) {
 115                 f = "/var/log/journal/";
 116                 m = &s->system_metrics;
 117         } else {
 118                 f = "/run/log/journal/";
 119                 m = &s->runtime_metrics;
 120         }
 121
 122         assert(m);
 123
 124         p = strappend(f, sd_id128_to_string(machine, ids));
 125         if (!p)
 126                 return 0;
 127
 128         d = opendir(p);
 129         if (!d)
 130                 return 0;
 131
 132         if (fstatvfs(dirfd(d), &ss) < 0)
 133                 return 0;
 134
 135         for (;;) {
 136                 struct stat st;
 137                 struct dirent *de;
 138                 union dirent_storage buf;
 139
 140                 r = readdir_r(d, &buf.de, &de);
 141                 if (r != 0)
 142                         break;
 143
 144                 if (!de)
 145                         break;
 146
 147                 if (!endswith(de->d_name, ".journal") &&
 148                     !endswith(de->d_name, ".journal~"))
 149                         continue;
 150
 151                 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
 152                         continue;
 153
 154                 if (!S_ISREG(st.st_mode))
 155                         continue;
 156
 157                 sum += (uint64_t) st.st_blocks * 512UL;
 158         }
 159
 160         avail = sum >= m->max_use ? 0 : m->max_use - sum;
 161
 162         ss_avail = ss.f_bsize * ss.f_bavail;
 163
 164         ss_avail = ss_avail < m->keep_free ? 0 : ss_avail - m->keep_free;
 165
 166         if (ss_avail < avail)
 167                 avail = ss_avail;
 168
 169         s->cached_available_space = avail;
 170         s->cached_available_space_timestamp = ts;
 171
 172         return avail;
 173 }
 174
 175 static void server_read_file_gid(Server *s) {
 176         const char *adm = "adm";
 177         int r;
 178
 179         assert(s);
 180
 181         if (s->file_gid_valid)
 182                 return;
 183
 184         r = get_group_creds(&adm, &s->file_gid);
 185         if (r < 0)
 186                 log_warning("Failed to resolve 'adm' group: %s", strerror(-r));
 187
 188         /* if we couldn't read the gid, then it will be 0, but that's
 189          * fine and we shouldn't try to resolve the group again, so
 190          * let's just pretend it worked right-away. */
 191         s->file_gid_valid = true;
 192 }
 193
 194 void server_fix_perms(Server *s, JournalFile *f, uid_t uid) {
 195         int r;
 196 #ifdef HAVE_ACL
 197         acl_t acl;
 198         acl_entry_t entry;
 199         acl_permset_t permset;
 200 #endif
 201
 202         assert(f);
 203
 204         server_read_file_gid(s);
 205
 206         r = fchmod_and_fchown(f->fd, 0640, 0, s->file_gid);
 207         if (r < 0)
 208                 log_warning("Failed to fix access mode/rights on %s, ignoring: %s", f->path, strerror(-r));
 209
 210 #ifdef HAVE_ACL
 211         if (uid <= 0)
 212                 return;
 213
 214         acl = acl_get_fd(f->fd);
 215         if (!acl) {
 216                 log_warning("Failed to read ACL on %s, ignoring: %m", f->path);
 217                 return;
 218         }
 219
 220         r = acl_find_uid(acl, uid, &entry);
 221         if (r <= 0) {
 222
 223                 if (acl_create_entry(&acl, &entry) < 0 ||
 224                     acl_set_tag_type(entry, ACL_USER) < 0 ||
 225                     acl_set_qualifier(entry, &uid) < 0) {
 226                         log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
 227                         goto finish;
 228                 }
 229         }
 230
 231         if (acl_get_permset(entry, &permset) < 0 ||
 232             acl_add_perm(permset, ACL_READ) < 0 ||
 233             acl_calc_mask(&acl) < 0) {
 234                 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
 235                 goto finish;
 236         }
 237
 238         if (acl_set_fd(f->fd, acl) < 0)
 239                 log_warning("Failed to set ACL on %s, ignoring: %m", f->path);
 240
 241 finish:
 242         acl_free(acl);
 243 #endif
 244 }
 245
 246 static JournalFile* find_journal(Server *s, uid_t uid) {
 247         char *p;
 248         int r;
 249         JournalFile *f;
 250         sd_id128_t machine;
 251
 252         assert(s);
 253
 254         /* We split up user logs only on /var, not on /run. If the
 255          * runtime file is open, we write to it exclusively, in order
 256          * to guarantee proper order as soon as we flush /run to
 257          * /var and close the runtime file. */
 258
 259         if (s->runtime_journal)
 260                 return s->runtime_journal;
 261
 262         if (uid <= 0)
 263                 return s->system_journal;
 264
 265         r = sd_id128_get_machine(&machine);
 266         if (r < 0)
 267                 return s->system_journal;
 268
 269         f = hashmap_get(s->user_journals, UINT32_TO_PTR(uid));
 270         if (f)
 271                 return f;
 272
 273         if (asprintf(&p, "/var/log/journal/" SD_ID128_FORMAT_STR "/user-%lu.journal",
 274                      SD_ID128_FORMAT_VAL(machine), (unsigned long) uid) < 0)
 275                 return s->system_journal;
 276
 277         while (hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) {
 278                 /* Too many open? Then let's close one */
 279                 f = hashmap_steal_first(s->user_journals);
 280                 assert(f);
 281                 journal_file_close(f);
 282         }
 283
 284         r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, s->system_journal, &f);
 285         free(p);
 286
 287         if (r < 0)
 288                 return s->system_journal;
 289
 290         server_fix_perms(s, f, uid);
 291
 292         r = hashmap_put(s->user_journals, UINT32_TO_PTR(uid), f);
 293         if (r < 0) {
 294                 journal_file_close(f);
 295                 return s->system_journal;
 296         }
 297
 298         return f;
 299 }
 300
 301 void server_rotate(Server *s) {
 302         JournalFile *f;
 303         void *k;
 304         Iterator i;
 305         int r;
 306
 307         log_debug("Rotating...");
 308
 309         if (s->runtime_journal) {
 310                 r = journal_file_rotate(&s->runtime_journal, s->compress, false);
 311                 if (r < 0)
 312                         if (s->runtime_journal)
 313                                 log_error("Failed to rotate %s: %s", s->runtime_journal->path, strerror(-r));
 314                         else
 315                                 log_error("Failed to create new runtime journal: %s", strerror(-r));
 316                 else
 317                         server_fix_perms(s, s->runtime_journal, 0);
 318         }
 319
 320         if (s->system_journal) {
 321                 r = journal_file_rotate(&s->system_journal, s->compress, s->seal);
 322                 if (r < 0)
 323                         if (s->system_journal)
 324                                 log_error("Failed to rotate %s: %s", s->system_journal->path, strerror(-r));
 325                         else
 326                                 log_error("Failed to create new system journal: %s", strerror(-r));
 327
 328                 else
 329                         server_fix_perms(s, s->system_journal, 0);
 330         }
 331
 332         HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
 333                 r = journal_file_rotate(&f, s->compress, s->seal);
 334                 if (r < 0)
 335                         if (f)
 336                                 log_error("Failed to rotate %s: %s", f->path, strerror(-r));
 337                         else
 338                                 log_error("Failed to create user journal: %s", strerror(-r));
 339                 else {
 340                         hashmap_replace(s->user_journals, k, f);
 341                         server_fix_perms(s, f, PTR_TO_UINT32(k));
 342                 }
 343         }
 344 }
 345
 346 void server_vacuum(Server *s) {
 347         char *p;
 348         char ids[33];
 349         sd_id128_t machine;
 350         int r;
 351
 352         log_debug("Vacuuming...");
 353
 354         s->oldest_file_usec = 0;
 355
 356         r = sd_id128_get_machine(&machine);
 357         if (r < 0) {
 358                 log_error("Failed to get machine ID: %s", strerror(-r));
 359                 return;
 360         }
 361
 362         sd_id128_to_string(machine, ids);
 363
 364         if (s->system_journal) {
 365                 p = strappend("/var/log/journal/", ids);
 366                 if (!p) {
 367                         log_oom();
 368                         return;
 369                 }
 370
 371                 r = journal_directory_vacuum(p, s->system_metrics.max_use, s->system_metrics.keep_free, s->max_retention_usec, &s->oldest_file_usec);
 372                 if (r < 0 && r != -ENOENT)
 373                         log_error("Failed to vacuum %s: %s", p, strerror(-r));
 374                 free(p);
 375         }
 376
 377         if (s->runtime_journal) {
 378                 p = strappend("/run/log/journal/", ids);
 379                 if (!p) {
 380                         log_oom();
 381                         return;
 382                 }
 383
 384                 r = journal_directory_vacuum(p, s->runtime_metrics.max_use, s->runtime_metrics.keep_free, s->max_retention_usec, &s->oldest_file_usec);
 385                 if (r < 0 && r != -ENOENT)
 386                         log_error("Failed to vacuum %s: %s", p, strerror(-r));
 387                 free(p);
 388         }
 389
 390         s->cached_available_space_timestamp = 0;
 391 }
 392
 393 static char *shortened_cgroup_path(pid_t pid) {
 394         int r;
 395         char _cleanup_free_ *process_path = NULL, *init_path = NULL;
 396         char *path;
 397
 398         assert(pid > 0);
 399
 400         r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, pid, &process_path);
 401         if (r < 0)
 402                 return NULL;
 403
 404         r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 1, &init_path);
 405         if (r < 0)
 406                 return NULL;
 407
 408         if (endswith(init_path, "/system"))
 409                 init_path[strlen(init_path) - 7] = 0;
 410         else if (streq(init_path, "/"))
 411                 init_path[0] = 0;
 412
 413         if (startswith(process_path, init_path)) {
 414                 path = strdup(process_path + strlen(init_path));
 415         } else {
 416                 path = process_path;
 417                 process_path = NULL;
 418         }
 419
 420         return path;
 421 }
 422
 423 bool shall_try_append_again(JournalFile *f, int r) {
 424
 425         /* -E2BIG            Hit configured limit
 426            -EFBIG            Hit fs limit
 427            -EDQUOT           Quota limit hit
 428            -ENOSPC           Disk full
 429            -EHOSTDOWN        Other machine
 430            -EBUSY            Unclean shutdown
 431            -EPROTONOSUPPORT  Unsupported feature
 432            -EBADMSG          Corrupted
 433            -ENODATA          Truncated
 434            -ESHUTDOWN        Already archived */
 435
 436         if (r == -E2BIG || r == -EFBIG || r == -EDQUOT || r == -ENOSPC)
 437                 log_debug("%s: Allocation limit reached, rotating.", f->path);
 438         else if (r == -EHOSTDOWN)
 439                 log_info("%s: Journal file from other machine, rotating.", f->path);
 440         else if (r == -EBUSY)
 441                 log_info("%s: Unclean shutdown, rotating.", f->path);
 442         else if (r == -EPROTONOSUPPORT)
 443                 log_info("%s: Unsupported feature, rotating.", f->path);
 444         else if (r == -EBADMSG || r == -ENODATA || r == ESHUTDOWN)
 445                 log_warning("%s: Journal file corrupted, rotating.", f->path);
 446         else
 447                 return false;
 448
 449         return true;
 450 }
 451
 452 static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n) {
 453         JournalFile *f;
 454         bool vacuumed = false;
 455         int r;
 456
 457         assert(s);
 458         assert(iovec);
 459         assert(n > 0);
 460
 461         f = find_journal(s, uid);
 462         if (!f)
 463                 return;
 464
 465         if (journal_file_rotate_suggested(f, s->max_file_usec)) {
 466                 log_debug("%s: Journal header limits reached or header out-of-date, rotating.", f->path);
 467                 server_rotate(s);
 468                 server_vacuum(s);
 469                 vacuumed = true;
 470
 471                 f = find_journal(s, uid);
 472                 if (!f)
 473                         return;
 474         }
 475
 476         r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
 477         if (r >= 0)
 478                 return;
 479
 480         if (vacuumed || !shall_try_append_again(f, r)) {
 481                 log_error("Failed to write entry, ignoring: %s", strerror(-r));
 482                 return;
 483         }
 484
 485         server_rotate(s);
 486         server_vacuum(s);
 487
 488         f = find_journal(s, uid);
 489         if (!f)
 490                 return;
 491
 492         log_debug("Retrying write.");
 493         r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
 494         if (r < 0)
 495                 log_error("Failed to write entry, ignoring: %s", strerror(-r));
 496 }
 497
 498 static void dispatch_message_real(
 499                 Server *s,
 500                 struct iovec *iovec, unsigned n, unsigned m,
 501                 struct ucred *ucred,
 502                 struct timeval *tv,
 503                 const char *label, size_t label_len,
 504                 const char *unit_id) {
 505
 506         char _cleanup_free_ *pid = NULL, *uid = NULL, *gid = NULL,
 507                 *source_time = NULL, *boot_id = NULL, *machine_id = NULL,
 508                 *comm = NULL, *cmdline = NULL, *hostname = NULL,
 509                 *audit_session = NULL, *audit_loginuid = NULL,
 510                 *exe = NULL, *cgroup = NULL, *session = NULL,
 511                 *owner_uid = NULL, *unit = NULL, *selinux_context = NULL;
 512
 513         char idbuf[33];
 514         sd_id128_t id;
 515         int r;
 516         char *t;
 517         uid_t loginuid = 0, realuid = 0;
 518         uid_t journal_uid;
 519         bool loginuid_valid = false;
 520
 521         assert(s);
 522         assert(iovec);
 523         assert(n > 0);
 524         assert(n + N_IOVEC_META_FIELDS <= m);
 525
 526         if (ucred) {
 527                 uint32_t audit;
 528 #ifdef HAVE_LOGIND
 529                 uid_t owner;
 530 #endif
 531
 532                 realuid = ucred->uid;
 533
 534                 if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0)
 535                         IOVEC_SET_STRING(iovec[n++], pid);
 536
 537                 if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0)
 538                         IOVEC_SET_STRING(iovec[n++], uid);
 539
 540                 if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0)
 541                         IOVEC_SET_STRING(iovec[n++], gid);
 542
 543                 r = get_process_comm(ucred->pid, &t);
 544                 if (r >= 0) {
 545                         comm = strappend("_COMM=", t);
 546                         free(t);
 547
 548                         if (comm)
 549                                 IOVEC_SET_STRING(iovec[n++], comm);
 550                 }
 551
 552                 r = get_process_exe(ucred->pid, &t);
 553                 if (r >= 0) {
 554                         exe = strappend("_EXE=", t);
 555                         free(t);
 556
 557                         if (exe)
 558                                 IOVEC_SET_STRING(iovec[n++], exe);
 559                 }
 560
 561                 r = get_process_cmdline(ucred->pid, 0, false, &t);
 562                 if (r >= 0) {
 563                         cmdline = strappend("_CMDLINE=", t);
 564                         free(t);
 565
 566                         if (cmdline)
 567                                 IOVEC_SET_STRING(iovec[n++], cmdline);
 568                 }
 569
 570                 r = audit_session_from_pid(ucred->pid, &audit);
 571                 if (r >= 0)
 572                         if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0)
 573                                 IOVEC_SET_STRING(iovec[n++], audit_session);
 574
 575                 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
 576                 if (r >= 0) {
 577                         loginuid_valid = true;
 578                         if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0)
 579                                 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
 580                 }
 581
 582                 t = shortened_cgroup_path(ucred->pid);
 583                 if (t) {
 584                         cgroup = strappend("_SYSTEMD_CGROUP=", t);
 585                         free(t);
 586
 587                         if (cgroup)
 588                                 IOVEC_SET_STRING(iovec[n++], cgroup);
 589                 }
 590
 591 #ifdef HAVE_LOGIND
 592                 if (sd_pid_get_session(ucred->pid, &t) >= 0) {
 593                         session = strappend("_SYSTEMD_SESSION=", t);
 594                         free(t);
 595
 596                         if (session)
 597                                 IOVEC_SET_STRING(iovec[n++], session);
 598                 }
 599
 600                 if (sd_pid_get_owner_uid(ucred->uid, &owner) >= 0)
 601                         if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0)
 602                                 IOVEC_SET_STRING(iovec[n++], owner_uid);
 603 #endif
 604
 605                 if (cg_pid_get_unit(ucred->pid, &t) >= 0) {
 606                         unit = strappend("_SYSTEMD_UNIT=", t);
 607                         free(t);
 608                 } else if (cg_pid_get_user_unit(ucred->pid, &t) >= 0) {
 609                         unit = strappend("_SYSTEMD_USER_UNIT=", t);
 610                         free(t);
 611                 } else if (unit_id) {
 612                         if (session)
 613                                 unit = strappend("_SYSTEMD_USER_UNIT=", unit_id);
 614                         else
 615                                 unit = strappend("_SYSTEMD_UNIT=", unit_id);
 616                 }
 617
 618                 if (unit)
 619                         IOVEC_SET_STRING(iovec[n++], unit);
 620
 621 #ifdef HAVE_SELINUX
 622                 if (label) {
 623                         selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len);
 624                         if (selinux_context) {
 625                                 memcpy(selinux_context, "_SELINUX_CONTEXT=", sizeof("_SELINUX_CONTEXT=")-1);
 626                                 memcpy(selinux_context+sizeof("_SELINUX_CONTEXT=")-1, label, label_len);
 627                                 selinux_context[sizeof("_SELINUX_CONTEXT=")-1+label_len] = 0;
 628                                 IOVEC_SET_STRING(iovec[n++], selinux_context);
 629                         }
 630                 } else {
 631                         security_context_t con;
 632
 633                         if (getpidcon(ucred->pid, &con) >= 0) {
 634                                 selinux_context = strappend("_SELINUX_CONTEXT=", con);
 635                                 if (selinux_context)
 636                                         IOVEC_SET_STRING(iovec[n++], selinux_context);
 637
 638                                 freecon(con);
 639                         }
 640                 }
 641 #endif
 642         }
 643
 644         if (tv) {
 645                 if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu",
 646                              (unsigned long long) timeval_load(tv)) >= 0)
 647                         IOVEC_SET_STRING(iovec[n++], source_time);
 648         }
 649
 650         /* Note that strictly speaking storing the boot id here is
 651          * redundant since the entry includes this in-line
 652          * anyway. However, we need this indexed, too. */
 653         r = sd_id128_get_boot(&id);
 654         if (r >= 0)
 655                 if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
 656                         IOVEC_SET_STRING(iovec[n++], boot_id);
 657
 658         r = sd_id128_get_machine(&id);
 659         if (r >= 0)
 660                 if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
 661                         IOVEC_SET_STRING(iovec[n++], machine_id);
 662
 663         t = gethostname_malloc();
 664         if (t) {
 665                 hostname = strappend("_HOSTNAME=", t);
 666                 free(t);
 667                 if (hostname)
 668                         IOVEC_SET_STRING(iovec[n++], hostname);
 669         }
 670
 671         assert(n <= m);
 672
 673         if (s->split_mode == SPLIT_NONE)
 674                 journal_uid = 0;
 675         else if (s->split_mode == SPLIT_UID || realuid == 0 || !loginuid_valid)
 676                 journal_uid = realuid;
 677         else
 678                 journal_uid = loginuid;
 679
 680         write_to_journal(s, journal_uid, iovec, n);
 681 }
 682
 683 void server_driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
 684         char mid[11 + 32 + 1];
 685         char buffer[16 + LINE_MAX + 1];
 686         struct iovec iovec[N_IOVEC_META_FIELDS + 4];
 687         int n = 0;
 688         va_list ap;
 689         struct ucred ucred;
 690
 691         assert(s);
 692         assert(format);
 693
 694         IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
 695         IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
 696
 697         memcpy(buffer, "MESSAGE=", 8);
 698         va_start(ap, format);
 699         vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
 700         va_end(ap);
 701         char_array_0(buffer);
 702         IOVEC_SET_STRING(iovec[n++], buffer);
 703
 704         if (!sd_id128_equal(message_id, SD_ID128_NULL)) {
 705                 snprintf(mid, sizeof(mid), MESSAGE_ID(message_id));
 706                 char_array_0(mid);
 707                 IOVEC_SET_STRING(iovec[n++], mid);
 708         }
 709
 710         zero(ucred);
 711         ucred.pid = getpid();
 712         ucred.uid = getuid();
 713         ucred.gid = getgid();
 714
 715         dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
 716 }
 717
 718 void server_dispatch_message(
 719                 Server *s,
 720                 struct iovec *iovec, unsigned n, unsigned m,
 721                 struct ucred *ucred,
 722                 struct timeval *tv,
 723                 const char *label, size_t label_len,
 724                 const char *unit_id,
 725                 int priority) {
 726
 727         int rl;
 728         char _cleanup_free_ *path = NULL;
 729         char *c;
 730
 731         assert(s);
 732         assert(iovec || n == 0);
 733
 734         if (n == 0)
 735                 return;
 736
 737         if (LOG_PRI(priority) > s->max_level_store)
 738                 return;
 739
 740         if (!ucred)
 741                 goto finish;
 742
 743         path = shortened_cgroup_path(ucred->pid);
 744         if (!path)
 745                 goto finish;
 746
 747         /* example: /user/lennart/3/foobar
 748          *          /system/dbus.service/foobar
 749          *
 750          * So let's cut of everything past the third /, since that is
 751          * where user directories start */
 752
 753         c = strchr(path, '/');
 754         if (c) {
 755                 c = strchr(c+1, '/');
 756                 if (c) {
 757                         c = strchr(c+1, '/');
 758                         if (c)
 759                                 *c = 0;
 760                 }
 761         }
 762
 763         rl = journal_rate_limit_test(s->rate_limit, path,
 764                                      priority & LOG_PRIMASK, available_space(s));
 765
 766         if (rl == 0)
 767                 return;
 768
 769         /* Write a suppression message if we suppressed something */
 770         if (rl > 1)
 771                 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED,
 772                                       "Suppressed %u messages from %s", rl - 1, path);
 773
 774 finish:
 775         dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
 776 }
 777
 778
 779 static int system_journal_open(Server *s) {
 780         int r;
 781         char *fn;
 782         sd_id128_t machine;
 783         char ids[33];
 784
 785         r = sd_id128_get_machine(&machine);
 786         if (r < 0)
 787                 return r;
 788
 789         sd_id128_to_string(machine, ids);
 790
 791         if (!s->system_journal &&
 792             (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
 793             access("/run/systemd/journal/flushed", F_OK) >= 0) {
 794
 795                 /* If in auto mode: first try to create the machine
 796                  * path, but not the prefix.
 797                  *
 798                  * If in persistent mode: create /var/log/journal and
 799                  * the machine path */
 800
 801                 if (s->storage == STORAGE_PERSISTENT)
 802                         (void) mkdir("/var/log/journal/", 0755);
 803
 804                 fn = strappend("/var/log/journal/", ids);
 805                 if (!fn)
 806                         return -ENOMEM;
 807
 808                 (void) mkdir(fn, 0755);
 809                 free(fn);
 810
 811                 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
 812                 if (!fn)
 813                         return -ENOMEM;
 814
 815                 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
 816                 free(fn);
 817
 818                 if (r >= 0) {
 819                         char fb[FORMAT_BYTES_MAX];
 820
 821                         server_fix_perms(s, s->system_journal, 0);
 822                         server_driver_message(s, SD_ID128_NULL, "Allowing system journal files to grow to %s.",
 823                                               format_bytes(fb, sizeof(fb), s->system_metrics.max_use));
 824
 825                 } else if (r < 0) {
 826
 827                         if (r != -ENOENT && r != -EROFS)
 828                                 log_warning("Failed to open system journal: %s", strerror(-r));
 829
 830                         r = 0;
 831                 }
 832         }
 833
 834         if (!s->runtime_journal &&
 835             (s->storage != STORAGE_NONE)) {
 836
 837                 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
 838                 if (!fn)
 839                         return -ENOMEM;
 840
 841                 if (s->system_journal) {
 842
 843                         /* Try to open the runtime journal, but only
 844                          * if it already exists, so that we can flush
 845                          * it into the system journal */
 846
 847                         r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 848                         free(fn);
 849
 850                         if (r < 0) {
 851                                 if (r != -ENOENT)
 852                                         log_warning("Failed to open runtime journal: %s", strerror(-r));
 853
 854                                 r = 0;
 855                         }
 856
 857                 } else {
 858
 859                         /* OK, we really need the runtime journal, so create
 860                          * it if necessary. */
 861
 862                         (void) mkdir_parents(fn, 0755);
 863                         r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 864                         free(fn);
 865
 866                         if (r < 0) {
 867                                 log_error("Failed to open runtime journal: %s", strerror(-r));
 868                                 return r;
 869                         }
 870                 }
 871
 872                 if (s->runtime_journal) {
 873                         char fb[FORMAT_BYTES_MAX];
 874
 875                         server_fix_perms(s, s->runtime_journal, 0);
 876                         server_driver_message(s, SD_ID128_NULL, "Allowing runtime journal files to grow to %s.",
 877                                               format_bytes(fb, sizeof(fb), s->runtime_metrics.max_use));
 878                 }
 879         }
 880
 881         return r;
 882 }
 883
 884 int server_flush_to_var(Server *s) {
 885         int r;
 886         sd_id128_t machine;
 887         sd_journal *j = NULL;
 888
 889         assert(s);
 890
 891         if (s->storage != STORAGE_AUTO &&
 892             s->storage != STORAGE_PERSISTENT)
 893                 return 0;
 894
 895         if (!s->runtime_journal)
 896                 return 0;
 897
 898         system_journal_open(s);
 899
 900         if (!s->system_journal)
 901                 return 0;
 902
 903         log_debug("Flushing to /var...");
 904
 905         r = sd_id128_get_machine(&machine);
 906         if (r < 0) {
 907                 log_error("Failed to get machine id: %s", strerror(-r));
 908                 return r;
 909         }
 910
 911         r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
 912         if (r < 0) {
 913                 log_error("Failed to read runtime journal: %s", strerror(-r));
 914                 return r;
 915         }
 916
 917         sd_journal_set_data_threshold(j, 0);
 918
 919         SD_JOURNAL_FOREACH(j) {
 920                 Object *o = NULL;
 921                 JournalFile *f;
 922
 923                 f = j->current_file;
 924                 assert(f && f->current_offset > 0);
 925
 926                 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
 927                 if (r < 0) {
 928                         log_error("Can't read entry: %s", strerror(-r));
 929                         goto finish;
 930                 }
 931
 932                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
 933                 if (r >= 0)
 934                         continue;
 935
 936                 if (!shall_try_append_again(s->system_journal, r)) {
 937                         log_error("Can't write entry: %s", strerror(-r));
 938                         goto finish;
 939                 }
 940
 941                 server_rotate(s);
 942                 server_vacuum(s);
 943
 944                 log_debug("Retrying write.");
 945                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
 946                 if (r < 0) {
 947                         log_error("Can't write entry: %s", strerror(-r));
 948                         goto finish;
 949                 }
 950         }
 951
 952 finish:
 953         journal_file_post_change(s->system_journal);
 954
 955         journal_file_close(s->runtime_journal);
 956         s->runtime_journal = NULL;
 957
 958         if (r >= 0)
 959                 rm_rf("/run/log/journal", false, true, false);
 960
 961         if (j)
 962                 sd_journal_close(j);
 963
 964         return r;
 965 }
 966
 967 int process_event(Server *s, struct epoll_event *ev) {
 968         assert(s);
 969         assert(ev);
 970
 971         if (ev->data.fd == s->signal_fd) {
 972                 struct signalfd_siginfo sfsi;
 973                 ssize_t n;
 974
 975                 if (ev->events != EPOLLIN) {
 976                         log_error("Got invalid event from epoll.");
 977                         return -EIO;
 978                 }
 979
 980                 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
 981                 if (n != sizeof(sfsi)) {
 982
 983                         if (n >= 0)
 984                                 return -EIO;
 985
 986                         if (errno == EINTR || errno == EAGAIN)
 987                                 return 1;
 988
 989                         return -errno;
 990                 }
 991
 992                 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
 993
 994                 if (sfsi.ssi_signo == SIGUSR1) {
 995                         touch("/run/systemd/journal/flushed");
 996                         server_flush_to_var(s);
 997                         return 1;
 998                 }
 999
1000                 if (sfsi.ssi_signo == SIGUSR2) {
1001                         server_rotate(s);
1002                         server_vacuum(s);
1003                         return 1;
1004                 }
1005
1006                 return 0;
1007
1008         } else if (ev->data.fd == s->dev_kmsg_fd) {
1009                 int r;
1010
1011                 if (ev->events != EPOLLIN) {
1012                         log_error("Got invalid event from epoll.");
1013                         return -EIO;
1014                 }
1015
1016                 r = server_read_dev_kmsg(s);
1017                 if (r < 0)
1018                         return r;
1019
1020                 return 1;
1021
1022         } else if (ev->data.fd == s->native_fd ||
1023                    ev->data.fd == s->syslog_fd) {
1024
1025                 if (ev->events != EPOLLIN) {
1026                         log_error("Got invalid event from epoll.");
1027                         return -EIO;
1028                 }
1029
1030                 for (;;) {
1031                         struct msghdr msghdr;
1032                         struct iovec iovec;
1033                         struct ucred *ucred = NULL;
1034                         struct timeval *tv = NULL;
1035                         struct cmsghdr *cmsg;
1036                         char *label = NULL;
1037                         size_t label_len = 0;
1038                         union {
1039                                 struct cmsghdr cmsghdr;
1040
1041                                 /* We use NAME_MAX space for the
1042                                  * SELinux label here. The kernel
1043                                  * currently enforces no limit, but
1044                                  * according to suggestions from the
1045                                  * SELinux people this will change and
1046                                  * it will probably be identical to
1047                                  * NAME_MAX. For now we use that, but
1048                                  * this should be updated one day when
1049                                  * the final limit is known.*/
1050                                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1051                                             CMSG_SPACE(sizeof(struct timeval)) +
1052                                             CMSG_SPACE(sizeof(int)) + /* fd */
1053                                             CMSG_SPACE(NAME_MAX)]; /* selinux label */
1054                         } control;
1055                         ssize_t n;
1056                         int v;
1057                         int *fds = NULL;
1058                         unsigned n_fds = 0;
1059
1060                         if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
1061                                 log_error("SIOCINQ failed: %m");
1062                                 return -errno;
1063                         }
1064
1065                         if (s->buffer_size < (size_t) v) {
1066                                 void *b;
1067                                 size_t l;
1068
1069                                 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
1070                                 b = realloc(s->buffer, l+1);
1071
1072                                 if (!b) {
1073                                         log_error("Couldn't increase buffer.");
1074                                         return -ENOMEM;
1075                                 }
1076
1077                                 s->buffer_size = l;
1078                                 s->buffer = b;
1079                         }
1080
1081                         zero(iovec);
1082                         iovec.iov_base = s->buffer;
1083                         iovec.iov_len = s->buffer_size;
1084
1085                         zero(control);
1086                         zero(msghdr);
1087                         msghdr.msg_iov = &iovec;
1088                         msghdr.msg_iovlen = 1;
1089                         msghdr.msg_control = &control;
1090                         msghdr.msg_controllen = sizeof(control);
1091
1092                         n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1093                         if (n < 0) {
1094
1095                                 if (errno == EINTR || errno == EAGAIN)
1096                                         return 1;
1097
1098                                 log_error("recvmsg() failed: %m");
1099                                 return -errno;
1100                         }
1101
1102                         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1103
1104                                 if (cmsg->cmsg_level == SOL_SOCKET &&
1105                                     cmsg->cmsg_type == SCM_CREDENTIALS &&
1106                                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1107                                         ucred = (struct ucred*) CMSG_DATA(cmsg);
1108                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1109                                          cmsg->cmsg_type == SCM_SECURITY) {
1110                                         label = (char*) CMSG_DATA(cmsg);
1111                                         label_len = cmsg->cmsg_len - CMSG_LEN(0);
1112                                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1113                                          cmsg->cmsg_type == SO_TIMESTAMP &&
1114                                          cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1115                                         tv = (struct timeval*) CMSG_DATA(cmsg);
1116                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1117                                          cmsg->cmsg_type == SCM_RIGHTS) {
1118                                         fds = (int*) CMSG_DATA(cmsg);
1119                                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1120                                 }
1121                         }
1122
1123                         if (ev->data.fd == s->syslog_fd) {
1124                                 char *e;
1125
1126                                 if (n > 0 && n_fds == 0) {
1127                                         e = memchr(s->buffer, '\n', n);
1128                                         if (e)
1129                                                 *e = 0;
1130                                         else
1131                                                 s->buffer[n] = 0;
1132
1133                                         server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1134                                 } else if (n_fds > 0)
1135                                         log_warning("Got file descriptors via syslog socket. Ignoring.");
1136
1137                         } else {
1138                                 if (n > 0 && n_fds == 0)
1139                                         server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1140                                 else if (n == 0 && n_fds == 1)
1141                                         server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1142                                 else if (n_fds > 0)
1143                                         log_warning("Got too many file descriptors via native socket. Ignoring.");
1144                         }
1145
1146                         close_many(fds, n_fds);
1147                 }
1148
1149                 return 1;
1150
1151         } else if (ev->data.fd == s->stdout_fd) {
1152
1153                 if (ev->events != EPOLLIN) {
1154                         log_error("Got invalid event from epoll.");
1155                         return -EIO;
1156                 }
1157
1158                 stdout_stream_new(s);
1159                 return 1;
1160
1161         } else {
1162                 StdoutStream *stream;
1163
1164                 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
1165                         log_error("Got invalid event from epoll.");
1166                         return -EIO;
1167                 }
1168
1169                 /* If it is none of the well-known fds, it must be an
1170                  * stdout stream fd. Note that this is a bit ugly here
1171                  * (since we rely that none of the well-known fds
1172                  * could be interpreted as pointer), but nonetheless
1173                  * safe, since the well-known fds would never get an
1174                  * fd > 4096, i.e. beyond the first memory page */
1175
1176                 stream = ev->data.ptr;
1177
1178                 if (stdout_stream_process(stream) <= 0)
1179                         stdout_stream_free(stream);
1180
1181                 return 1;
1182         }
1183
1184         log_error("Unknown event.");
1185         return 0;
1186 }
1187
1188 static int open_signalfd(Server *s) {
1189         sigset_t mask;
1190         struct epoll_event ev;
1191
1192         assert(s);
1193
1194         assert_se(sigemptyset(&mask) == 0);
1195         sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1196         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1197
1198         s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1199         if (s->signal_fd < 0) {
1200                 log_error("signalfd(): %m");
1201                 return -errno;
1202         }
1203
1204         zero(ev);
1205         ev.events = EPOLLIN;
1206         ev.data.fd = s->signal_fd;
1207
1208         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
1209                 log_error("epoll_ctl(): %m");
1210                 return -errno;
1211         }
1212
1213         return 0;
1214 }
1215
1216 static int server_parse_proc_cmdline(Server *s) {
1217         char _cleanup_free_ *line = NULL;
1218         char *w, *state;
1219         int r;
1220         size_t l;
1221
1222         if (detect_container(NULL) > 0)
1223                 return 0;
1224
1225         r = read_one_line_file("/proc/cmdline", &line);
1226         if (r < 0) {
1227                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1228                 return 0;
1229         }
1230
1231         FOREACH_WORD_QUOTED(w, l, line, state) {
1232                 char _cleanup_free_ *word;
1233
1234                 word = strndup(w, l);
1235                 if (!word)
1236                         return -ENOMEM;
1237
1238                 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1239                         r = parse_boolean(word + 35);
1240                         if (r < 0)
1241                                 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1242                         else
1243                                 s->forward_to_syslog = r;
1244                 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1245                         r = parse_boolean(word + 33);
1246                         if (r < 0)
1247                                 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1248                         else
1249                                 s->forward_to_kmsg = r;
1250                 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1251                         r = parse_boolean(word + 36);
1252                         if (r < 0)
1253                                 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1254                         else
1255                                 s->forward_to_console = r;
1256                 } else if (startswith(word, "systemd.journald"))
1257                         log_warning("Invalid systemd.journald parameter. Ignoring.");
1258         }
1259
1260         return 0;
1261 }
1262
1263 static int server_parse_config_file(Server *s) {
1264         static const char *fn = "/etc/systemd/journald.conf";
1265         FILE _cleanup_fclose_ *f = NULL;
1266         int r;
1267
1268         assert(s);
1269
1270         f = fopen(fn, "re");
1271         if (!f) {
1272                 if (errno == ENOENT)
1273                         return 0;
1274
1275                 log_warning("Failed to open configuration file %s: %m", fn);
1276                 return -errno;
1277         }
1278
1279         r = config_parse(fn, f, "Journal\0", config_item_perf_lookup,
1280                          (void*) journald_gperf_lookup, false, s);
1281         if (r < 0)
1282                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1283
1284         return r;
1285 }
1286
1287 int server_init(Server *s) {
1288         int n, r, fd;
1289
1290         assert(s);
1291
1292         zero(*s);
1293         s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
1294         s->compress = true;
1295         s->seal = true;
1296
1297         s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1298         s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1299
1300         s->forward_to_syslog = true;
1301
1302         s->max_level_store = LOG_DEBUG;
1303         s->max_level_syslog = LOG_DEBUG;
1304         s->max_level_kmsg = LOG_NOTICE;
1305         s->max_level_console = LOG_INFO;
1306
1307         memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1308         memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1309
1310         server_parse_config_file(s);
1311         server_parse_proc_cmdline(s);
1312
1313         mkdir_p("/run/systemd/journal", 0755);
1314
1315         s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1316         if (!s->user_journals)
1317                 return log_oom();
1318
1319         s->mmap = mmap_cache_new();
1320         if (!s->mmap)
1321                 return log_oom();
1322
1323         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1324         if (s->epoll_fd < 0) {
1325                 log_error("Failed to create epoll object: %m");
1326                 return -errno;
1327         }
1328
1329         n = sd_listen_fds(true);
1330         if (n < 0) {
1331                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1332                 return n;
1333         }
1334
1335         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1336
1337                 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1338
1339                         if (s->native_fd >= 0) {
1340                                 log_error("Too many native sockets passed.");
1341                                 return -EINVAL;
1342                         }
1343
1344                         s->native_fd = fd;
1345
1346                 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1347
1348                         if (s->stdout_fd >= 0) {
1349                                 log_error("Too many stdout sockets passed.");
1350                                 return -EINVAL;
1351                         }
1352
1353                         s->stdout_fd = fd;
1354
1355                 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1356
1357                         if (s->syslog_fd >= 0) {
1358                                 log_error("Too many /dev/log sockets passed.");
1359                                 return -EINVAL;
1360                         }
1361
1362                         s->syslog_fd = fd;
1363
1364                 } else {
1365                         log_error("Unknown socket passed.");
1366                         return -EINVAL;
1367                 }
1368         }
1369
1370         r = server_open_syslog_socket(s);
1371         if (r < 0)
1372                 return r;
1373
1374         r = server_open_native_socket(s);
1375         if (r < 0)
1376                 return r;
1377
1378         r = server_open_stdout_socket(s);
1379         if (r < 0)
1380                 return r;
1381
1382         r = server_open_dev_kmsg(s);
1383         if (r < 0)
1384                 return r;
1385
1386         r = server_open_kernel_seqnum(s);
1387         if (r < 0)
1388                 return r;
1389
1390         r = open_signalfd(s);
1391         if (r < 0)
1392                 return r;
1393
1394         s->udev = udev_new();
1395         if (!s->udev)
1396                 return -ENOMEM;
1397
1398         s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
1399         if (!s->rate_limit)
1400                 return -ENOMEM;
1401
1402         r = system_journal_open(s);
1403         if (r < 0)
1404                 return r;
1405
1406         return 0;
1407 }
1408
1409 void server_maybe_append_tags(Server *s) {
1410 #ifdef HAVE_GCRYPT
1411         JournalFile *f;
1412         Iterator i;
1413         usec_t n;
1414
1415         n = now(CLOCK_REALTIME);
1416
1417         if (s->system_journal)
1418                 journal_file_maybe_append_tag(s->system_journal, n);
1419
1420         HASHMAP_FOREACH(f, s->user_journals, i)
1421                 journal_file_maybe_append_tag(f, n);
1422 #endif
1423 }
1424
1425 void server_done(Server *s) {
1426         JournalFile *f;
1427         assert(s);
1428
1429         while (s->stdout_streams)
1430                 stdout_stream_free(s->stdout_streams);
1431
1432         if (s->system_journal)
1433                 journal_file_close(s->system_journal);
1434
1435         if (s->runtime_journal)
1436                 journal_file_close(s->runtime_journal);
1437
1438         while ((f = hashmap_steal_first(s->user_journals)))
1439                 journal_file_close(f);
1440
1441         hashmap_free(s->user_journals);
1442
1443         if (s->epoll_fd >= 0)
1444                 close_nointr_nofail(s->epoll_fd);
1445
1446         if (s->signal_fd >= 0)
1447                 close_nointr_nofail(s->signal_fd);
1448
1449         if (s->syslog_fd >= 0)
1450                 close_nointr_nofail(s->syslog_fd);
1451
1452         if (s->native_fd >= 0)
1453                 close_nointr_nofail(s->native_fd);
1454
1455         if (s->stdout_fd >= 0)
1456                 close_nointr_nofail(s->stdout_fd);
1457
1458         if (s->dev_kmsg_fd >= 0)
1459                 close_nointr_nofail(s->dev_kmsg_fd);
1460
1461         if (s->rate_limit)
1462                 journal_rate_limit_free(s->rate_limit);
1463
1464         if (s->kernel_seqnum)
1465                 munmap(s->kernel_seqnum, sizeof(uint64_t));
1466
1467         free(s->buffer);
1468         free(s->tty_path);
1469
1470         if (s->mmap)
1471                 mmap_cache_unref(s->mmap);
1472
1473         if (s->udev)
1474                 udev_unref(s->udev);
1475 }