src/journal/journald-server.c

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