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