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