src/journal/journald-server.c

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