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 *g = "systemd-journal";
 178         int r;
 179
 180         assert(s);
 181
 182         if (s->file_gid_valid)
 183                 return;
 184
 185         r = get_group_creds(&g, &s->file_gid);
 186         if (r < 0)
 187                 log_warning("Failed to resolve '%s' group: %s", g, 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 realuid = 0, owner = 0, journal_uid;
 519         bool owner_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                 uid_t loginuid;
 529
 530                 realuid = ucred->uid;
 531
 532                 if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0)
 533                         IOVEC_SET_STRING(iovec[n++], pid);
 534
 535                 if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0)
 536                         IOVEC_SET_STRING(iovec[n++], uid);
 537
 538                 if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0)
 539                         IOVEC_SET_STRING(iovec[n++], gid);
 540
 541                 r = get_process_comm(ucred->pid, &t);
 542                 if (r >= 0) {
 543                         comm = strappend("_COMM=", t);
 544                         free(t);
 545
 546                         if (comm)
 547                                 IOVEC_SET_STRING(iovec[n++], comm);
 548                 }
 549
 550                 r = get_process_exe(ucred->pid, &t);
 551                 if (r >= 0) {
 552                         exe = strappend("_EXE=", t);
 553                         free(t);
 554
 555                         if (exe)
 556                                 IOVEC_SET_STRING(iovec[n++], exe);
 557                 }
 558
 559                 r = get_process_cmdline(ucred->pid, 0, false, &t);
 560                 if (r >= 0) {
 561                         cmdline = strappend("_CMDLINE=", t);
 562                         free(t);
 563
 564                         if (cmdline)
 565                                 IOVEC_SET_STRING(iovec[n++], cmdline);
 566                 }
 567
 568                 r = audit_session_from_pid(ucred->pid, &audit);
 569                 if (r >= 0)
 570                         if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0)
 571                                 IOVEC_SET_STRING(iovec[n++], audit_session);
 572
 573                 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
 574                 if (r >= 0)
 575                         if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0)
 576                                 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
 577
 578                 t = shortened_cgroup_path(ucred->pid);
 579                 if (t) {
 580                         cgroup = strappend("_SYSTEMD_CGROUP=", t);
 581                         free(t);
 582
 583                         if (cgroup)
 584                                 IOVEC_SET_STRING(iovec[n++], cgroup);
 585                 }
 586
 587 #ifdef HAVE_LOGIND
 588                 if (sd_pid_get_session(ucred->pid, &t) >= 0) {
 589                         session = strappend("_SYSTEMD_SESSION=", t);
 590                         free(t);
 591
 592                         if (session)
 593                                 IOVEC_SET_STRING(iovec[n++], session);
 594                 }
 595
 596                 if (sd_pid_get_owner_uid(ucred->uid, &owner) >= 0) {
 597                         owner_valid = true;
 598                         if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0)
 599                                 IOVEC_SET_STRING(iovec[n++], owner_uid);
 600                 }
 601 #endif
 602
 603                 if (cg_pid_get_unit(ucred->pid, &t) >= 0) {
 604                         unit = strappend("_SYSTEMD_UNIT=", t);
 605                         free(t);
 606                 } else if (cg_pid_get_user_unit(ucred->pid, &t) >= 0) {
 607                         unit = strappend("_SYSTEMD_USER_UNIT=", t);
 608                         free(t);
 609                 } else if (unit_id) {
 610                         if (session)
 611                                 unit = strappend("_SYSTEMD_USER_UNIT=", unit_id);
 612                         else
 613                                 unit = strappend("_SYSTEMD_UNIT=", unit_id);
 614                 }
 615
 616                 if (unit)
 617                         IOVEC_SET_STRING(iovec[n++], unit);
 618
 619 #ifdef HAVE_SELINUX
 620                 if (label) {
 621                         selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len);
 622                         if (selinux_context) {
 623                                 *((char*) mempcpy(stpcpy(selinux_context, "_SELINUX_CONTEXT="), label, label_len)) = 0;
 624                                 IOVEC_SET_STRING(iovec[n++], selinux_context);
 625                         }
 626                 } else {
 627                         security_context_t con;
 628
 629                         if (getpidcon(ucred->pid, &con) >= 0) {
 630                                 selinux_context = strappend("_SELINUX_CONTEXT=", con);
 631                                 if (selinux_context)
 632                                         IOVEC_SET_STRING(iovec[n++], selinux_context);
 633                                 freecon(con);
 634                         }
 635                 }
 636 #endif
 637         }
 638
 639         if (tv) {
 640                 if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu",
 641                              (unsigned long long) timeval_load(tv)) >= 0)
 642                         IOVEC_SET_STRING(iovec[n++], source_time);
 643         }
 644
 645         /* Note that strictly speaking storing the boot id here is
 646          * redundant since the entry includes this in-line
 647          * anyway. However, we need this indexed, too. */
 648         r = sd_id128_get_boot(&id);
 649         if (r >= 0)
 650                 if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
 651                         IOVEC_SET_STRING(iovec[n++], boot_id);
 652
 653         r = sd_id128_get_machine(&id);
 654         if (r >= 0)
 655                 if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
 656                         IOVEC_SET_STRING(iovec[n++], machine_id);
 657
 658         t = gethostname_malloc();
 659         if (t) {
 660                 hostname = strappend("_HOSTNAME=", t);
 661                 free(t);
 662                 if (hostname)
 663                         IOVEC_SET_STRING(iovec[n++], hostname);
 664         }
 665
 666         assert(n <= m);
 667
 668         if (s->split_mode == SPLIT_UID && realuid > 0)
 669                 /* Split up strictly by any UID */
 670                 journal_uid = realuid;
 671         else if (s->split_mode == SPLIT_LOGIN && realuid > 0 && owner_valid && owner > 0)
 672                 /* Split up by login UIDs, this avoids creation of
 673                  * individual journals for system UIDs.  We do this
 674                  * only if the realuid is not root, in order not to
 675                  * accidentally leak privileged information to the
 676                  * user that is logged by a privileged process that is
 677                  * part of an unprivileged session.*/
 678                 journal_uid = owner;
 679         else
 680                 journal_uid = 0;
 681
 682         write_to_journal(s, journal_uid, iovec, n);
 683 }
 684
 685 void server_driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
 686         char mid[11 + 32 + 1];
 687         char buffer[16 + LINE_MAX + 1];
 688         struct iovec iovec[N_IOVEC_META_FIELDS + 4];
 689         int n = 0;
 690         va_list ap;
 691         struct ucred ucred;
 692
 693         assert(s);
 694         assert(format);
 695
 696         IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
 697         IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
 698
 699         memcpy(buffer, "MESSAGE=", 8);
 700         va_start(ap, format);
 701         vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
 702         va_end(ap);
 703         char_array_0(buffer);
 704         IOVEC_SET_STRING(iovec[n++], buffer);
 705
 706         if (!sd_id128_equal(message_id, SD_ID128_NULL)) {
 707                 snprintf(mid, sizeof(mid), MESSAGE_ID(message_id));
 708                 char_array_0(mid);
 709                 IOVEC_SET_STRING(iovec[n++], mid);
 710         }
 711
 712         zero(ucred);
 713         ucred.pid = getpid();
 714         ucred.uid = getuid();
 715         ucred.gid = getgid();
 716
 717         dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
 718 }
 719
 720 void server_dispatch_message(
 721                 Server *s,
 722                 struct iovec *iovec, unsigned n, unsigned m,
 723                 struct ucred *ucred,
 724                 struct timeval *tv,
 725                 const char *label, size_t label_len,
 726                 const char *unit_id,
 727                 int priority) {
 728
 729         int rl;
 730         char _cleanup_free_ *path = NULL;
 731         char *c;
 732
 733         assert(s);
 734         assert(iovec || n == 0);
 735
 736         if (n == 0)
 737                 return;
 738
 739         if (LOG_PRI(priority) > s->max_level_store)
 740                 return;
 741
 742         if (!ucred)
 743                 goto finish;
 744
 745         path = shortened_cgroup_path(ucred->pid);
 746         if (!path)
 747                 goto finish;
 748
 749         /* example: /user/lennart/3/foobar
 750          *          /system/dbus.service/foobar
 751          *
 752          * So let's cut of everything past the third /, since that is
 753          * where user directories start */
 754
 755         c = strchr(path, '/');
 756         if (c) {
 757                 c = strchr(c+1, '/');
 758                 if (c) {
 759                         c = strchr(c+1, '/');
 760                         if (c)
 761                                 *c = 0;
 762                 }
 763         }
 764
 765         rl = journal_rate_limit_test(s->rate_limit, path,
 766                                      priority & LOG_PRIMASK, available_space(s));
 767
 768         if (rl == 0)
 769                 return;
 770
 771         /* Write a suppression message if we suppressed something */
 772         if (rl > 1)
 773                 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED,
 774                                       "Suppressed %u messages from %s", rl - 1, path);
 775
 776 finish:
 777         dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
 778 }
 779
 780
 781 static int system_journal_open(Server *s) {
 782         int r;
 783         char *fn;
 784         sd_id128_t machine;
 785         char ids[33];
 786
 787         r = sd_id128_get_machine(&machine);
 788         if (r < 0)
 789                 return r;
 790
 791         sd_id128_to_string(machine, ids);
 792
 793         if (!s->system_journal &&
 794             (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
 795             access("/run/systemd/journal/flushed", F_OK) >= 0) {
 796
 797                 /* If in auto mode: first try to create the machine
 798                  * path, but not the prefix.
 799                  *
 800                  * If in persistent mode: create /var/log/journal and
 801                  * the machine path */
 802
 803                 if (s->storage == STORAGE_PERSISTENT)
 804                         (void) mkdir("/var/log/journal/", 0755);
 805
 806                 fn = strappend("/var/log/journal/", ids);
 807                 if (!fn)
 808                         return -ENOMEM;
 809
 810                 (void) mkdir(fn, 0755);
 811                 free(fn);
 812
 813                 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
 814                 if (!fn)
 815                         return -ENOMEM;
 816
 817                 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
 818                 free(fn);
 819
 820                 if (r >= 0) {
 821                         char fb[FORMAT_BYTES_MAX];
 822
 823                         server_fix_perms(s, s->system_journal, 0);
 824                         server_driver_message(s, SD_ID128_NULL, "Allowing system journal files to grow to %s.",
 825                                               format_bytes(fb, sizeof(fb), s->system_metrics.max_use));
 826
 827                 } else if (r < 0) {
 828
 829                         if (r != -ENOENT && r != -EROFS)
 830                                 log_warning("Failed to open system journal: %s", strerror(-r));
 831
 832                         r = 0;
 833                 }
 834         }
 835
 836         if (!s->runtime_journal &&
 837             (s->storage != STORAGE_NONE)) {
 838
 839                 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
 840                 if (!fn)
 841                         return -ENOMEM;
 842
 843                 if (s->system_journal) {
 844
 845                         /* Try to open the runtime journal, but only
 846                          * if it already exists, so that we can flush
 847                          * it into the system journal */
 848
 849                         r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 850                         free(fn);
 851
 852                         if (r < 0) {
 853                                 if (r != -ENOENT)
 854                                         log_warning("Failed to open runtime journal: %s", strerror(-r));
 855
 856                                 r = 0;
 857                         }
 858
 859                 } else {
 860
 861                         /* OK, we really need the runtime journal, so create
 862                          * it if necessary. */
 863
 864                         (void) mkdir_parents(fn, 0755);
 865                         r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 866                         free(fn);
 867
 868                         if (r < 0) {
 869                                 log_error("Failed to open runtime journal: %s", strerror(-r));
 870                                 return r;
 871                         }
 872                 }
 873
 874                 if (s->runtime_journal) {
 875                         char fb[FORMAT_BYTES_MAX];
 876
 877                         server_fix_perms(s, s->runtime_journal, 0);
 878                         server_driver_message(s, SD_ID128_NULL, "Allowing runtime journal files to grow to %s.",
 879                                               format_bytes(fb, sizeof(fb), s->runtime_metrics.max_use));
 880                 }
 881         }
 882
 883         return r;
 884 }
 885
 886 int server_flush_to_var(Server *s) {
 887         int r;
 888         sd_id128_t machine;
 889         sd_journal *j = NULL;
 890
 891         assert(s);
 892
 893         if (s->storage != STORAGE_AUTO &&
 894             s->storage != STORAGE_PERSISTENT)
 895                 return 0;
 896
 897         if (!s->runtime_journal)
 898                 return 0;
 899
 900         system_journal_open(s);
 901
 902         if (!s->system_journal)
 903                 return 0;
 904
 905         log_debug("Flushing to /var...");
 906
 907         r = sd_id128_get_machine(&machine);
 908         if (r < 0) {
 909                 log_error("Failed to get machine id: %s", strerror(-r));
 910                 return r;
 911         }
 912
 913         r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
 914         if (r < 0) {
 915                 log_error("Failed to read runtime journal: %s", strerror(-r));
 916                 return r;
 917         }
 918
 919         sd_journal_set_data_threshold(j, 0);
 920
 921         SD_JOURNAL_FOREACH(j) {
 922                 Object *o = NULL;
 923                 JournalFile *f;
 924
 925                 f = j->current_file;
 926                 assert(f && f->current_offset > 0);
 927
 928                 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
 929                 if (r < 0) {
 930                         log_error("Can't read entry: %s", strerror(-r));
 931                         goto finish;
 932                 }
 933
 934                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
 935                 if (r >= 0)
 936                         continue;
 937
 938                 if (!shall_try_append_again(s->system_journal, r)) {
 939                         log_error("Can't write entry: %s", strerror(-r));
 940                         goto finish;
 941                 }
 942
 943                 server_rotate(s);
 944                 server_vacuum(s);
 945
 946                 log_debug("Retrying write.");
 947                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
 948                 if (r < 0) {
 949                         log_error("Can't write entry: %s", strerror(-r));
 950                         goto finish;
 951                 }
 952         }
 953
 954 finish:
 955         journal_file_post_change(s->system_journal);
 956
 957         journal_file_close(s->runtime_journal);
 958         s->runtime_journal = NULL;
 959
 960         if (r >= 0)
 961                 rm_rf("/run/log/journal", false, true, false);
 962
 963         if (j)
 964                 sd_journal_close(j);
 965
 966         return r;
 967 }
 968
 969 int process_event(Server *s, struct epoll_event *ev) {
 970         assert(s);
 971         assert(ev);
 972
 973         if (ev->data.fd == s->signal_fd) {
 974                 struct signalfd_siginfo sfsi;
 975                 ssize_t n;
 976
 977                 if (ev->events != EPOLLIN) {
 978                         log_error("Got invalid event from epoll.");
 979                         return -EIO;
 980                 }
 981
 982                 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
 983                 if (n != sizeof(sfsi)) {
 984
 985                         if (n >= 0)
 986                                 return -EIO;
 987
 988                         if (errno == EINTR || errno == EAGAIN)
 989                                 return 1;
 990
 991                         return -errno;
 992                 }
 993
 994                 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
 995
 996                 if (sfsi.ssi_signo == SIGUSR1) {
 997                         touch("/run/systemd/journal/flushed");
 998                         server_flush_to_var(s);
 999                         return 1;
1000                 }
1001
1002                 if (sfsi.ssi_signo == SIGUSR2) {
1003                         server_rotate(s);
1004                         server_vacuum(s);
1005                         return 1;
1006                 }
1007
1008                 return 0;
1009
1010         } else if (ev->data.fd == s->dev_kmsg_fd) {
1011                 int r;
1012
1013                 if (ev->events != EPOLLIN) {
1014                         log_error("Got invalid event from epoll.");
1015                         return -EIO;
1016                 }
1017
1018                 r = server_read_dev_kmsg(s);
1019                 if (r < 0)
1020                         return r;
1021
1022                 return 1;
1023
1024         } else if (ev->data.fd == s->native_fd ||
1025                    ev->data.fd == s->syslog_fd) {
1026
1027                 if (ev->events != EPOLLIN) {
1028                         log_error("Got invalid event from epoll.");
1029                         return -EIO;
1030                 }
1031
1032                 for (;;) {
1033                         struct msghdr msghdr;
1034                         struct iovec iovec;
1035                         struct ucred *ucred = NULL;
1036                         struct timeval *tv = NULL;
1037                         struct cmsghdr *cmsg;
1038                         char *label = NULL;
1039                         size_t label_len = 0;
1040                         union {
1041                                 struct cmsghdr cmsghdr;
1042
1043                                 /* We use NAME_MAX space for the
1044                                  * SELinux label here. The kernel
1045                                  * currently enforces no limit, but
1046                                  * according to suggestions from the
1047                                  * SELinux people this will change and
1048                                  * it will probably be identical to
1049                                  * NAME_MAX. For now we use that, but
1050                                  * this should be updated one day when
1051                                  * the final limit is known.*/
1052                                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1053                                             CMSG_SPACE(sizeof(struct timeval)) +
1054                                             CMSG_SPACE(sizeof(int)) + /* fd */
1055                                             CMSG_SPACE(NAME_MAX)]; /* selinux label */
1056                         } control;
1057                         ssize_t n;
1058                         int v;
1059                         int *fds = NULL;
1060                         unsigned n_fds = 0;
1061
1062                         if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
1063                                 log_error("SIOCINQ failed: %m");
1064                                 return -errno;
1065                         }
1066
1067                         if (s->buffer_size < (size_t) v) {
1068                                 void *b;
1069                                 size_t l;
1070
1071                                 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
1072                                 b = realloc(s->buffer, l+1);
1073
1074                                 if (!b) {
1075                                         log_error("Couldn't increase buffer.");
1076                                         return -ENOMEM;
1077                                 }
1078
1079                                 s->buffer_size = l;
1080                                 s->buffer = b;
1081                         }
1082
1083                         zero(iovec);
1084                         iovec.iov_base = s->buffer;
1085                         iovec.iov_len = s->buffer_size;
1086
1087                         zero(control);
1088                         zero(msghdr);
1089                         msghdr.msg_iov = &iovec;
1090                         msghdr.msg_iovlen = 1;
1091                         msghdr.msg_control = &control;
1092                         msghdr.msg_controllen = sizeof(control);
1093
1094                         n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1095                         if (n < 0) {
1096
1097                                 if (errno == EINTR || errno == EAGAIN)
1098                                         return 1;
1099
1100                                 log_error("recvmsg() failed: %m");
1101                                 return -errno;
1102                         }
1103
1104                         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1105
1106                                 if (cmsg->cmsg_level == SOL_SOCKET &&
1107                                     cmsg->cmsg_type == SCM_CREDENTIALS &&
1108                                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1109                                         ucred = (struct ucred*) CMSG_DATA(cmsg);
1110                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1111                                          cmsg->cmsg_type == SCM_SECURITY) {
1112                                         label = (char*) CMSG_DATA(cmsg);
1113                                         label_len = cmsg->cmsg_len - CMSG_LEN(0);
1114                                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1115                                          cmsg->cmsg_type == SO_TIMESTAMP &&
1116                                          cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1117                                         tv = (struct timeval*) CMSG_DATA(cmsg);
1118                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1119                                          cmsg->cmsg_type == SCM_RIGHTS) {
1120                                         fds = (int*) CMSG_DATA(cmsg);
1121                                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1122                                 }
1123                         }
1124
1125                         if (ev->data.fd == s->syslog_fd) {
1126                                 char *e;
1127
1128                                 if (n > 0 && n_fds == 0) {
1129                                         e = memchr(s->buffer, '\n', n);
1130                                         if (e)
1131                                                 *e = 0;
1132                                         else
1133                                                 s->buffer[n] = 0;
1134
1135                                         server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1136                                 } else if (n_fds > 0)
1137                                         log_warning("Got file descriptors via syslog socket. Ignoring.");
1138
1139                         } else {
1140                                 if (n > 0 && n_fds == 0)
1141                                         server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1142                                 else if (n == 0 && n_fds == 1)
1143                                         server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1144                                 else if (n_fds > 0)
1145                                         log_warning("Got too many file descriptors via native socket. Ignoring.");
1146                         }
1147
1148                         close_many(fds, n_fds);
1149                 }
1150
1151                 return 1;
1152
1153         } else if (ev->data.fd == s->stdout_fd) {
1154
1155                 if (ev->events != EPOLLIN) {
1156                         log_error("Got invalid event from epoll.");
1157                         return -EIO;
1158                 }
1159
1160                 stdout_stream_new(s);
1161                 return 1;
1162
1163         } else {
1164                 StdoutStream *stream;
1165
1166                 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
1167                         log_error("Got invalid event from epoll.");
1168                         return -EIO;
1169                 }
1170
1171                 /* If it is none of the well-known fds, it must be an
1172                  * stdout stream fd. Note that this is a bit ugly here
1173                  * (since we rely that none of the well-known fds
1174                  * could be interpreted as pointer), but nonetheless
1175                  * safe, since the well-known fds would never get an
1176                  * fd > 4096, i.e. beyond the first memory page */
1177
1178                 stream = ev->data.ptr;
1179
1180                 if (stdout_stream_process(stream) <= 0)
1181                         stdout_stream_free(stream);
1182
1183                 return 1;
1184         }
1185
1186         log_error("Unknown event.");
1187         return 0;
1188 }
1189
1190 static int open_signalfd(Server *s) {
1191         sigset_t mask;
1192         struct epoll_event ev;
1193
1194         assert(s);
1195
1196         assert_se(sigemptyset(&mask) == 0);
1197         sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1198         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1199
1200         s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1201         if (s->signal_fd < 0) {
1202                 log_error("signalfd(): %m");
1203                 return -errno;
1204         }
1205
1206         zero(ev);
1207         ev.events = EPOLLIN;
1208         ev.data.fd = s->signal_fd;
1209
1210         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
1211                 log_error("epoll_ctl(): %m");
1212                 return -errno;
1213         }
1214
1215         return 0;
1216 }
1217
1218 static int server_parse_proc_cmdline(Server *s) {
1219         char _cleanup_free_ *line = NULL;
1220         char *w, *state;
1221         int r;
1222         size_t l;
1223
1224         if (detect_container(NULL) > 0)
1225                 return 0;
1226
1227         r = read_one_line_file("/proc/cmdline", &line);
1228         if (r < 0) {
1229                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1230                 return 0;
1231         }
1232
1233         FOREACH_WORD_QUOTED(w, l, line, state) {
1234                 char _cleanup_free_ *word;
1235
1236                 word = strndup(w, l);
1237                 if (!word)
1238                         return -ENOMEM;
1239
1240                 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1241                         r = parse_boolean(word + 35);
1242                         if (r < 0)
1243                                 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1244                         else
1245                                 s->forward_to_syslog = r;
1246                 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1247                         r = parse_boolean(word + 33);
1248                         if (r < 0)
1249                                 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1250                         else
1251                                 s->forward_to_kmsg = r;
1252                 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1253                         r = parse_boolean(word + 36);
1254                         if (r < 0)
1255                                 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1256                         else
1257                                 s->forward_to_console = r;
1258                 } else if (startswith(word, "systemd.journald"))
1259                         log_warning("Invalid systemd.journald parameter. Ignoring.");
1260         }
1261
1262         return 0;
1263 }
1264
1265 static int server_parse_config_file(Server *s) {
1266         static const char *fn = "/etc/systemd/journald.conf";
1267         FILE _cleanup_fclose_ *f = NULL;
1268         int r;
1269
1270         assert(s);
1271
1272         f = fopen(fn, "re");
1273         if (!f) {
1274                 if (errno == ENOENT)
1275                         return 0;
1276
1277                 log_warning("Failed to open configuration file %s: %m", fn);
1278                 return -errno;
1279         }
1280
1281         r = config_parse(fn, f, "Journal\0", config_item_perf_lookup,
1282                          (void*) journald_gperf_lookup, false, s);
1283         if (r < 0)
1284                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1285
1286         return r;
1287 }
1288
1289 int server_init(Server *s) {
1290         int n, r, fd;
1291
1292         assert(s);
1293
1294         zero(*s);
1295         s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
1296         s->compress = true;
1297         s->seal = true;
1298
1299         s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1300         s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1301
1302         s->forward_to_syslog = true;
1303
1304         s->max_level_store = LOG_DEBUG;
1305         s->max_level_syslog = LOG_DEBUG;
1306         s->max_level_kmsg = LOG_NOTICE;
1307         s->max_level_console = LOG_INFO;
1308
1309         memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1310         memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1311
1312         server_parse_config_file(s);
1313         server_parse_proc_cmdline(s);
1314         if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) {
1315                 log_debug("Setting both rate limit interval and burst from %llu,%u to 0,0",
1316                           (long long unsigned) s->rate_limit_interval,
1317                           s->rate_limit_burst);
1318                 s->rate_limit_interval = s->rate_limit_burst = 0;
1319         }
1320
1321         mkdir_p("/run/systemd/journal", 0755);
1322
1323         s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1324         if (!s->user_journals)
1325                 return log_oom();
1326
1327         s->mmap = mmap_cache_new();
1328         if (!s->mmap)
1329                 return log_oom();
1330
1331         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1332         if (s->epoll_fd < 0) {
1333                 log_error("Failed to create epoll object: %m");
1334                 return -errno;
1335         }
1336
1337         n = sd_listen_fds(true);
1338         if (n < 0) {
1339                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1340                 return n;
1341         }
1342
1343         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1344
1345                 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1346
1347                         if (s->native_fd >= 0) {
1348                                 log_error("Too many native sockets passed.");
1349                                 return -EINVAL;
1350                         }
1351
1352                         s->native_fd = fd;
1353
1354                 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1355
1356                         if (s->stdout_fd >= 0) {
1357                                 log_error("Too many stdout sockets passed.");
1358                                 return -EINVAL;
1359                         }
1360
1361                         s->stdout_fd = fd;
1362
1363                 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1364
1365                         if (s->syslog_fd >= 0) {
1366                                 log_error("Too many /dev/log sockets passed.");
1367                                 return -EINVAL;
1368                         }
1369
1370                         s->syslog_fd = fd;
1371
1372                 } else {
1373                         log_error("Unknown socket passed.");
1374                         return -EINVAL;
1375                 }
1376         }
1377
1378         r = server_open_syslog_socket(s);
1379         if (r < 0)
1380                 return r;
1381
1382         r = server_open_native_socket(s);
1383         if (r < 0)
1384                 return r;
1385
1386         r = server_open_stdout_socket(s);
1387         if (r < 0)
1388                 return r;
1389
1390         r = server_open_dev_kmsg(s);
1391         if (r < 0)
1392                 return r;
1393
1394         r = server_open_kernel_seqnum(s);
1395         if (r < 0)
1396                 return r;
1397
1398         r = open_signalfd(s);
1399         if (r < 0)
1400                 return r;
1401
1402         s->udev = udev_new();
1403         if (!s->udev)
1404                 return -ENOMEM;
1405
1406         s->rate_limit = journal_rate_limit_new(s->rate_limit_interval,
1407                                                s->rate_limit_burst);
1408         if (!s->rate_limit)
1409                 return -ENOMEM;
1410
1411         r = system_journal_open(s);
1412         if (r < 0)
1413                 return r;
1414
1415         return 0;
1416 }
1417
1418 void server_maybe_append_tags(Server *s) {
1419 #ifdef HAVE_GCRYPT
1420         JournalFile *f;
1421         Iterator i;
1422         usec_t n;
1423
1424         n = now(CLOCK_REALTIME);
1425
1426         if (s->system_journal)
1427                 journal_file_maybe_append_tag(s->system_journal, n);
1428
1429         HASHMAP_FOREACH(f, s->user_journals, i)
1430                 journal_file_maybe_append_tag(f, n);
1431 #endif
1432 }
1433
1434 void server_done(Server *s) {
1435         JournalFile *f;
1436         assert(s);
1437
1438         while (s->stdout_streams)
1439                 stdout_stream_free(s->stdout_streams);
1440
1441         if (s->system_journal)
1442                 journal_file_close(s->system_journal);
1443
1444         if (s->runtime_journal)
1445                 journal_file_close(s->runtime_journal);
1446
1447         while ((f = hashmap_steal_first(s->user_journals)))
1448                 journal_file_close(f);
1449
1450         hashmap_free(s->user_journals);
1451
1452         if (s->epoll_fd >= 0)
1453                 close_nointr_nofail(s->epoll_fd);
1454
1455         if (s->signal_fd >= 0)
1456                 close_nointr_nofail(s->signal_fd);
1457
1458         if (s->syslog_fd >= 0)
1459                 close_nointr_nofail(s->syslog_fd);
1460
1461         if (s->native_fd >= 0)
1462                 close_nointr_nofail(s->native_fd);
1463
1464         if (s->stdout_fd >= 0)
1465                 close_nointr_nofail(s->stdout_fd);
1466
1467         if (s->dev_kmsg_fd >= 0)
1468                 close_nointr_nofail(s->dev_kmsg_fd);
1469
1470         if (s->rate_limit)
1471                 journal_rate_limit_free(s->rate_limit);
1472
1473         if (s->kernel_seqnum)
1474                 munmap(s->kernel_seqnum, sizeof(uint64_t));
1475
1476         free(s->buffer);
1477         free(s->tty_path);
1478
1479         if (s->mmap)
1480                 mmap_cache_unref(s->mmap);
1481
1482         if (s->udev)
1483                 udev_unref(s->udev);
1484 }