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, owner = 0, journal_uid;
 519         bool loginuid_valid = false, 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
 529                 realuid = ucred->uid;
 530
 531                 if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0)
 532                         IOVEC_SET_STRING(iovec[n++], pid);
 533
 534                 if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0)
 535                         IOVEC_SET_STRING(iovec[n++], uid);
 536
 537                 if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0)
 538                         IOVEC_SET_STRING(iovec[n++], gid);
 539
 540                 r = get_process_comm(ucred->pid, &t);
 541                 if (r >= 0) {
 542                         comm = strappend("_COMM=", t);
 543                         free(t);
 544
 545                         if (comm)
 546                                 IOVEC_SET_STRING(iovec[n++], comm);
 547                 }
 548
 549                 r = get_process_exe(ucred->pid, &t);
 550                 if (r >= 0) {
 551                         exe = strappend("_EXE=", t);
 552                         free(t);
 553
 554                         if (exe)
 555                                 IOVEC_SET_STRING(iovec[n++], exe);
 556                 }
 557
 558                 r = get_process_cmdline(ucred->pid, 0, false, &t);
 559                 if (r >= 0) {
 560                         cmdline = strappend("_CMDLINE=", t);
 561                         free(t);
 562
 563                         if (cmdline)
 564                                 IOVEC_SET_STRING(iovec[n++], cmdline);
 565                 }
 566
 567                 r = audit_session_from_pid(ucred->pid, &audit);
 568                 if (r >= 0)
 569                         if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0)
 570                                 IOVEC_SET_STRING(iovec[n++], audit_session);
 571
 572                 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
 573                 if (r >= 0) {
 574                         loginuid_valid = true;
 575                         if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0)
 576                                 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
 577                 }
 578
 579                 t = shortened_cgroup_path(ucred->pid);
 580                 if (t) {
 581                         cgroup = strappend("_SYSTEMD_CGROUP=", t);
 582                         free(t);
 583
 584                         if (cgroup)
 585                                 IOVEC_SET_STRING(iovec[n++], cgroup);
 586                 }
 587
 588 #ifdef HAVE_LOGIND
 589                 if (sd_pid_get_session(ucred->pid, &t) >= 0) {
 590                         session = strappend("_SYSTEMD_SESSION=", t);
 591                         free(t);
 592
 593                         if (session)
 594                                 IOVEC_SET_STRING(iovec[n++], session);
 595                 }
 596
 597                 if (sd_pid_get_owner_uid(ucred->uid, &owner) >= 0) {
 598                         owner_valid = true;
 599                         if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0)
 600                                 IOVEC_SET_STRING(iovec[n++], owner_uid);
 601                 }
 602 #endif
 603
 604                 if (cg_pid_get_unit(ucred->pid, &t) >= 0) {
 605                         unit = strappend("_SYSTEMD_UNIT=", t);
 606                         free(t);
 607                 } else if (cg_pid_get_user_unit(ucred->pid, &t) >= 0) {
 608                         unit = strappend("_SYSTEMD_USER_UNIT=", t);
 609                         free(t);
 610                 } else if (unit_id) {
 611                         if (session)
 612                                 unit = strappend("_SYSTEMD_USER_UNIT=", unit_id);
 613                         else
 614                                 unit = strappend("_SYSTEMD_UNIT=", unit_id);
 615                 }
 616
 617                 if (unit)
 618                         IOVEC_SET_STRING(iovec[n++], unit);
 619
 620 #ifdef HAVE_SELINUX
 621                 if (label) {
 622                         selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len);
 623                         if (selinux_context) {
 624                                 memcpy(selinux_context, "_SELINUX_CONTEXT=", sizeof("_SELINUX_CONTEXT=")-1);
 625                                 memcpy(selinux_context+sizeof("_SELINUX_CONTEXT=")-1, label, label_len);
 626                                 selinux_context[sizeof("_SELINUX_CONTEXT=")-1+label_len] = 0;
 627                                 IOVEC_SET_STRING(iovec[n++], selinux_context);
 628                         }
 629                 } else {
 630                         security_context_t con;
 631
 632                         if (getpidcon(ucred->pid, &con) >= 0) {
 633                                 selinux_context = strappend("_SELINUX_CONTEXT=", con);
 634                                 if (selinux_context)
 635                                         IOVEC_SET_STRING(iovec[n++], selinux_context);
 636
 637                                 freecon(con);
 638                         }
 639                 }
 640 #endif
 641         }
 642
 643         if (tv) {
 644                 if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu",
 645                              (unsigned long long) timeval_load(tv)) >= 0)
 646                         IOVEC_SET_STRING(iovec[n++], source_time);
 647         }
 648
 649         /* Note that strictly speaking storing the boot id here is
 650          * redundant since the entry includes this in-line
 651          * anyway. However, we need this indexed, too. */
 652         r = sd_id128_get_boot(&id);
 653         if (r >= 0)
 654                 if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
 655                         IOVEC_SET_STRING(iovec[n++], boot_id);
 656
 657         r = sd_id128_get_machine(&id);
 658         if (r >= 0)
 659                 if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
 660                         IOVEC_SET_STRING(iovec[n++], machine_id);
 661
 662         t = gethostname_malloc();
 663         if (t) {
 664                 hostname = strappend("_HOSTNAME=", t);
 665                 free(t);
 666                 if (hostname)
 667                         IOVEC_SET_STRING(iovec[n++], hostname);
 668         }
 669
 670         assert(n <= m);
 671
 672         if (s->split_mode == SPLIT_UID && realuid > 0)
 673                 journal_uid = realuid;
 674         else if (s->split_mode == SPLIT_LOGIN && owner_valid && owner > 0)
 675                 journal_uid = owner;
 676         else if (s->split_mode == SPLIT_LOGIN && loginuid_valid && loginuid > 0)
 677                 journal_uid = loginuid;
 678         else
 679                 journal_uid = 0;
 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         if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) {
1314                 log_debug("Setting both rate limit interval and burst from %llu,%u to 0,0",
1315                           (long long unsigned) s->rate_limit_interval,
1316                           s->rate_limit_burst);
1317                 s->rate_limit_interval = s->rate_limit_burst = 0;
1318         }
1319
1320         mkdir_p("/run/systemd/journal", 0755);
1321
1322         s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1323         if (!s->user_journals)
1324                 return log_oom();
1325
1326         s->mmap = mmap_cache_new();
1327         if (!s->mmap)
1328                 return log_oom();
1329
1330         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1331         if (s->epoll_fd < 0) {
1332                 log_error("Failed to create epoll object: %m");
1333                 return -errno;
1334         }
1335
1336         n = sd_listen_fds(true);
1337         if (n < 0) {
1338                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1339                 return n;
1340         }
1341
1342         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1343
1344                 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1345
1346                         if (s->native_fd >= 0) {
1347                                 log_error("Too many native sockets passed.");
1348                                 return -EINVAL;
1349                         }
1350
1351                         s->native_fd = fd;
1352
1353                 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1354
1355                         if (s->stdout_fd >= 0) {
1356                                 log_error("Too many stdout sockets passed.");
1357                                 return -EINVAL;
1358                         }
1359
1360                         s->stdout_fd = fd;
1361
1362                 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1363
1364                         if (s->syslog_fd >= 0) {
1365                                 log_error("Too many /dev/log sockets passed.");
1366                                 return -EINVAL;
1367                         }
1368
1369                         s->syslog_fd = fd;
1370
1371                 } else {
1372                         log_error("Unknown socket passed.");
1373                         return -EINVAL;
1374                 }
1375         }
1376
1377         r = server_open_syslog_socket(s);
1378         if (r < 0)
1379                 return r;
1380
1381         r = server_open_native_socket(s);
1382         if (r < 0)
1383                 return r;
1384
1385         r = server_open_stdout_socket(s);
1386         if (r < 0)
1387                 return r;
1388
1389         r = server_open_dev_kmsg(s);
1390         if (r < 0)
1391                 return r;
1392
1393         r = server_open_kernel_seqnum(s);
1394         if (r < 0)
1395                 return r;
1396
1397         r = open_signalfd(s);
1398         if (r < 0)
1399                 return r;
1400
1401         s->udev = udev_new();
1402         if (!s->udev)
1403                 return -ENOMEM;
1404
1405         s->rate_limit = journal_rate_limit_new(s->rate_limit_interval,
1406                                                s->rate_limit_burst);
1407         if (!s->rate_limit)
1408                 return -ENOMEM;
1409
1410         r = system_journal_open(s);
1411         if (r < 0)
1412                 return r;
1413
1414         return 0;
1415 }
1416
1417 void server_maybe_append_tags(Server *s) {
1418 #ifdef HAVE_GCRYPT
1419         JournalFile *f;
1420         Iterator i;
1421         usec_t n;
1422
1423         n = now(CLOCK_REALTIME);
1424
1425         if (s->system_journal)
1426                 journal_file_maybe_append_tag(s->system_journal, n);
1427
1428         HASHMAP_FOREACH(f, s->user_journals, i)
1429                 journal_file_maybe_append_tag(f, n);
1430 #endif
1431 }
1432
1433 void server_done(Server *s) {
1434         JournalFile *f;
1435         assert(s);
1436
1437         while (s->stdout_streams)
1438                 stdout_stream_free(s->stdout_streams);
1439
1440         if (s->system_journal)
1441                 journal_file_close(s->system_journal);
1442
1443         if (s->runtime_journal)
1444                 journal_file_close(s->runtime_journal);
1445
1446         while ((f = hashmap_steal_first(s->user_journals)))
1447                 journal_file_close(f);
1448
1449         hashmap_free(s->user_journals);
1450
1451         if (s->epoll_fd >= 0)
1452                 close_nointr_nofail(s->epoll_fd);
1453
1454         if (s->signal_fd >= 0)
1455                 close_nointr_nofail(s->signal_fd);
1456
1457         if (s->syslog_fd >= 0)
1458                 close_nointr_nofail(s->syslog_fd);
1459
1460         if (s->native_fd >= 0)
1461                 close_nointr_nofail(s->native_fd);
1462
1463         if (s->stdout_fd >= 0)
1464                 close_nointr_nofail(s->stdout_fd);
1465
1466         if (s->dev_kmsg_fd >= 0)
1467                 close_nointr_nofail(s->dev_kmsg_fd);
1468
1469         if (s->rate_limit)
1470                 journal_rate_limit_free(s->rate_limit);
1471
1472         if (s->kernel_seqnum)
1473                 munmap(s->kernel_seqnum, sizeof(uint64_t));
1474
1475         free(s->buffer);
1476         free(s->tty_path);
1477
1478         if (s->mmap)
1479                 mmap_cache_unref(s->mmap);
1480
1481         if (s->udev)
1482                 udev_unref(s->udev);
1483 }