src/journal/journald.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/epoll.h>
  23 #include <sys/socket.h>
  24 #include <errno.h>
  25 #include <sys/signalfd.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <stddef.h>
  29 #include <sys/ioctl.h>
  30 #include <linux/sockios.h>
  31 #include <sys/statvfs.h>
  32
  33 #include <systemd/sd-journal.h>
  34 #include <systemd/sd-messages.h>
  35 #include <systemd/sd-daemon.h>
  36
  37 #ifdef HAVE_LOGIND
  38 #include <systemd/sd-login.h>
  39 #endif
  40
  41 #include "mkdir.h"
  42 #include "hashmap.h"
  43 #include "journal-file.h"
  44 #include "socket-util.h"
  45 #include "cgroup-util.h"
  46 #include "list.h"
  47 #include "journal-rate-limit.h"
  48 #include "journal-internal.h"
  49 #include "conf-parser.h"
  50 #include "journald.h"
  51 #include "virt.h"
  52 #include "missing.h"
  53
  54 #ifdef HAVE_ACL
  55 #include <sys/acl.h>
  56 #include <acl/libacl.h>
  57 #include "acl-util.h"
  58 #endif
  59
  60 #ifdef HAVE_SELINUX
  61 #include <selinux/selinux.h>
  62 #endif
  63
  64 #define USER_JOURNALS_MAX 1024
  65 #define STDOUT_STREAMS_MAX 4096
  66
  67 #define DEFAULT_RATE_LIMIT_INTERVAL (10*USEC_PER_SEC)
  68 #define DEFAULT_RATE_LIMIT_BURST 200
  69
  70 #define RECHECK_AVAILABLE_SPACE_USEC (30*USEC_PER_SEC)
  71
  72 #define N_IOVEC_META_FIELDS 17
  73
  74 #define ENTRY_SIZE_MAX (1024*1024*32)
  75
  76 typedef enum StdoutStreamState {
  77         STDOUT_STREAM_IDENTIFIER,
  78         STDOUT_STREAM_UNIT_ID,
  79         STDOUT_STREAM_PRIORITY,
  80         STDOUT_STREAM_LEVEL_PREFIX,
  81         STDOUT_STREAM_FORWARD_TO_SYSLOG,
  82         STDOUT_STREAM_FORWARD_TO_KMSG,
  83         STDOUT_STREAM_FORWARD_TO_CONSOLE,
  84         STDOUT_STREAM_RUNNING
  85 } StdoutStreamState;
  86
  87 struct StdoutStream {
  88         Server *server;
  89         StdoutStreamState state;
  90
  91         int fd;
  92
  93         struct ucred ucred;
  94 #ifdef HAVE_SELINUX
  95         security_context_t security_context;
  96 #endif
  97
  98         char *identifier;
  99         char *unit_id;
 100         int priority;
 101         bool level_prefix:1;
 102         bool forward_to_syslog:1;
 103         bool forward_to_kmsg:1;
 104         bool forward_to_console:1;
 105
 106         char buffer[LINE_MAX+1];
 107         size_t length;
 108
 109         LIST_FIELDS(StdoutStream, stdout_stream);
 110 };
 111
 112 static const char* const storage_table[] = {
 113         [STORAGE_AUTO] = "auto",
 114         [STORAGE_VOLATILE] = "volatile",
 115         [STORAGE_PERSISTENT] = "persistent",
 116         [STORAGE_NONE] = "none"
 117 };
 118
 119 DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
 120 DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
 121
 122 static uint64_t available_space(Server *s) {
 123         char ids[33], *p;
 124         const char *f;
 125         sd_id128_t machine;
 126         struct statvfs ss;
 127         uint64_t sum = 0, avail = 0, ss_avail = 0;
 128         int r;
 129         DIR *d;
 130         usec_t ts;
 131         JournalMetrics *m;
 132
 133         ts = now(CLOCK_MONOTONIC);
 134
 135         if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts)
 136                 return s->cached_available_space;
 137
 138         r = sd_id128_get_machine(&machine);
 139         if (r < 0)
 140                 return 0;
 141
 142         if (s->system_journal) {
 143                 f = "/var/log/journal/";
 144                 m = &s->system_metrics;
 145         } else {
 146                 f = "/run/log/journal/";
 147                 m = &s->runtime_metrics;
 148         }
 149
 150         assert(m);
 151
 152         p = strappend(f, sd_id128_to_string(machine, ids));
 153         if (!p)
 154                 return 0;
 155
 156         d = opendir(p);
 157         free(p);
 158
 159         if (!d)
 160                 return 0;
 161
 162         if (fstatvfs(dirfd(d), &ss) < 0)
 163                 goto finish;
 164
 165         for (;;) {
 166                 struct stat st;
 167                 struct dirent buf, *de;
 168
 169                 r = readdir_r(d, &buf, &de);
 170                 if (r != 0)
 171                         break;
 172
 173                 if (!de)
 174                         break;
 175
 176                 if (!endswith(de->d_name, ".journal") &&
 177                     !endswith(de->d_name, ".journal~"))
 178                         continue;
 179
 180                 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
 181                         continue;
 182
 183                 if (!S_ISREG(st.st_mode))
 184                         continue;
 185
 186                 sum += (uint64_t) st.st_blocks * 512UL;
 187         }
 188
 189         avail = sum >= m->max_use ? 0 : m->max_use - sum;
 190
 191         ss_avail = ss.f_bsize * ss.f_bavail;
 192
 193         ss_avail = ss_avail < m->keep_free ? 0 : ss_avail - m->keep_free;
 194
 195         if (ss_avail < avail)
 196                 avail = ss_avail;
 197
 198         s->cached_available_space = avail;
 199         s->cached_available_space_timestamp = ts;
 200
 201 finish:
 202         closedir(d);
 203
 204         return avail;
 205 }
 206
 207 static void server_read_file_gid(Server *s) {
 208         const char *adm = "adm";
 209         int r;
 210
 211         assert(s);
 212
 213         if (s->file_gid_valid)
 214                 return;
 215
 216         r = get_group_creds(&adm, &s->file_gid);
 217         if (r < 0)
 218                 log_warning("Failed to resolve 'adm' group: %s", strerror(-r));
 219
 220         /* if we couldn't read the gid, then it will be 0, but that's
 221          * fine and we shouldn't try to resolve the group again, so
 222          * let's just pretend it worked right-away. */
 223         s->file_gid_valid = true;
 224 }
 225
 226 static void server_fix_perms(Server *s, JournalFile *f, uid_t uid) {
 227         int r;
 228 #ifdef HAVE_ACL
 229         acl_t acl;
 230         acl_entry_t entry;
 231         acl_permset_t permset;
 232 #endif
 233
 234         assert(f);
 235
 236         server_read_file_gid(s);
 237
 238         r = fchmod_and_fchown(f->fd, 0640, 0, s->file_gid);
 239         if (r < 0)
 240                 log_warning("Failed to fix access mode/rights on %s, ignoring: %s", f->path, strerror(-r));
 241
 242 #ifdef HAVE_ACL
 243         if (uid <= 0)
 244                 return;
 245
 246         acl = acl_get_fd(f->fd);
 247         if (!acl) {
 248                 log_warning("Failed to read ACL on %s, ignoring: %m", f->path);
 249                 return;
 250         }
 251
 252         r = acl_find_uid(acl, uid, &entry);
 253         if (r <= 0) {
 254
 255                 if (acl_create_entry(&acl, &entry) < 0 ||
 256                     acl_set_tag_type(entry, ACL_USER) < 0 ||
 257                     acl_set_qualifier(entry, &uid) < 0) {
 258                         log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
 259                         goto finish;
 260                 }
 261         }
 262
 263         if (acl_get_permset(entry, &permset) < 0 ||
 264             acl_add_perm(permset, ACL_READ) < 0 ||
 265             acl_calc_mask(&acl) < 0) {
 266                 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
 267                 goto finish;
 268         }
 269
 270         if (acl_set_fd(f->fd, acl) < 0)
 271                 log_warning("Failed to set ACL on %s, ignoring: %m", f->path);
 272
 273 finish:
 274         acl_free(acl);
 275 #endif
 276 }
 277
 278 static JournalFile* find_journal(Server *s, uid_t uid) {
 279         char *p;
 280         int r;
 281         JournalFile *f;
 282         char ids[33];
 283         sd_id128_t machine;
 284
 285         assert(s);
 286
 287         /* We split up user logs only on /var, not on /run. If the
 288          * runtime file is open, we write to it exclusively, in order
 289          * to guarantee proper order as soon as we flush /run to
 290          * /var and close the runtime file. */
 291
 292         if (s->runtime_journal)
 293                 return s->runtime_journal;
 294
 295         if (uid <= 0)
 296                 return s->system_journal;
 297
 298         r = sd_id128_get_machine(&machine);
 299         if (r < 0)
 300                 return s->system_journal;
 301
 302         f = hashmap_get(s->user_journals, UINT32_TO_PTR(uid));
 303         if (f)
 304                 return f;
 305
 306         if (asprintf(&p, "/var/log/journal/%s/user-%lu.journal", sd_id128_to_string(machine, ids), (unsigned long) uid) < 0)
 307                 return s->system_journal;
 308
 309         while (hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) {
 310                 /* Too many open? Then let's close one */
 311                 f = hashmap_steal_first(s->user_journals);
 312                 assert(f);
 313                 journal_file_close(f);
 314         }
 315
 316         r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, &s->system_metrics, s->system_journal, &f);
 317         free(p);
 318
 319         if (r < 0)
 320                 return s->system_journal;
 321
 322         server_fix_perms(s, f, uid);
 323
 324         r = hashmap_put(s->user_journals, UINT32_TO_PTR(uid), f);
 325         if (r < 0) {
 326                 journal_file_close(f);
 327                 return s->system_journal;
 328         }
 329
 330         return f;
 331 }
 332
 333 static void server_rotate(Server *s) {
 334         JournalFile *f;
 335         void *k;
 336         Iterator i;
 337         int r;
 338
 339         log_info("Rotating...");
 340
 341         if (s->runtime_journal) {
 342                 r = journal_file_rotate(&s->runtime_journal);
 343                 if (r < 0)
 344                         if (s->runtime_journal)
 345                                 log_error("Failed to rotate %s: %s", s->runtime_journal->path, strerror(-r));
 346                         else
 347                                 log_error("Failed to create new runtime journal: %s", strerror(-r));
 348                 else
 349                         server_fix_perms(s, s->runtime_journal, 0);
 350         }
 351
 352         if (s->system_journal) {
 353                 r = journal_file_rotate(&s->system_journal);
 354                 if (r < 0)
 355                         if (s->system_journal)
 356                                 log_error("Failed to rotate %s: %s", s->system_journal->path, strerror(-r));
 357                         else
 358                                 log_error("Failed to create new system journal: %s", strerror(-r));
 359
 360                 else
 361                         server_fix_perms(s, s->system_journal, 0);
 362         }
 363
 364         HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
 365                 r = journal_file_rotate(&f);
 366                 if (r < 0)
 367                         if (f->path)
 368                                 log_error("Failed to rotate %s: %s", f->path, strerror(-r));
 369                         else
 370                                 log_error("Failed to create user journal: %s", strerror(-r));
 371                 else {
 372                         hashmap_replace(s->user_journals, k, f);
 373                         server_fix_perms(s, s->system_journal, PTR_TO_UINT32(k));
 374                 }
 375         }
 376 }
 377
 378 static void server_vacuum(Server *s) {
 379         char *p;
 380         char ids[33];
 381         sd_id128_t machine;
 382         int r;
 383
 384         log_info("Vacuuming...");
 385
 386         r = sd_id128_get_machine(&machine);
 387         if (r < 0) {
 388                 log_error("Failed to get machine ID: %s", strerror(-r));
 389                 return;
 390         }
 391
 392         sd_id128_to_string(machine, ids);
 393
 394         if (s->system_journal) {
 395                 if (asprintf(&p, "/var/log/journal/%s", ids) < 0) {
 396                         log_oom();
 397                         return;
 398                 }
 399
 400                 r = journal_directory_vacuum(p, s->system_metrics.max_use, s->system_metrics.keep_free);
 401                 if (r < 0 && r != -ENOENT)
 402                         log_error("Failed to vacuum %s: %s", p, strerror(-r));
 403                 free(p);
 404         }
 405
 406         if (s->runtime_journal) {
 407                 if (asprintf(&p, "/run/log/journal/%s", ids) < 0) {
 408                         log_oom();
 409                         return;
 410                 }
 411
 412                 r = journal_directory_vacuum(p, s->runtime_metrics.max_use, s->runtime_metrics.keep_free);
 413                 if (r < 0 && r != -ENOENT)
 414                         log_error("Failed to vacuum %s: %s", p, strerror(-r));
 415                 free(p);
 416         }
 417
 418         s->cached_available_space_timestamp = 0;
 419 }
 420
 421 static char *shortened_cgroup_path(pid_t pid) {
 422         int r;
 423         char *process_path, *init_path, *path;
 424
 425         assert(pid > 0);
 426
 427         r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, pid, &process_path);
 428         if (r < 0)
 429                 return NULL;
 430
 431         r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 1, &init_path);
 432         if (r < 0) {
 433                 free(process_path);
 434                 return NULL;
 435         }
 436
 437         if (endswith(init_path, "/system"))
 438                 init_path[strlen(init_path) - 7] = 0;
 439         else if (streq(init_path, "/"))
 440                 init_path[0] = 0;
 441
 442         if (startswith(process_path, init_path)) {
 443                 char *p;
 444
 445                 p = strdup(process_path + strlen(init_path));
 446                 if (!p) {
 447                         free(process_path);
 448                         free(init_path);
 449                         return NULL;
 450                 }
 451                 path = p;
 452         } else {
 453                 path = process_path;
 454                 process_path = NULL;
 455         }
 456
 457         free(process_path);
 458         free(init_path);
 459
 460         return path;
 461 }
 462
 463 static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n) {
 464         JournalFile *f;
 465         bool vacuumed = false;
 466         int r;
 467
 468         assert(s);
 469         assert(iovec);
 470         assert(n > 0);
 471
 472         f = find_journal(s, uid);
 473         if (!f)
 474                 return;
 475
 476         if (journal_file_rotate_suggested(f)) {
 477                 log_info("Journal header limits reached or header out-of-date, rotating.");
 478                 server_rotate(s);
 479                 server_vacuum(s);
 480                 vacuumed = true;
 481
 482                 f = find_journal(s, uid);
 483                 if (!f)
 484                         return;
 485         }
 486
 487         for (;;) {
 488                 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
 489                 if (r >= 0)
 490                         return;
 491
 492                 if (vacuumed ||
 493                     (r != -E2BIG && /* hit limit */
 494                      r != -EFBIG && /* hit fs limit */
 495                      r != -EDQUOT && /* quota hit */
 496                      r != -ENOSPC && /* disk full */
 497                      r != -EBADMSG && /* corrupted */
 498                      r != -ENODATA && /* truncated */
 499                      r != -EHOSTDOWN && /* other machine */
 500                      r != -EPROTONOSUPPORT && /* unsupported feature */
 501                      r != -EBUSY && /* unclean shutdown */
 502                      r != -ESHUTDOWN /* already archived */)) {
 503                         log_error("Failed to write entry, ignoring: %s", strerror(-r));
 504                         return;
 505                 }
 506
 507                 if (r == -E2BIG || r == -EFBIG || r == EDQUOT || r == ENOSPC)
 508                         log_info("Allocation limit reached, rotating.");
 509                 else if (r == -EHOSTDOWN)
 510                         log_info("Journal file from other machine, rotating.");
 511                 else if (r == -EBUSY)
 512                         log_info("Unlcean shutdown, rotating.");
 513                 else
 514                         log_warning("Journal file corrupted, rotating.");
 515
 516                 server_rotate(s);
 517                 server_vacuum(s);
 518                 vacuumed = true;
 519
 520                 f = find_journal(s, uid);
 521                 if (!f)
 522                         return;
 523
 524                 log_info("Retrying write.");
 525         }
 526 }
 527
 528 static void dispatch_message_real(
 529                 Server *s,
 530                 struct iovec *iovec, unsigned n, unsigned m,
 531                 struct ucred *ucred,
 532                 struct timeval *tv,
 533                 const char *label, size_t label_len,
 534                 const char *unit_id) {
 535
 536         char *pid = NULL, *uid = NULL, *gid = NULL,
 537                 *source_time = NULL, *boot_id = NULL, *machine_id = NULL,
 538                 *comm = NULL, *cmdline = NULL, *hostname = NULL,
 539                 *audit_session = NULL, *audit_loginuid = NULL,
 540                 *exe = NULL, *cgroup = NULL, *session = NULL,
 541                 *owner_uid = NULL, *unit = NULL, *selinux_context = NULL;
 542
 543         char idbuf[33];
 544         sd_id128_t id;
 545         int r;
 546         char *t;
 547         uid_t loginuid = 0, realuid = 0;
 548
 549         assert(s);
 550         assert(iovec);
 551         assert(n > 0);
 552         assert(n + N_IOVEC_META_FIELDS <= m);
 553
 554         if (ucred) {
 555                 uint32_t audit;
 556 #ifdef HAVE_LOGIND
 557                 uid_t owner;
 558 #endif
 559
 560                 realuid = ucred->uid;
 561
 562                 if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0)
 563                         IOVEC_SET_STRING(iovec[n++], pid);
 564
 565                 if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0)
 566                         IOVEC_SET_STRING(iovec[n++], uid);
 567
 568                 if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0)
 569                         IOVEC_SET_STRING(iovec[n++], gid);
 570
 571                 r = get_process_comm(ucred->pid, &t);
 572                 if (r >= 0) {
 573                         comm = strappend("_COMM=", t);
 574                         free(t);
 575
 576                         if (comm)
 577                                 IOVEC_SET_STRING(iovec[n++], comm);
 578                 }
 579
 580                 r = get_process_exe(ucred->pid, &t);
 581                 if (r >= 0) {
 582                         exe = strappend("_EXE=", t);
 583                         free(t);
 584
 585                         if (exe)
 586                                 IOVEC_SET_STRING(iovec[n++], exe);
 587                 }
 588
 589                 r = get_process_cmdline(ucred->pid, LINE_MAX, false, &t);
 590                 if (r >= 0) {
 591                         cmdline = strappend("_CMDLINE=", t);
 592                         free(t);
 593
 594                         if (cmdline)
 595                                 IOVEC_SET_STRING(iovec[n++], cmdline);
 596                 }
 597
 598                 r = audit_session_from_pid(ucred->pid, &audit);
 599                 if (r >= 0)
 600                         if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0)
 601                                 IOVEC_SET_STRING(iovec[n++], audit_session);
 602
 603                 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
 604                 if (r >= 0)
 605                         if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0)
 606                                 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
 607
 608                 t = shortened_cgroup_path(ucred->pid);
 609                 if (t) {
 610                         cgroup = strappend("_SYSTEMD_CGROUP=", t);
 611                         free(t);
 612
 613                         if (cgroup)
 614                                 IOVEC_SET_STRING(iovec[n++], cgroup);
 615                 }
 616
 617 #ifdef HAVE_LOGIND
 618                 if (sd_pid_get_session(ucred->pid, &t) >= 0) {
 619                         session = strappend("_SYSTEMD_SESSION=", t);
 620                         free(t);
 621
 622                         if (session)
 623                                 IOVEC_SET_STRING(iovec[n++], session);
 624                 }
 625
 626                 if (sd_pid_get_owner_uid(ucred->uid, &owner) >= 0)
 627                         if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0)
 628                                 IOVEC_SET_STRING(iovec[n++], owner_uid);
 629 #endif
 630
 631                 if (cg_pid_get_unit(ucred->pid, &t) >= 0) {
 632                         unit = strappend("_SYSTEMD_UNIT=", t);
 633                         free(t);
 634                 } else if (unit_id)
 635                         unit = strappend("_SYSTEMD_UNIT=", unit_id);
 636
 637                 if (unit)
 638                         IOVEC_SET_STRING(iovec[n++], unit);
 639
 640 #ifdef HAVE_SELINUX
 641                 if (label) {
 642                         selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len);
 643                         if (selinux_context) {
 644                                 memcpy(selinux_context, "_SELINUX_CONTEXT=", sizeof("_SELINUX_CONTEXT=")-1);
 645                                 memcpy(selinux_context+sizeof("_SELINUX_CONTEXT=")-1, label, label_len);
 646                                 selinux_context[sizeof("_SELINUX_CONTEXT=")-1+label_len] = 0;
 647                                 IOVEC_SET_STRING(iovec[n++], selinux_context);
 648                         }
 649                 } else {
 650                         security_context_t con;
 651
 652                         if (getpidcon(ucred->pid, &con) >= 0) {
 653                                 selinux_context = strappend("_SELINUX_CONTEXT=", con);
 654                                 if (selinux_context)
 655                                         IOVEC_SET_STRING(iovec[n++], selinux_context);
 656
 657                                 freecon(con);
 658                         }
 659                 }
 660 #endif
 661         }
 662
 663         if (tv) {
 664                 if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu",
 665                              (unsigned long long) timeval_load(tv)) >= 0)
 666                         IOVEC_SET_STRING(iovec[n++], source_time);
 667         }
 668
 669         /* Note that strictly speaking storing the boot id here is
 670          * redundant since the entry includes this in-line
 671          * anyway. However, we need this indexed, too. */
 672         r = sd_id128_get_boot(&id);
 673         if (r >= 0)
 674                 if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
 675                         IOVEC_SET_STRING(iovec[n++], boot_id);
 676
 677         r = sd_id128_get_machine(&id);
 678         if (r >= 0)
 679                 if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
 680                         IOVEC_SET_STRING(iovec[n++], machine_id);
 681
 682         t = gethostname_malloc();
 683         if (t) {
 684                 hostname = strappend("_HOSTNAME=", t);
 685                 free(t);
 686                 if (hostname)
 687                         IOVEC_SET_STRING(iovec[n++], hostname);
 688         }
 689
 690         assert(n <= m);
 691
 692         write_to_journal(s, realuid == 0 ? 0 : loginuid, iovec, n);
 693
 694         free(pid);
 695         free(uid);
 696         free(gid);
 697         free(comm);
 698         free(exe);
 699         free(cmdline);
 700         free(source_time);
 701         free(boot_id);
 702         free(machine_id);
 703         free(hostname);
 704         free(audit_session);
 705         free(audit_loginuid);
 706         free(cgroup);
 707         free(session);
 708         free(owner_uid);
 709         free(unit);
 710         free(selinux_context);
 711 }
 712
 713 static void driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
 714         char mid[11 + 32 + 1];
 715         char buffer[16 + LINE_MAX + 1];
 716         struct iovec iovec[N_IOVEC_META_FIELDS + 4];
 717         int n = 0;
 718         va_list ap;
 719         struct ucred ucred;
 720
 721         assert(s);
 722         assert(format);
 723
 724         IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
 725         IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
 726
 727         memcpy(buffer, "MESSAGE=", 8);
 728         va_start(ap, format);
 729         vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
 730         va_end(ap);
 731         char_array_0(buffer);
 732         IOVEC_SET_STRING(iovec[n++], buffer);
 733
 734         snprintf(mid, sizeof(mid), "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(message_id));
 735         char_array_0(mid);
 736         IOVEC_SET_STRING(iovec[n++], mid);
 737
 738         zero(ucred);
 739         ucred.pid = getpid();
 740         ucred.uid = getuid();
 741         ucred.gid = getgid();
 742
 743         dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
 744 }
 745
 746 static void dispatch_message(Server *s,
 747                              struct iovec *iovec, unsigned n, unsigned m,
 748                              struct ucred *ucred,
 749                              struct timeval *tv,
 750                              const char *label, size_t label_len,
 751                              const char *unit_id,
 752                              int priority) {
 753         int rl;
 754         char *path = NULL, *c;
 755
 756         assert(s);
 757         assert(iovec || n == 0);
 758
 759         if (n == 0)
 760                 return;
 761
 762         if (LOG_PRI(priority) > s->max_level_store)
 763                 return;
 764
 765         if (!ucred)
 766                 goto finish;
 767
 768         path = shortened_cgroup_path(ucred->pid);
 769         if (!path)
 770                 goto finish;
 771
 772         /* example: /user/lennart/3/foobar
 773          *          /system/dbus.service/foobar
 774          *
 775          * So let's cut of everything past the third /, since that is
 776          * wher user directories start */
 777
 778         c = strchr(path, '/');
 779         if (c) {
 780                 c = strchr(c+1, '/');
 781                 if (c) {
 782                         c = strchr(c+1, '/');
 783                         if (c)
 784                                 *c = 0;
 785                 }
 786         }
 787
 788         rl = journal_rate_limit_test(s->rate_limit, path, priority & LOG_PRIMASK, available_space(s));
 789
 790         if (rl == 0) {
 791                 free(path);
 792                 return;
 793         }
 794
 795         /* Write a suppression message if we suppressed something */
 796         if (rl > 1)
 797                 driver_message(s, SD_MESSAGE_JOURNAL_DROPPED, "Suppressed %u messages from %s", rl - 1, path);
 798
 799         free(path);
 800
 801 finish:
 802         dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
 803 }
 804
 805 static void forward_syslog_iovec(Server *s, const struct iovec *iovec, unsigned n_iovec, struct ucred *ucred, struct timeval *tv) {
 806         struct msghdr msghdr;
 807         struct cmsghdr *cmsg;
 808         union {
 809                 struct cmsghdr cmsghdr;
 810                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
 811         } control;
 812         union sockaddr_union sa;
 813
 814         assert(s);
 815         assert(iovec);
 816         assert(n_iovec > 0);
 817
 818         zero(msghdr);
 819         msghdr.msg_iov = (struct iovec*) iovec;
 820         msghdr.msg_iovlen = n_iovec;
 821
 822         zero(sa);
 823         sa.un.sun_family = AF_UNIX;
 824         strncpy(sa.un.sun_path, "/run/systemd/journal/syslog", sizeof(sa.un.sun_path));
 825         msghdr.msg_name = &sa;
 826         msghdr.msg_namelen = offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path);
 827
 828         if (ucred) {
 829                 zero(control);
 830                 msghdr.msg_control = &control;
 831                 msghdr.msg_controllen = sizeof(control);
 832
 833                 cmsg = CMSG_FIRSTHDR(&msghdr);
 834                 cmsg->cmsg_level = SOL_SOCKET;
 835                 cmsg->cmsg_type = SCM_CREDENTIALS;
 836                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
 837                 memcpy(CMSG_DATA(cmsg), ucred, sizeof(struct ucred));
 838                 msghdr.msg_controllen = cmsg->cmsg_len;
 839         }
 840
 841         /* Forward the syslog message we received via /dev/log to
 842          * /run/systemd/syslog. Unfortunately we currently can't set
 843          * the SO_TIMESTAMP auxiliary data, and hence we don't. */
 844
 845         if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
 846                 return;
 847
 848         /* The socket is full? I guess the syslog implementation is
 849          * too slow, and we shouldn't wait for that... */
 850         if (errno == EAGAIN)
 851                 return;
 852
 853         if (ucred && errno == ESRCH) {
 854                 struct ucred u;
 855
 856                 /* Hmm, presumably the sender process vanished
 857                  * by now, so let's fix it as good as we
 858                  * can, and retry */
 859
 860                 u = *ucred;
 861                 u.pid = getpid();
 862                 memcpy(CMSG_DATA(cmsg), &u, sizeof(struct ucred));
 863
 864                 if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
 865                         return;
 866
 867                 if (errno == EAGAIN)
 868                         return;
 869         }
 870
 871         if (errno != ENOENT)
 872                 log_debug("Failed to forward syslog message: %m");
 873 }
 874
 875 static void forward_syslog_raw(Server *s, int priority, const char *buffer, struct ucred *ucred, struct timeval *tv) {
 876         struct iovec iovec;
 877
 878         assert(s);
 879         assert(buffer);
 880
 881         if (LOG_PRI(priority) > s->max_level_syslog)
 882                 return;
 883
 884         IOVEC_SET_STRING(iovec, buffer);
 885         forward_syslog_iovec(s, &iovec, 1, ucred, tv);
 886 }
 887
 888 static void forward_syslog(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred, struct timeval *tv) {
 889         struct iovec iovec[5];
 890         char header_priority[6], header_time[64], header_pid[16];
 891         int n = 0;
 892         time_t t;
 893         struct tm *tm;
 894         char *ident_buf = NULL;
 895
 896         assert(s);
 897         assert(priority >= 0);
 898         assert(priority <= 999);
 899         assert(message);
 900
 901         if (LOG_PRI(priority) > s->max_level_syslog)
 902                 return;
 903
 904         /* First: priority field */
 905         snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
 906         char_array_0(header_priority);
 907         IOVEC_SET_STRING(iovec[n++], header_priority);
 908
 909         /* Second: timestamp */
 910         t = tv ? tv->tv_sec : ((time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC));
 911         tm = localtime(&t);
 912         if (!tm)
 913                 return;
 914         if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
 915                 return;
 916         IOVEC_SET_STRING(iovec[n++], header_time);
 917
 918         /* Third: identifier and PID */
 919         if (ucred) {
 920                 if (!identifier) {
 921                         get_process_comm(ucred->pid, &ident_buf);
 922                         identifier = ident_buf;
 923                 }
 924
 925                 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
 926                 char_array_0(header_pid);
 927
 928                 if (identifier)
 929                         IOVEC_SET_STRING(iovec[n++], identifier);
 930
 931                 IOVEC_SET_STRING(iovec[n++], header_pid);
 932         } else if (identifier) {
 933                 IOVEC_SET_STRING(iovec[n++], identifier);
 934                 IOVEC_SET_STRING(iovec[n++], ": ");
 935         }
 936
 937         /* Fourth: message */
 938         IOVEC_SET_STRING(iovec[n++], message);
 939
 940         forward_syslog_iovec(s, iovec, n, ucred, tv);
 941
 942         free(ident_buf);
 943 }
 944
 945 static int fixup_priority(int priority) {
 946
 947         if ((priority & LOG_FACMASK) == 0)
 948                 return (priority & LOG_PRIMASK) | LOG_USER;
 949
 950         return priority;
 951 }
 952
 953 static void forward_kmsg(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred) {
 954         struct iovec iovec[5];
 955         char header_priority[6], header_pid[16];
 956         int n = 0;
 957         char *ident_buf = NULL;
 958         int fd;
 959
 960         assert(s);
 961         assert(priority >= 0);
 962         assert(priority <= 999);
 963         assert(message);
 964
 965         if (LOG_PRI(priority) > s->max_level_kmsg)
 966                 return;
 967
 968         /* Never allow messages with kernel facility to be written to
 969          * kmsg, regardless where the data comes from. */
 970         priority = fixup_priority(priority);
 971
 972         /* First: priority field */
 973         snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
 974         char_array_0(header_priority);
 975         IOVEC_SET_STRING(iovec[n++], header_priority);
 976
 977         /* Second: identifier and PID */
 978         if (ucred) {
 979                 if (!identifier) {
 980                         get_process_comm(ucred->pid, &ident_buf);
 981                         identifier = ident_buf;
 982                 }
 983
 984                 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
 985                 char_array_0(header_pid);
 986
 987                 if (identifier)
 988                         IOVEC_SET_STRING(iovec[n++], identifier);
 989
 990                 IOVEC_SET_STRING(iovec[n++], header_pid);
 991         } else if (identifier) {
 992                 IOVEC_SET_STRING(iovec[n++], identifier);
 993                 IOVEC_SET_STRING(iovec[n++], ": ");
 994         }
 995
 996         /* Fourth: message */
 997         IOVEC_SET_STRING(iovec[n++], message);
 998         IOVEC_SET_STRING(iovec[n++], "\n");
 999
1000         fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
1001         if (fd < 0) {
1002                 log_debug("Failed to open /dev/kmsg for logging: %s", strerror(errno));
1003                 goto finish;
1004         }
1005
1006         if (writev(fd, iovec, n) < 0)
1007                 log_debug("Failed to write to /dev/kmsg for logging: %s", strerror(errno));
1008
1009         close_nointr_nofail(fd);
1010
1011 finish:
1012         free(ident_buf);
1013 }
1014
1015 static void forward_console(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred) {
1016         struct iovec iovec[4];
1017         char header_pid[16];
1018         int n = 0, fd;
1019         char *ident_buf = NULL;
1020         const char *tty;
1021
1022         assert(s);
1023         assert(message);
1024
1025         if (LOG_PRI(priority) > s->max_level_console)
1026                 return;
1027
1028         /* First: identifier and PID */
1029         if (ucred) {
1030                 if (!identifier) {
1031                         get_process_comm(ucred->pid, &ident_buf);
1032                         identifier = ident_buf;
1033                 }
1034
1035                 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
1036                 char_array_0(header_pid);
1037
1038                 if (identifier)
1039                         IOVEC_SET_STRING(iovec[n++], identifier);
1040
1041                 IOVEC_SET_STRING(iovec[n++], header_pid);
1042         } else if (identifier) {
1043                 IOVEC_SET_STRING(iovec[n++], identifier);
1044                 IOVEC_SET_STRING(iovec[n++], ": ");
1045         }
1046
1047         /* Third: message */
1048         IOVEC_SET_STRING(iovec[n++], message);
1049         IOVEC_SET_STRING(iovec[n++], "\n");
1050
1051         tty = s->tty_path ? s->tty_path : "/dev/console";
1052
1053         fd = open_terminal(tty, O_WRONLY|O_NOCTTY|O_CLOEXEC);
1054         if (fd < 0) {
1055                 log_debug("Failed to open %s for logging: %s", tty, strerror(errno));
1056                 goto finish;
1057         }
1058
1059         if (writev(fd, iovec, n) < 0)
1060                 log_debug("Failed to write to %s for logging: %s", tty, strerror(errno));
1061
1062         close_nointr_nofail(fd);
1063
1064 finish:
1065         free(ident_buf);
1066 }
1067
1068 static void read_identifier(const char **buf, char **identifier, char **pid) {
1069         const char *p;
1070         char *t;
1071         size_t l, e;
1072
1073         assert(buf);
1074         assert(identifier);
1075         assert(pid);
1076
1077         p = *buf;
1078
1079         p += strspn(p, WHITESPACE);
1080         l = strcspn(p, WHITESPACE);
1081
1082         if (l <= 0 ||
1083             p[l-1] != ':')
1084                 return;
1085
1086         e = l;
1087         l--;
1088
1089         if (p[l-1] == ']') {
1090                 size_t k = l-1;
1091
1092                 for (;;) {
1093
1094                         if (p[k] == '[') {
1095                                 t = strndup(p+k+1, l-k-2);
1096                                 if (t)
1097                                         *pid = t;
1098
1099                                 l = k;
1100                                 break;
1101                         }
1102
1103                         if (k == 0)
1104                                 break;
1105
1106                         k--;
1107                 }
1108         }
1109
1110         t = strndup(p, l);
1111         if (t)
1112                 *identifier = t;
1113
1114         *buf = p + e;
1115         *buf += strspn(*buf, WHITESPACE);
1116 }
1117
1118 static void process_syslog_message(Server *s, const char *buf, struct ucred *ucred, struct timeval *tv, const char *label, size_t label_len) {
1119         char *message = NULL, *syslog_priority = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *syslog_pid = NULL;
1120         struct iovec iovec[N_IOVEC_META_FIELDS + 6];
1121         unsigned n = 0;
1122         int priority = LOG_USER | LOG_INFO;
1123         char *identifier = NULL, *pid = NULL;
1124         const char *orig;
1125
1126         assert(s);
1127         assert(buf);
1128
1129         orig = buf;
1130         parse_syslog_priority((char**) &buf, &priority);
1131
1132         if (s->forward_to_syslog)
1133                 forward_syslog_raw(s, priority, orig, ucred, tv);
1134
1135         skip_syslog_date((char**) &buf);
1136         read_identifier(&buf, &identifier, &pid);
1137
1138         if (s->forward_to_kmsg)
1139                 forward_kmsg(s, priority, identifier, buf, ucred);
1140
1141         if (s->forward_to_console)
1142                 forward_console(s, priority, identifier, buf, ucred);
1143
1144         IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=syslog");
1145
1146         if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1147                 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1148
1149         if (priority & LOG_FACMASK)
1150                 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1151                         IOVEC_SET_STRING(iovec[n++], syslog_facility);
1152
1153         if (identifier) {
1154                 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
1155                 if (syslog_identifier)
1156                         IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1157         }
1158
1159         if (pid) {
1160                 syslog_pid = strappend("SYSLOG_PID=", pid);
1161                 if (syslog_pid)
1162                         IOVEC_SET_STRING(iovec[n++], syslog_pid);
1163         }
1164
1165         message = strappend("MESSAGE=", buf);
1166         if (message)
1167                 IOVEC_SET_STRING(iovec[n++], message);
1168
1169         dispatch_message(s, iovec, n, ELEMENTSOF(iovec), ucred, tv, label, label_len, NULL, priority);
1170
1171         free(message);
1172         free(identifier);
1173         free(pid);
1174         free(syslog_priority);
1175         free(syslog_facility);
1176         free(syslog_identifier);
1177         free(syslog_pid);
1178 }
1179
1180 static bool valid_user_field(const char *p, size_t l) {
1181         const char *a;
1182
1183         /* We kinda enforce POSIX syntax recommendations for
1184            environment variables here, but make a couple of additional
1185            requirements.
1186
1187            http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html */
1188
1189         /* No empty field names */
1190         if (l <= 0)
1191                 return false;
1192
1193         /* Don't allow names longer than 64 chars */
1194         if (l > 64)
1195                 return false;
1196
1197         /* Variables starting with an underscore are protected */
1198         if (p[0] == '_')
1199                 return false;
1200
1201         /* Don't allow digits as first character */
1202         if (p[0] >= '0' && p[0] <= '9')
1203                 return false;
1204
1205         /* Only allow A-Z0-9 and '_' */
1206         for (a = p; a < p + l; a++)
1207                 if (!((*a >= 'A' && *a <= 'Z') ||
1208                       (*a >= '0' && *a <= '9') ||
1209                       *a == '_'))
1210                         return false;
1211
1212         return true;
1213 }
1214
1215 static void process_native_message(
1216                 Server *s,
1217                 const void *buffer, size_t buffer_size,
1218                 struct ucred *ucred,
1219                 struct timeval *tv,
1220                 const char *label, size_t label_len) {
1221
1222         struct iovec *iovec = NULL;
1223         unsigned n = 0, m = 0, j, tn = (unsigned) -1;
1224         const char *p;
1225         size_t remaining;
1226         int priority = LOG_INFO;
1227         char *identifier = NULL, *message = NULL;
1228
1229         assert(s);
1230         assert(buffer || buffer_size == 0);
1231
1232         p = buffer;
1233         remaining = buffer_size;
1234
1235         while (remaining > 0) {
1236                 const char *e, *q;
1237
1238                 e = memchr(p, '\n', remaining);
1239
1240                 if (!e) {
1241                         /* Trailing noise, let's ignore it, and flush what we collected */
1242                         log_debug("Received message with trailing noise, ignoring.");
1243                         break;
1244                 }
1245
1246                 if (e == p) {
1247                         /* Entry separator */
1248                         dispatch_message(s, iovec, n, m, ucred, tv, label, label_len, NULL, priority);
1249                         n = 0;
1250                         priority = LOG_INFO;
1251
1252                         p++;
1253                         remaining--;
1254                         continue;
1255                 }
1256
1257                 if (*p == '.' || *p == '#') {
1258                         /* Ignore control commands for now, and
1259                          * comments too. */
1260                         remaining -= (e - p) + 1;
1261                         p = e + 1;
1262                         continue;
1263                 }
1264
1265                 /* A property follows */
1266
1267                 if (n+N_IOVEC_META_FIELDS >= m) {
1268                         struct iovec *c;
1269                         unsigned u;
1270
1271                         u = MAX((n+N_IOVEC_META_FIELDS+1) * 2U, 4U);
1272                         c = realloc(iovec, u * sizeof(struct iovec));
1273                         if (!c) {
1274                                 log_oom();
1275                                 break;
1276                         }
1277
1278                         iovec = c;
1279                         m = u;
1280                 }
1281
1282                 q = memchr(p, '=', e - p);
1283                 if (q) {
1284                         if (valid_user_field(p, q - p)) {
1285                                 size_t l;
1286
1287                                 l = e - p;
1288
1289                                 /* If the field name starts with an
1290                                  * underscore, skip the variable,
1291                                  * since that indidates a trusted
1292                                  * field */
1293                                 iovec[n].iov_base = (char*) p;
1294                                 iovec[n].iov_len = l;
1295                                 n++;
1296
1297                                 /* We need to determine the priority
1298                                  * of this entry for the rate limiting
1299                                  * logic */
1300                                 if (l == 10 &&
1301                                     memcmp(p, "PRIORITY=", 9) == 0 &&
1302                                     p[9] >= '0' && p[9] <= '9')
1303                                         priority = (priority & LOG_FACMASK) | (p[9] - '0');
1304
1305                                 else if (l == 17 &&
1306                                          memcmp(p, "SYSLOG_FACILITY=", 16) == 0 &&
1307                                          p[16] >= '0' && p[16] <= '9')
1308                                         priority = (priority & LOG_PRIMASK) | ((p[16] - '0') << 3);
1309
1310                                 else if (l == 18 &&
1311                                          memcmp(p, "SYSLOG_FACILITY=", 16) == 0 &&
1312                                          p[16] >= '0' && p[16] <= '9' &&
1313                                          p[17] >= '0' && p[17] <= '9')
1314                                         priority = (priority & LOG_PRIMASK) | (((p[16] - '0')*10 + (p[17] - '0')) << 3);
1315
1316                                 else if (l >= 19 &&
1317                                          memcmp(p, "SYSLOG_IDENTIFIER=", 18) == 0) {
1318                                         char *t;
1319
1320                                         t = strndup(p + 18, l - 18);
1321                                         if (t) {
1322                                                 free(identifier);
1323                                                 identifier = t;
1324                                         }
1325                                 } else if (l >= 8 &&
1326                                            memcmp(p, "MESSAGE=", 8) == 0) {
1327                                         char *t;
1328
1329                                         t = strndup(p + 8, l - 8);
1330                                         if (t) {
1331                                                 free(message);
1332                                                 message = t;
1333                                         }
1334                                 }
1335                         }
1336
1337                         remaining -= (e - p) + 1;
1338                         p = e + 1;
1339                         continue;
1340                 } else {
1341                         le64_t l_le;
1342                         uint64_t l;
1343                         char *k;
1344
1345                         if (remaining < e - p + 1 + sizeof(uint64_t) + 1) {
1346                                 log_debug("Failed to parse message, ignoring.");
1347                                 break;
1348                         }
1349
1350                         memcpy(&l_le, e + 1, sizeof(uint64_t));
1351                         l = le64toh(l_le);
1352
1353                         if (remaining < e - p + 1 + sizeof(uint64_t) + l + 1 ||
1354                             e[1+sizeof(uint64_t)+l] != '\n') {
1355                                 log_debug("Failed to parse message, ignoring.");
1356                                 break;
1357                         }
1358
1359                         k = malloc((e - p) + 1 + l);
1360                         if (!k) {
1361                                 log_oom();
1362                                 break;
1363                         }
1364
1365                         memcpy(k, p, e - p);
1366                         k[e - p] = '=';
1367                         memcpy(k + (e - p) + 1, e + 1 + sizeof(uint64_t), l);
1368
1369                         if (valid_user_field(p, e - p)) {
1370                                 iovec[n].iov_base = k;
1371                                 iovec[n].iov_len = (e - p) + 1 + l;
1372                                 n++;
1373                         } else
1374                                 free(k);
1375
1376                         remaining -= (e - p) + 1 + sizeof(uint64_t) + l + 1;
1377                         p = e + 1 + sizeof(uint64_t) + l + 1;
1378                 }
1379         }
1380
1381         if (n <= 0)
1382                 goto finish;
1383
1384         tn = n++;
1385         IOVEC_SET_STRING(iovec[tn], "_TRANSPORT=journal");
1386
1387         if (message) {
1388                 if (s->forward_to_syslog)
1389                         forward_syslog(s, priority, identifier, message, ucred, tv);
1390
1391                 if (s->forward_to_kmsg)
1392                         forward_kmsg(s, priority, identifier, message, ucred);
1393
1394                 if (s->forward_to_console)
1395                         forward_console(s, priority, identifier, message, ucred);
1396         }
1397
1398         dispatch_message(s, iovec, n, m, ucred, tv, label, label_len, NULL, priority);
1399
1400 finish:
1401         for (j = 0; j < n; j++)  {
1402                 if (j == tn)
1403                         continue;
1404
1405                 if (iovec[j].iov_base < buffer ||
1406                     (const uint8_t*) iovec[j].iov_base >= (const uint8_t*) buffer + buffer_size)
1407                         free(iovec[j].iov_base);
1408         }
1409
1410         free(iovec);
1411         free(identifier);
1412         free(message);
1413 }
1414
1415 static void process_native_file(
1416                 Server *s,
1417                 int fd,
1418                 struct ucred *ucred,
1419                 struct timeval *tv,
1420                 const char *label, size_t label_len) {
1421
1422         struct stat st;
1423         void *p;
1424         ssize_t n;
1425
1426         assert(s);
1427         assert(fd >= 0);
1428
1429         /* Data is in the passed file, since it didn't fit in a
1430          * datagram. We can't map the file here, since clients might
1431          * then truncate it and trigger a SIGBUS for us. So let's
1432          * stupidly read it */
1433
1434         if (fstat(fd, &st) < 0) {
1435                 log_error("Failed to stat passed file, ignoring: %m");
1436                 return;
1437         }
1438
1439         if (!S_ISREG(st.st_mode)) {
1440                 log_error("File passed is not regular. Ignoring.");
1441                 return;
1442         }
1443
1444         if (st.st_size <= 0)
1445                 return;
1446
1447         if (st.st_size > ENTRY_SIZE_MAX) {
1448                 log_error("File passed too large. Ignoring.");
1449                 return;
1450         }
1451
1452         p = malloc(st.st_size);
1453         if (!p) {
1454                 log_oom();
1455                 return;
1456         }
1457
1458         n = pread(fd, p, st.st_size, 0);
1459         if (n < 0)
1460                 log_error("Failed to read file, ignoring: %s", strerror(-n));
1461         else if (n > 0)
1462                 process_native_message(s, p, n, ucred, tv, label, label_len);
1463
1464         free(p);
1465 }
1466
1467 static int stdout_stream_log(StdoutStream *s, const char *p) {
1468         struct iovec iovec[N_IOVEC_META_FIELDS + 5];
1469         char *message = NULL, *syslog_priority = NULL, *syslog_facility = NULL, *syslog_identifier = NULL;
1470         unsigned n = 0;
1471         int priority;
1472         char *label = NULL;
1473         size_t label_len = 0;
1474
1475         assert(s);
1476         assert(p);
1477
1478         if (isempty(p))
1479                 return 0;
1480
1481         priority = s->priority;
1482
1483         if (s->level_prefix)
1484                 parse_syslog_priority((char**) &p, &priority);
1485
1486         if (s->forward_to_syslog || s->server->forward_to_syslog)
1487                 forward_syslog(s->server, fixup_priority(priority), s->identifier, p, &s->ucred, NULL);
1488
1489         if (s->forward_to_kmsg || s->server->forward_to_kmsg)
1490                 forward_kmsg(s->server, priority, s->identifier, p, &s->ucred);
1491
1492         if (s->forward_to_console || s->server->forward_to_console)
1493                 forward_console(s->server, priority, s->identifier, p, &s->ucred);
1494
1495         IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=stdout");
1496
1497         if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1498                 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1499
1500         if (priority & LOG_FACMASK)
1501                 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1502                         IOVEC_SET_STRING(iovec[n++], syslog_facility);
1503
1504         if (s->identifier) {
1505                 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", s->identifier);
1506                 if (syslog_identifier)
1507                         IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1508         }
1509
1510         message = strappend("MESSAGE=", p);
1511         if (message)
1512                 IOVEC_SET_STRING(iovec[n++], message);
1513
1514 #ifdef HAVE_SELINUX
1515         if (s->security_context) {
1516                 label = (char*) s->security_context;
1517                 label_len = strlen((char*) s->security_context);
1518         }
1519 #endif
1520
1521         dispatch_message(s->server, iovec, n, ELEMENTSOF(iovec), &s->ucred, NULL, label, label_len, s->unit_id, priority);
1522
1523         free(message);
1524         free(syslog_priority);
1525         free(syslog_facility);
1526         free(syslog_identifier);
1527
1528         return 0;
1529 }
1530
1531 static int stdout_stream_line(StdoutStream *s, char *p) {
1532         int r;
1533
1534         assert(s);
1535         assert(p);
1536
1537         p = strstrip(p);
1538
1539         switch (s->state) {
1540
1541         case STDOUT_STREAM_IDENTIFIER:
1542                 if (isempty(p))
1543                         s->identifier = NULL;
1544                 else  {
1545                         s->identifier = strdup(p);
1546                         if (!s->identifier)
1547                                 return log_oom();
1548                 }
1549
1550                 s->state = STDOUT_STREAM_UNIT_ID;
1551                 return 0;
1552
1553         case STDOUT_STREAM_UNIT_ID:
1554                 if (s->ucred.uid == 0) {
1555                         if (isempty(p))
1556                                 s->unit_id = NULL;
1557                         else  {
1558                                 s->unit_id = strdup(p);
1559                                 if (!s->unit_id)
1560                                         return log_oom();
1561                         }
1562                 }
1563
1564                 s->state = STDOUT_STREAM_PRIORITY;
1565                 return 0;
1566
1567         case STDOUT_STREAM_PRIORITY:
1568                 r = safe_atoi(p, &s->priority);
1569                 if (r < 0 || s->priority <= 0 || s->priority >= 999) {
1570                         log_warning("Failed to parse log priority line.");
1571                         return -EINVAL;
1572                 }
1573
1574                 s->state = STDOUT_STREAM_LEVEL_PREFIX;
1575                 return 0;
1576
1577         case STDOUT_STREAM_LEVEL_PREFIX:
1578                 r = parse_boolean(p);
1579                 if (r < 0) {
1580                         log_warning("Failed to parse level prefix line.");
1581                         return -EINVAL;
1582                 }
1583
1584                 s->level_prefix = !!r;
1585                 s->state = STDOUT_STREAM_FORWARD_TO_SYSLOG;
1586                 return 0;
1587
1588         case STDOUT_STREAM_FORWARD_TO_SYSLOG:
1589                 r = parse_boolean(p);
1590                 if (r < 0) {
1591                         log_warning("Failed to parse forward to syslog line.");
1592                         return -EINVAL;
1593                 }
1594
1595                 s->forward_to_syslog = !!r;
1596                 s->state = STDOUT_STREAM_FORWARD_TO_KMSG;
1597                 return 0;
1598
1599         case STDOUT_STREAM_FORWARD_TO_KMSG:
1600                 r = parse_boolean(p);
1601                 if (r < 0) {
1602                         log_warning("Failed to parse copy to kmsg line.");
1603                         return -EINVAL;
1604                 }
1605
1606                 s->forward_to_kmsg = !!r;
1607                 s->state = STDOUT_STREAM_FORWARD_TO_CONSOLE;
1608                 return 0;
1609
1610         case STDOUT_STREAM_FORWARD_TO_CONSOLE:
1611                 r = parse_boolean(p);
1612                 if (r < 0) {
1613                         log_warning("Failed to parse copy to console line.");
1614                         return -EINVAL;
1615                 }
1616
1617                 s->forward_to_console = !!r;
1618                 s->state = STDOUT_STREAM_RUNNING;
1619                 return 0;
1620
1621         case STDOUT_STREAM_RUNNING:
1622                 return stdout_stream_log(s, p);
1623         }
1624
1625         assert_not_reached("Unknown stream state");
1626 }
1627
1628 static int stdout_stream_scan(StdoutStream *s, bool force_flush) {
1629         char *p;
1630         size_t remaining;
1631         int r;
1632
1633         assert(s);
1634
1635         p = s->buffer;
1636         remaining = s->length;
1637         for (;;) {
1638                 char *end;
1639                 size_t skip;
1640
1641                 end = memchr(p, '\n', remaining);
1642                 if (end)
1643                         skip = end - p + 1;
1644                 else if (remaining >= sizeof(s->buffer) - 1) {
1645                         end = p + sizeof(s->buffer) - 1;
1646                         skip = remaining;
1647                 } else
1648                         break;
1649
1650                 *end = 0;
1651
1652                 r = stdout_stream_line(s, p);
1653                 if (r < 0)
1654                         return r;
1655
1656                 remaining -= skip;
1657                 p += skip;
1658         }
1659
1660         if (force_flush && remaining > 0) {
1661                 p[remaining] = 0;
1662                 r = stdout_stream_line(s, p);
1663                 if (r < 0)
1664                         return r;
1665
1666                 p += remaining;
1667                 remaining = 0;
1668         }
1669
1670         if (p > s->buffer) {
1671                 memmove(s->buffer, p, remaining);
1672                 s->length = remaining;
1673         }
1674
1675         return 0;
1676 }
1677
1678 static int stdout_stream_process(StdoutStream *s) {
1679         ssize_t l;
1680         int r;
1681
1682         assert(s);
1683
1684         l = read(s->fd, s->buffer+s->length, sizeof(s->buffer)-1-s->length);
1685         if (l < 0) {
1686
1687                 if (errno == EAGAIN)
1688                         return 0;
1689
1690                 log_warning("Failed to read from stream: %m");
1691                 return -errno;
1692         }
1693
1694         if (l == 0) {
1695                 r = stdout_stream_scan(s, true);
1696                 if (r < 0)
1697                         return r;
1698
1699                 return 0;
1700         }
1701
1702         s->length += l;
1703         r = stdout_stream_scan(s, false);
1704         if (r < 0)
1705                 return r;
1706
1707         return 1;
1708
1709 }
1710
1711 static void stdout_stream_free(StdoutStream *s) {
1712         assert(s);
1713
1714         if (s->server) {
1715                 assert(s->server->n_stdout_streams > 0);
1716                 s->server->n_stdout_streams --;
1717                 LIST_REMOVE(StdoutStream, stdout_stream, s->server->stdout_streams, s);
1718         }
1719
1720         if (s->fd >= 0) {
1721                 if (s->server)
1722                         epoll_ctl(s->server->epoll_fd, EPOLL_CTL_DEL, s->fd, NULL);
1723
1724                 close_nointr_nofail(s->fd);
1725         }
1726
1727 #ifdef HAVE_SELINUX
1728         if (s->security_context)
1729                 freecon(s->security_context);
1730 #endif
1731
1732         free(s->identifier);
1733         free(s);
1734 }
1735
1736 static int stdout_stream_new(Server *s) {
1737         StdoutStream *stream;
1738         int fd, r;
1739         socklen_t len;
1740         struct epoll_event ev;
1741
1742         assert(s);
1743
1744         fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1745         if (fd < 0) {
1746                 if (errno == EAGAIN)
1747                         return 0;
1748
1749                 log_error("Failed to accept stdout connection: %m");
1750                 return -errno;
1751         }
1752
1753         if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) {
1754                 log_warning("Too many stdout streams, refusing connection.");
1755                 close_nointr_nofail(fd);
1756                 return 0;
1757         }
1758
1759         stream = new0(StdoutStream, 1);
1760         if (!stream) {
1761                 close_nointr_nofail(fd);
1762                 return log_oom();
1763         }
1764
1765         stream->fd = fd;
1766
1767         len = sizeof(stream->ucred);
1768         if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &stream->ucred, &len) < 0) {
1769                 log_error("Failed to determine peer credentials: %m");
1770                 r = -errno;
1771                 goto fail;
1772         }
1773
1774 #ifdef HAVE_SELINUX
1775         if (getpeercon(fd, &stream->security_context) < 0 && errno != ENOPROTOOPT)
1776                 log_error("Failed to determine peer security context: %m");
1777 #endif
1778
1779         if (shutdown(fd, SHUT_WR) < 0) {
1780                 log_error("Failed to shutdown writing side of socket: %m");
1781                 r = -errno;
1782                 goto fail;
1783         }
1784
1785         zero(ev);
1786         ev.data.ptr = stream;
1787         ev.events = EPOLLIN;
1788         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
1789                 log_error("Failed to add stream to event loop: %m");
1790                 r = -errno;
1791                 goto fail;
1792         }
1793
1794         stream->server = s;
1795         LIST_PREPEND(StdoutStream, stdout_stream, s->stdout_streams, stream);
1796         s->n_stdout_streams ++;
1797
1798         return 0;
1799
1800 fail:
1801         stdout_stream_free(stream);
1802         return r;
1803 }
1804
1805 static int parse_kernel_timestamp(char **_p, usec_t *t) {
1806         usec_t r;
1807         int k, i;
1808         char *p;
1809
1810         assert(_p);
1811         assert(*_p);
1812         assert(t);
1813
1814         p = *_p;
1815
1816         if (strlen(p) < 14 || p[0] != '[' || p[13] != ']' || p[6] != '.')
1817                 return 0;
1818
1819         r = 0;
1820
1821         for (i = 1; i <= 5; i++) {
1822                 r *= 10;
1823
1824                 if (p[i] == ' ')
1825                         continue;
1826
1827                 k = undecchar(p[i]);
1828                 if (k < 0)
1829                         return 0;
1830
1831                 r += k;
1832         }
1833
1834         for (i = 7; i <= 12; i++) {
1835                 r *= 10;
1836
1837                 k = undecchar(p[i]);
1838                 if (k < 0)
1839                         return 0;
1840
1841                 r += k;
1842         }
1843
1844         *t = r;
1845         *_p += 14;
1846         *_p += strspn(*_p, WHITESPACE);
1847
1848         return 1;
1849 }
1850
1851 static bool is_us(const char *pid) {
1852         pid_t t;
1853
1854         assert(pid);
1855
1856         if (parse_pid(pid, &t) < 0)
1857                 return false;
1858
1859         return t == getpid();
1860 }
1861
1862 static void proc_kmsg_line(Server *s, const char *p) {
1863         struct iovec iovec[N_IOVEC_META_FIELDS + 7];
1864         char *message = NULL, *syslog_priority = NULL, *syslog_pid = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *source_time = NULL;
1865         int priority = LOG_KERN | LOG_INFO;
1866         unsigned n = 0;
1867         usec_t usec;
1868         char *identifier = NULL, *pid = NULL;
1869
1870         assert(s);
1871         assert(p);
1872
1873         if (isempty(p))
1874                 return;
1875
1876         parse_syslog_priority((char **) &p, &priority);
1877
1878         if (s->forward_to_kmsg && (priority & LOG_FACMASK) != LOG_KERN)
1879                 return;
1880
1881         if (parse_kernel_timestamp((char **) &p, &usec) > 0) {
1882                 if (asprintf(&source_time, "_SOURCE_MONOTONIC_TIMESTAMP=%llu",
1883                              (unsigned long long) usec) >= 0)
1884                         IOVEC_SET_STRING(iovec[n++], source_time);
1885         }
1886
1887         IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=kernel");
1888
1889         if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1890                 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1891
1892         if ((priority & LOG_FACMASK) == LOG_KERN) {
1893
1894                 if (s->forward_to_syslog)
1895                         forward_syslog(s, priority, "kernel", p, NULL, NULL);
1896
1897                 IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=kernel");
1898         } else {
1899                 read_identifier(&p, &identifier, &pid);
1900
1901                 /* Avoid any messages we generated ourselves via
1902                  * log_info() and friends. */
1903                 if (pid && is_us(pid))
1904                         goto finish;
1905
1906                 if (s->forward_to_syslog)
1907                         forward_syslog(s, priority, identifier, p, NULL, NULL);
1908
1909                 if (identifier) {
1910                         syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
1911                         if (syslog_identifier)
1912                                 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1913                 }
1914
1915                 if (pid) {
1916                         syslog_pid = strappend("SYSLOG_PID=", pid);
1917                         if (syslog_pid)
1918                                 IOVEC_SET_STRING(iovec[n++], syslog_pid);
1919                 }
1920
1921                 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1922                         IOVEC_SET_STRING(iovec[n++], syslog_facility);
1923         }
1924
1925         message = strappend("MESSAGE=", p);
1926         if (message)
1927                 IOVEC_SET_STRING(iovec[n++], message);
1928
1929         dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, NULL, NULL, 0, NULL, priority);
1930
1931 finish:
1932         free(message);
1933         free(syslog_priority);
1934         free(syslog_identifier);
1935         free(syslog_pid);
1936         free(syslog_facility);
1937         free(source_time);
1938         free(identifier);
1939         free(pid);
1940 }
1941
1942 static void proc_kmsg_scan(Server *s) {
1943         char *p;
1944         size_t remaining;
1945
1946         assert(s);
1947
1948         p = s->proc_kmsg_buffer;
1949         remaining = s->proc_kmsg_length;
1950         for (;;) {
1951                 char *end;
1952                 size_t skip;
1953
1954                 end = memchr(p, '\n', remaining);
1955                 if (end)
1956                         skip = end - p + 1;
1957                 else if (remaining >= sizeof(s->proc_kmsg_buffer) - 1) {
1958                         end = p + sizeof(s->proc_kmsg_buffer) - 1;
1959                         skip = remaining;
1960                 } else
1961                         break;
1962
1963                 *end = 0;
1964
1965                 proc_kmsg_line(s, p);
1966
1967                 remaining -= skip;
1968                 p += skip;
1969         }
1970
1971         if (p > s->proc_kmsg_buffer) {
1972                 memmove(s->proc_kmsg_buffer, p, remaining);
1973                 s->proc_kmsg_length = remaining;
1974         }
1975 }
1976
1977 static int system_journal_open(Server *s) {
1978         int r;
1979         char *fn;
1980         sd_id128_t machine;
1981         char ids[33];
1982
1983         r = sd_id128_get_machine(&machine);
1984         if (r < 0)
1985                 return r;
1986
1987         sd_id128_to_string(machine, ids);
1988
1989         if (!s->system_journal &&
1990             (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
1991             access("/run/systemd/journal/flushed", F_OK) >= 0) {
1992
1993                 /* If in auto mode: first try to create the machine
1994                  * path, but not the prefix.
1995                  *
1996                  * If in persistent mode: create /var/log/journal and
1997                  * the machine path */
1998
1999                 if (s->storage == STORAGE_PERSISTENT)
2000                         (void) mkdir("/var/log/journal/", 0755);
2001
2002                 fn = strappend("/var/log/journal/", ids);
2003                 if (!fn)
2004                         return -ENOMEM;
2005
2006                 (void) mkdir(fn, 0755);
2007                 free(fn);
2008
2009                 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
2010                 if (!fn)
2011                         return -ENOMEM;
2012
2013                 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, &s->system_metrics, NULL, &s->system_journal);
2014                 free(fn);
2015
2016                 if (r >= 0) {
2017                         s->system_journal->compress = s->compress;
2018
2019                         server_fix_perms(s, s->system_journal, 0);
2020                 } else if (r < 0) {
2021
2022                         if (r != -ENOENT && r != -EROFS)
2023                                 log_warning("Failed to open system journal: %s", strerror(-r));
2024
2025                         r = 0;
2026                 }
2027         }
2028
2029         if (!s->runtime_journal &&
2030             (s->storage != STORAGE_NONE)) {
2031
2032                 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
2033                 if (!fn)
2034                         return -ENOMEM;
2035
2036                 if (s->system_journal) {
2037
2038                         /* Try to open the runtime journal, but only
2039                          * if it already exists, so that we can flush
2040                          * it into the system journal */
2041
2042                         r = journal_file_open(fn, O_RDWR, 0640, &s->runtime_metrics, NULL, &s->runtime_journal);
2043                         free(fn);
2044
2045                         if (r < 0) {
2046                                 if (r != -ENOENT)
2047                                         log_warning("Failed to open runtime journal: %s", strerror(-r));
2048
2049                                 r = 0;
2050                         }
2051
2052                 } else {
2053
2054                         /* OK, we really need the runtime journal, so create
2055                          * it if necessary. */
2056
2057                         (void) mkdir_parents(fn, 0755);
2058                         r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, &s->runtime_metrics, NULL, &s->runtime_journal);
2059                         free(fn);
2060
2061                         if (r < 0) {
2062                                 log_error("Failed to open runtime journal: %s", strerror(-r));
2063                                 return r;
2064                         }
2065                 }
2066
2067                 if (s->runtime_journal) {
2068                         s->runtime_journal->compress = s->compress;
2069
2070                         server_fix_perms(s, s->runtime_journal, 0);
2071                 }
2072         }
2073
2074         return r;
2075 }
2076
2077 static int server_flush_to_var(Server *s) {
2078         Object *o = NULL;
2079         int r;
2080         sd_id128_t machine;
2081         sd_journal *j;
2082
2083         assert(s);
2084
2085         if (s->storage != STORAGE_AUTO &&
2086             s->storage != STORAGE_PERSISTENT)
2087                 return 0;
2088
2089         if (!s->runtime_journal)
2090                 return 0;
2091
2092         system_journal_open(s);
2093
2094         if (!s->system_journal)
2095                 return 0;
2096
2097         log_info("Flushing to /var...");
2098
2099         r = sd_id128_get_machine(&machine);
2100         if (r < 0) {
2101                 log_error("Failed to get machine id: %s", strerror(-r));
2102                 return r;
2103         }
2104
2105         r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
2106         if (r < 0) {
2107                 log_error("Failed to read runtime journal: %s", strerror(-r));
2108                 return r;
2109         }
2110
2111         SD_JOURNAL_FOREACH(j) {
2112                 JournalFile *f;
2113
2114                 f = j->current_file;
2115                 assert(f && f->current_offset > 0);
2116
2117                 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
2118                 if (r < 0) {
2119                         log_error("Can't read entry: %s", strerror(-r));
2120                         goto finish;
2121                 }
2122
2123                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
2124                 if (r == -E2BIG) {
2125                         log_info("Allocation limit reached.");
2126
2127                         journal_file_post_change(s->system_journal);
2128                         server_rotate(s);
2129                         server_vacuum(s);
2130
2131                         r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
2132                 }
2133
2134                 if (r < 0) {
2135                         log_error("Can't write entry: %s", strerror(-r));
2136                         goto finish;
2137                 }
2138         }
2139
2140 finish:
2141         journal_file_post_change(s->system_journal);
2142
2143         journal_file_close(s->runtime_journal);
2144         s->runtime_journal = NULL;
2145
2146         if (r >= 0)
2147                 rm_rf("/run/log/journal", false, true, false);
2148
2149         return r;
2150 }
2151
2152 static int server_read_proc_kmsg(Server *s) {
2153         ssize_t l;
2154         assert(s);
2155         assert(s->proc_kmsg_fd >= 0);
2156
2157         l = read(s->proc_kmsg_fd, s->proc_kmsg_buffer + s->proc_kmsg_length, sizeof(s->proc_kmsg_buffer) - 1 - s->proc_kmsg_length);
2158         if (l == 0) /* the kernel is stupid and in some race
2159                      * conditions returns 0 in the middle of the
2160                      * stream. */
2161                 return 0;
2162         if (l < 0) {
2163
2164                 if (errno == EAGAIN || errno == EINTR)
2165                         return 0;
2166
2167                 log_error("Failed to read from kernel: %m");
2168                 return -errno;
2169         }
2170
2171         s->proc_kmsg_length += l;
2172
2173         proc_kmsg_scan(s);
2174         return 1;
2175 }
2176
2177 static int server_flush_proc_kmsg(Server *s) {
2178         int r;
2179
2180         assert(s);
2181
2182         if (s->proc_kmsg_fd < 0)
2183                 return 0;
2184
2185         log_info("Flushing /proc/kmsg...");
2186
2187         for (;;) {
2188                 r = server_read_proc_kmsg(s);
2189                 if (r < 0)
2190                         return r;
2191
2192                 if (r == 0)
2193                         break;
2194         }
2195
2196         return 0;
2197 }
2198
2199 static int process_event(Server *s, struct epoll_event *ev) {
2200         assert(s);
2201         assert(ev);
2202
2203         if (ev->data.fd == s->signal_fd) {
2204                 struct signalfd_siginfo sfsi;
2205                 ssize_t n;
2206
2207                 if (ev->events != EPOLLIN) {
2208                         log_info("Got invalid event from epoll.");
2209                         return -EIO;
2210                 }
2211
2212                 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
2213                 if (n != sizeof(sfsi)) {
2214
2215                         if (n >= 0)
2216                                 return -EIO;
2217
2218                         if (errno == EINTR || errno == EAGAIN)
2219                                 return 1;
2220
2221                         return -errno;
2222                 }
2223
2224                 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
2225
2226                 if (sfsi.ssi_signo == SIGUSR1) {
2227                         touch("/run/systemd/journal/flushed");
2228                         server_flush_to_var(s);
2229                         return 1;
2230                 }
2231
2232                 if (sfsi.ssi_signo == SIGUSR2) {
2233                         server_rotate(s);
2234                         server_vacuum(s);
2235                         return 1;
2236                 }
2237
2238                 return 0;
2239
2240         } else if (ev->data.fd == s->proc_kmsg_fd) {
2241                 int r;
2242
2243                 if (ev->events != EPOLLIN) {
2244                         log_info("Got invalid event from epoll.");
2245                         return -EIO;
2246                 }
2247
2248                 r = server_read_proc_kmsg(s);
2249                 if (r < 0)
2250                         return r;
2251
2252                 return 1;
2253
2254         } else if (ev->data.fd == s->native_fd ||
2255                    ev->data.fd == s->syslog_fd) {
2256
2257                 if (ev->events != EPOLLIN) {
2258                         log_info("Got invalid event from epoll.");
2259                         return -EIO;
2260                 }
2261
2262                 for (;;) {
2263                         struct msghdr msghdr;
2264                         struct iovec iovec;
2265                         struct ucred *ucred = NULL;
2266                         struct timeval *tv = NULL;
2267                         struct cmsghdr *cmsg;
2268                         char *label = NULL;
2269                         size_t label_len = 0;
2270                         union {
2271                                 struct cmsghdr cmsghdr;
2272
2273                                 /* We use NAME_MAX space for the
2274                                  * SELinux label here. The kernel
2275                                  * currently enforces no limit, but
2276                                  * according to suggestions from the
2277                                  * SELinux people this will change and
2278                                  * it will probably be identical to
2279                                  * NAME_MAX. For now we use that, but
2280                                  * this should be updated one day when
2281                                  * the final limit is known.*/
2282                                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
2283                                             CMSG_SPACE(sizeof(struct timeval)) +
2284                                             CMSG_SPACE(sizeof(int)) + /* fd */
2285                                             CMSG_SPACE(NAME_MAX)]; /* selinux label */
2286                         } control;
2287                         ssize_t n;
2288                         int v;
2289                         int *fds = NULL;
2290                         unsigned n_fds = 0;
2291
2292                         if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
2293                                 log_error("SIOCINQ failed: %m");
2294                                 return -errno;
2295                         }
2296
2297                         if (s->buffer_size < (size_t) v) {
2298                                 void *b;
2299                                 size_t l;
2300
2301                                 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
2302                                 b = realloc(s->buffer, l+1);
2303
2304                                 if (!b) {
2305                                         log_error("Couldn't increase buffer.");
2306                                         return -ENOMEM;
2307                                 }
2308
2309                                 s->buffer_size = l;
2310                                 s->buffer = b;
2311                         }
2312
2313                         zero(iovec);
2314                         iovec.iov_base = s->buffer;
2315                         iovec.iov_len = s->buffer_size;
2316
2317                         zero(control);
2318                         zero(msghdr);
2319                         msghdr.msg_iov = &iovec;
2320                         msghdr.msg_iovlen = 1;
2321                         msghdr.msg_control = &control;
2322                         msghdr.msg_controllen = sizeof(control);
2323
2324                         n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
2325                         if (n < 0) {
2326
2327                                 if (errno == EINTR || errno == EAGAIN)
2328                                         return 1;
2329
2330                                 log_error("recvmsg() failed: %m");
2331                                 return -errno;
2332                         }
2333
2334                         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
2335
2336                                 if (cmsg->cmsg_level == SOL_SOCKET &&
2337                                     cmsg->cmsg_type == SCM_CREDENTIALS &&
2338                                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
2339                                         ucred = (struct ucred*) CMSG_DATA(cmsg);
2340                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
2341                                          cmsg->cmsg_type == SCM_SECURITY) {
2342                                         label = (char*) CMSG_DATA(cmsg);
2343                                         label_len = cmsg->cmsg_len - CMSG_LEN(0);
2344                                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
2345                                          cmsg->cmsg_type == SO_TIMESTAMP &&
2346                                          cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
2347                                         tv = (struct timeval*) CMSG_DATA(cmsg);
2348                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
2349                                          cmsg->cmsg_type == SCM_RIGHTS) {
2350                                         fds = (int*) CMSG_DATA(cmsg);
2351                                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
2352                                 }
2353                         }
2354
2355                         if (ev->data.fd == s->syslog_fd) {
2356                                 char *e;
2357
2358                                 if (n > 0 && n_fds == 0) {
2359                                         e = memchr(s->buffer, '\n', n);
2360                                         if (e)
2361                                                 *e = 0;
2362                                         else
2363                                                 s->buffer[n] = 0;
2364
2365                                         process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
2366                                 } else if (n_fds > 0)
2367                                         log_warning("Got file descriptors via syslog socket. Ignoring.");
2368
2369                         } else {
2370                                 if (n > 0 && n_fds == 0)
2371                                         process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
2372                                 else if (n == 0 && n_fds == 1)
2373                                         process_native_file(s, fds[0], ucred, tv, label, label_len);
2374                                 else if (n_fds > 0)
2375                                         log_warning("Got too many file descriptors via native socket. Ignoring.");
2376                         }
2377
2378                         close_many(fds, n_fds);
2379                 }
2380
2381                 return 1;
2382
2383         } else if (ev->data.fd == s->stdout_fd) {
2384
2385                 if (ev->events != EPOLLIN) {
2386                         log_info("Got invalid event from epoll.");
2387                         return -EIO;
2388                 }
2389
2390                 stdout_stream_new(s);
2391                 return 1;
2392
2393         } else {
2394                 StdoutStream *stream;
2395
2396                 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
2397                         log_info("Got invalid event from epoll.");
2398                         return -EIO;
2399                 }
2400
2401                 /* If it is none of the well-known fds, it must be an
2402                  * stdout stream fd. Note that this is a bit ugly here
2403                  * (since we rely that none of the well-known fds
2404                  * could be interpreted as pointer), but nonetheless
2405                  * safe, since the well-known fds would never get an
2406                  * fd > 4096, i.e. beyond the first memory page */
2407
2408                 stream = ev->data.ptr;
2409
2410                 if (stdout_stream_process(stream) <= 0)
2411                         stdout_stream_free(stream);
2412
2413                 return 1;
2414         }
2415
2416         log_error("Unknown event.");
2417         return 0;
2418 }
2419
2420 static int open_syslog_socket(Server *s) {
2421         union sockaddr_union sa;
2422         int one, r;
2423         struct epoll_event ev;
2424
2425         assert(s);
2426
2427         if (s->syslog_fd < 0) {
2428
2429                 s->syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2430                 if (s->syslog_fd < 0) {
2431                         log_error("socket() failed: %m");
2432                         return -errno;
2433                 }
2434
2435                 zero(sa);
2436                 sa.un.sun_family = AF_UNIX;
2437                 strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));
2438
2439                 unlink(sa.un.sun_path);
2440
2441                 r = bind(s->syslog_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2442                 if (r < 0) {
2443                         log_error("bind() failed: %m");
2444                         return -errno;
2445                 }
2446
2447                 chmod(sa.un.sun_path, 0666);
2448         } else
2449                 fd_nonblock(s->syslog_fd, 1);
2450
2451         one = 1;
2452         r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
2453         if (r < 0) {
2454                 log_error("SO_PASSCRED failed: %m");
2455                 return -errno;
2456         }
2457
2458 #ifdef HAVE_SELINUX
2459         one = 1;
2460         r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
2461         if (r < 0)
2462                 log_warning("SO_PASSSEC failed: %m");
2463 #endif
2464
2465         one = 1;
2466         r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
2467         if (r < 0) {
2468                 log_error("SO_TIMESTAMP failed: %m");
2469                 return -errno;
2470         }
2471
2472         zero(ev);
2473         ev.events = EPOLLIN;
2474         ev.data.fd = s->syslog_fd;
2475         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->syslog_fd, &ev) < 0) {
2476                 log_error("Failed to add syslog server fd to epoll object: %m");
2477                 return -errno;
2478         }
2479
2480         return 0;
2481 }
2482
2483 static int open_native_socket(Server*s) {
2484         union sockaddr_union sa;
2485         int one, r;
2486         struct epoll_event ev;
2487
2488         assert(s);
2489
2490         if (s->native_fd < 0) {
2491
2492                 s->native_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2493                 if (s->native_fd < 0) {
2494                         log_error("socket() failed: %m");
2495                         return -errno;
2496                 }
2497
2498                 zero(sa);
2499                 sa.un.sun_family = AF_UNIX;
2500                 strncpy(sa.un.sun_path, "/run/systemd/journal/socket", sizeof(sa.un.sun_path));
2501
2502                 unlink(sa.un.sun_path);
2503
2504                 r = bind(s->native_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2505                 if (r < 0) {
2506                         log_error("bind() failed: %m");
2507                         return -errno;
2508                 }
2509
2510                 chmod(sa.un.sun_path, 0666);
2511         } else
2512                 fd_nonblock(s->native_fd, 1);
2513
2514         one = 1;
2515         r = setsockopt(s->native_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
2516         if (r < 0) {
2517                 log_error("SO_PASSCRED failed: %m");
2518                 return -errno;
2519         }
2520
2521 #ifdef HAVE_SELINUX
2522         one = 1;
2523         r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
2524         if (r < 0)
2525                 log_warning("SO_PASSSEC failed: %m");
2526 #endif
2527
2528         one = 1;
2529         r = setsockopt(s->native_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
2530         if (r < 0) {
2531                 log_error("SO_TIMESTAMP failed: %m");
2532                 return -errno;
2533         }
2534
2535         zero(ev);
2536         ev.events = EPOLLIN;
2537         ev.data.fd = s->native_fd;
2538         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->native_fd, &ev) < 0) {
2539                 log_error("Failed to add native server fd to epoll object: %m");
2540                 return -errno;
2541         }
2542
2543         return 0;
2544 }
2545
2546 static int open_stdout_socket(Server *s) {
2547         union sockaddr_union sa;
2548         int r;
2549         struct epoll_event ev;
2550
2551         assert(s);
2552
2553         if (s->stdout_fd < 0) {
2554
2555                 s->stdout_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2556                 if (s->stdout_fd < 0) {
2557                         log_error("socket() failed: %m");
2558                         return -errno;
2559                 }
2560
2561                 zero(sa);
2562                 sa.un.sun_family = AF_UNIX;
2563                 strncpy(sa.un.sun_path, "/run/systemd/journal/stdout", sizeof(sa.un.sun_path));
2564
2565                 unlink(sa.un.sun_path);
2566
2567                 r = bind(s->stdout_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2568                 if (r < 0) {
2569                         log_error("bind() failed: %m");
2570                         return -errno;
2571                 }
2572
2573                 chmod(sa.un.sun_path, 0666);
2574
2575                 if (listen(s->stdout_fd, SOMAXCONN) < 0) {
2576                         log_error("liste() failed: %m");
2577                         return -errno;
2578                 }
2579         } else
2580                 fd_nonblock(s->stdout_fd, 1);
2581
2582         zero(ev);
2583         ev.events = EPOLLIN;
2584         ev.data.fd = s->stdout_fd;
2585         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->stdout_fd, &ev) < 0) {
2586                 log_error("Failed to add stdout server fd to epoll object: %m");
2587                 return -errno;
2588         }
2589
2590         return 0;
2591 }
2592
2593 static int open_proc_kmsg(Server *s) {
2594         struct epoll_event ev;
2595
2596         assert(s);
2597
2598         if (!s->import_proc_kmsg)
2599                 return 0;
2600
2601         s->proc_kmsg_fd = open("/proc/kmsg", O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
2602         if (s->proc_kmsg_fd < 0) {
2603                 log_warning("Failed to open /proc/kmsg, ignoring: %m");
2604                 return 0;
2605         }
2606
2607         zero(ev);
2608         ev.events = EPOLLIN;
2609         ev.data.fd = s->proc_kmsg_fd;
2610         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->proc_kmsg_fd, &ev) < 0) {
2611                 log_error("Failed to add /proc/kmsg fd to epoll object: %m");
2612                 return -errno;
2613         }
2614
2615         return 0;
2616 }
2617
2618 static int open_signalfd(Server *s) {
2619         sigset_t mask;
2620         struct epoll_event ev;
2621
2622         assert(s);
2623
2624         assert_se(sigemptyset(&mask) == 0);
2625         sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
2626         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
2627
2628         s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
2629         if (s->signal_fd < 0) {
2630                 log_error("signalfd(): %m");
2631                 return -errno;
2632         }
2633
2634         zero(ev);
2635         ev.events = EPOLLIN;
2636         ev.data.fd = s->signal_fd;
2637
2638         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
2639                 log_error("epoll_ctl(): %m");
2640                 return -errno;
2641         }
2642
2643         return 0;
2644 }
2645
2646 static int server_parse_proc_cmdline(Server *s) {
2647         char *line, *w, *state;
2648         int r;
2649         size_t l;
2650
2651         if (detect_container(NULL) > 0)
2652                 return 0;
2653
2654         r = read_one_line_file("/proc/cmdline", &line);
2655         if (r < 0) {
2656                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
2657                 return 0;
2658         }
2659
2660         FOREACH_WORD_QUOTED(w, l, line, state) {
2661                 char *word;
2662
2663                 word = strndup(w, l);
2664                 if (!word) {
2665                         r = -ENOMEM;
2666                         goto finish;
2667                 }
2668
2669                 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
2670                         r = parse_boolean(word + 35);
2671                         if (r < 0)
2672                                 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
2673                         else
2674                                 s->forward_to_syslog = r;
2675                 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
2676                         r = parse_boolean(word + 33);
2677                         if (r < 0)
2678                                 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
2679                         else
2680                                 s->forward_to_kmsg = r;
2681                 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
2682                         r = parse_boolean(word + 36);
2683                         if (r < 0)
2684                                 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
2685                         else
2686                                 s->forward_to_console = r;
2687                 } else if (startswith(word, "systemd.journald"))
2688                         log_warning("Invalid systemd.journald parameter. Ignoring.");
2689
2690                 free(word);
2691         }
2692
2693         r = 0;
2694
2695 finish:
2696         free(line);
2697         return r;
2698 }
2699
2700 static int server_parse_config_file(Server *s) {
2701         FILE *f;
2702         const char *fn;
2703         int r;
2704
2705         assert(s);
2706
2707         fn = "/etc/systemd/journald.conf";
2708         f = fopen(fn, "re");
2709         if (!f) {
2710                 if (errno == ENOENT)
2711                         return 0;
2712
2713                 log_warning("Failed to open configuration file %s: %m", fn);
2714                 return -errno;
2715         }
2716
2717         r = config_parse(fn, f, "Journal\0", config_item_perf_lookup, (void*) journald_gperf_lookup, false, s);
2718         if (r < 0)
2719                 log_warning("Failed to parse configuration file: %s", strerror(-r));
2720
2721         fclose(f);
2722
2723         return r;
2724 }
2725
2726 static int server_init(Server *s) {
2727         int n, r, fd;
2728
2729         assert(s);
2730
2731         zero(*s);
2732         s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->proc_kmsg_fd = -1;
2733         s->compress = true;
2734
2735         s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
2736         s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
2737
2738         s->forward_to_syslog = true;
2739
2740         s->max_level_store = LOG_DEBUG;
2741         s->max_level_syslog = LOG_DEBUG;
2742         s->max_level_kmsg = LOG_NOTICE;
2743         s->max_level_console = LOG_INFO;
2744
2745         memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
2746         memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
2747
2748         server_parse_config_file(s);
2749         server_parse_proc_cmdline(s);
2750
2751         s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
2752         if (!s->user_journals)
2753                 return log_oom();
2754
2755         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2756         if (s->epoll_fd < 0) {
2757                 log_error("Failed to create epoll object: %m");
2758                 return -errno;
2759         }
2760
2761         n = sd_listen_fds(true);
2762         if (n < 0) {
2763                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
2764                 return n;
2765         }
2766
2767         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
2768
2769                 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
2770
2771                         if (s->native_fd >= 0) {
2772                                 log_error("Too many native sockets passed.");
2773                                 return -EINVAL;
2774                         }
2775
2776                         s->native_fd = fd;
2777
2778                 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
2779
2780                         if (s->stdout_fd >= 0) {
2781                                 log_error("Too many stdout sockets passed.");
2782                                 return -EINVAL;
2783                         }
2784
2785                         s->stdout_fd = fd;
2786
2787                 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
2788
2789                         if (s->syslog_fd >= 0) {
2790                                 log_error("Too many /dev/log sockets passed.");
2791                                 return -EINVAL;
2792                         }
2793
2794                         s->syslog_fd = fd;
2795
2796                 } else {
2797                         log_error("Unknown socket passed.");
2798                         return -EINVAL;
2799                 }
2800         }
2801
2802         r = open_syslog_socket(s);
2803         if (r < 0)
2804                 return r;
2805
2806         r = open_native_socket(s);
2807         if (r < 0)
2808                 return r;
2809
2810         r = open_stdout_socket(s);
2811         if (r < 0)
2812                 return r;
2813
2814         r = open_proc_kmsg(s);
2815         if (r < 0)
2816                 return r;
2817
2818         r = open_signalfd(s);
2819         if (r < 0)
2820                 return r;
2821
2822         s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
2823         if (!s->rate_limit)
2824                 return -ENOMEM;
2825
2826         r = system_journal_open(s);
2827         if (r < 0)
2828                 return r;
2829
2830         return 0;
2831 }
2832
2833 static void server_done(Server *s) {
2834         JournalFile *f;
2835         assert(s);
2836
2837         while (s->stdout_streams)
2838                 stdout_stream_free(s->stdout_streams);
2839
2840         if (s->system_journal)
2841                 journal_file_close(s->system_journal);
2842
2843         if (s->runtime_journal)
2844                 journal_file_close(s->runtime_journal);
2845
2846         while ((f = hashmap_steal_first(s->user_journals)))
2847                 journal_file_close(f);
2848
2849         hashmap_free(s->user_journals);
2850
2851         if (s->epoll_fd >= 0)
2852                 close_nointr_nofail(s->epoll_fd);
2853
2854         if (s->signal_fd >= 0)
2855                 close_nointr_nofail(s->signal_fd);
2856
2857         if (s->syslog_fd >= 0)
2858                 close_nointr_nofail(s->syslog_fd);
2859
2860         if (s->native_fd >= 0)
2861                 close_nointr_nofail(s->native_fd);
2862
2863         if (s->stdout_fd >= 0)
2864                 close_nointr_nofail(s->stdout_fd);
2865
2866         if (s->proc_kmsg_fd >= 0)
2867                 close_nointr_nofail(s->proc_kmsg_fd);
2868
2869         if (s->rate_limit)
2870                 journal_rate_limit_free(s->rate_limit);
2871
2872         free(s->buffer);
2873         free(s->tty_path);
2874 }
2875
2876 int main(int argc, char *argv[]) {
2877         Server server;
2878         int r;
2879
2880         /* if (getppid() != 1) { */
2881         /*         log_error("This program should be invoked by init only."); */
2882         /*         return EXIT_FAILURE; */
2883         /* } */
2884
2885         if (argc > 1) {
2886                 log_error("This program does not take arguments.");
2887                 return EXIT_FAILURE;
2888         }
2889
2890         log_set_target(LOG_TARGET_SAFE);
2891         log_set_facility(LOG_SYSLOG);
2892         log_parse_environment();
2893         log_open();
2894
2895         umask(0022);
2896
2897         r = server_init(&server);
2898         if (r < 0)
2899                 goto finish;
2900
2901         server_vacuum(&server);
2902         server_flush_to_var(&server);
2903         server_flush_proc_kmsg(&server);
2904
2905         log_debug("systemd-journald running as pid %lu", (unsigned long) getpid());
2906         driver_message(&server, SD_MESSAGE_JOURNAL_START, "Journal started");
2907
2908         sd_notify(false,
2909                   "READY=1\n"
2910                   "STATUS=Processing requests...");
2911
2912         for (;;) {
2913                 struct epoll_event event;
2914
2915                 r = epoll_wait(server.epoll_fd, &event, 1, -1);
2916                 if (r < 0) {
2917
2918                         if (errno == EINTR)
2919                                 continue;
2920
2921                         log_error("epoll_wait() failed: %m");
2922                         r = -errno;
2923                         goto finish;
2924                 } else if (r == 0)
2925                         break;
2926
2927                 r = process_event(&server, &event);
2928                 if (r < 0)
2929                         goto finish;
2930                 else if (r == 0)
2931                         break;
2932         }
2933
2934         log_debug("systemd-journald stopped as pid %lu", (unsigned long) getpid());
2935         driver_message(&server, SD_MESSAGE_JOURNAL_STOP, "Journal stopped");
2936
2937 finish:
2938         sd_notify(false,
2939                   "STATUS=Shutting down...");
2940
2941         server_done(&server);
2942
2943         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
2944 }