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