src/journal/journald-server.c

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