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