src/journal/journald-server.c

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