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=5");
 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 }
1178
1179 static bool valid_user_field(const char *p, size_t l) {
1180         const char *a;
1181
1182         /* We kinda enforce POSIX syntax recommendations for
1183            environment variables here, but make a couple of additional
1184            requirements.
1185
1186            http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html */
1187
1188         /* No empty field names */
1189         if (l <= 0)
1190                 return false;
1191
1192         /* Don't allow names longer than 64 chars */
1193         if (l > 64)
1194                 return false;
1195
1196         /* Variables starting with an underscore are protected */
1197         if (p[0] == '_')
1198                 return false;
1199
1200         /* Don't allow digits as first character */
1201         if (p[0] >= '0' && p[0] <= '9')
1202                 return false;
1203
1204         /* Only allow A-Z0-9 and '_' */
1205         for (a = p; a < p + l; a++)
1206                 if (!((*a >= 'A' && *a <= 'Z') ||
1207                       (*a >= '0' && *a <= '9') ||
1208                       *a == '_'))
1209                         return false;
1210
1211         return true;
1212 }
1213
1214 static void process_native_message(
1215                 Server *s,
1216                 const void *buffer, size_t buffer_size,
1217                 struct ucred *ucred,
1218                 struct timeval *tv,
1219                 const char *label, size_t label_len) {
1220
1221         struct iovec *iovec = NULL;
1222         unsigned n = 0, m = 0, j, tn = (unsigned) -1;
1223         const char *p;
1224         size_t remaining;
1225         int priority = LOG_INFO;
1226         char *identifier = NULL, *message = NULL;
1227
1228         assert(s);
1229         assert(buffer || buffer_size == 0);
1230
1231         p = buffer;
1232         remaining = buffer_size;
1233
1234         while (remaining > 0) {
1235                 const char *e, *q;
1236
1237                 e = memchr(p, '\n', remaining);
1238
1239                 if (!e) {
1240                         /* Trailing noise, let's ignore it, and flush what we collected */
1241                         log_debug("Received message with trailing noise, ignoring.");
1242                         break;
1243                 }
1244
1245                 if (e == p) {
1246                         /* Entry separator */
1247                         dispatch_message(s, iovec, n, m, ucred, tv, label, label_len, NULL, priority);
1248                         n = 0;
1249                         priority = LOG_INFO;
1250
1251                         p++;
1252                         remaining--;
1253                         continue;
1254                 }
1255
1256                 if (*p == '.' || *p == '#') {
1257                         /* Ignore control commands for now, and
1258                          * comments too. */
1259                         remaining -= (e - p) + 1;
1260                         p = e + 1;
1261                         continue;
1262                 }
1263
1264                 /* A property follows */
1265
1266                 if (n+N_IOVEC_META_FIELDS >= m) {
1267                         struct iovec *c;
1268                         unsigned u;
1269
1270                         u = MAX((n+N_IOVEC_META_FIELDS+1) * 2U, 4U);
1271                         c = realloc(iovec, u * sizeof(struct iovec));
1272                         if (!c) {
1273                                 log_oom();
1274                                 break;
1275                         }
1276
1277                         iovec = c;
1278                         m = u;
1279                 }
1280
1281                 q = memchr(p, '=', e - p);
1282                 if (q) {
1283                         if (valid_user_field(p, q - p)) {
1284                                 size_t l;
1285
1286                                 l = e - p;
1287
1288                                 /* If the field name starts with an
1289                                  * underscore, skip the variable,
1290                                  * since that indidates a trusted
1291                                  * field */
1292                                 iovec[n].iov_base = (char*) p;
1293                                 iovec[n].iov_len = l;
1294                                 n++;
1295
1296                                 /* We need to determine the priority
1297                                  * of this entry for the rate limiting
1298                                  * logic */
1299                                 if (l == 10 &&
1300                                     memcmp(p, "PRIORITY=", 9) == 0 &&
1301                                     p[9] >= '0' && p[9] <= '9')
1302                                         priority = (priority & LOG_FACMASK) | (p[9] - '0');
1303
1304                                 else if (l == 17 &&
1305                                          memcmp(p, "SYSLOG_FACILITY=", 16) == 0 &&
1306                                          p[16] >= '0' && p[16] <= '9')
1307                                         priority = (priority & LOG_PRIMASK) | ((p[16] - '0') << 3);
1308
1309                                 else if (l == 18 &&
1310                                          memcmp(p, "SYSLOG_FACILITY=", 16) == 0 &&
1311                                          p[16] >= '0' && p[16] <= '9' &&
1312                                          p[17] >= '0' && p[17] <= '9')
1313                                         priority = (priority & LOG_PRIMASK) | (((p[16] - '0')*10 + (p[17] - '0')) << 3);
1314
1315                                 else if (l >= 19 &&
1316                                          memcmp(p, "SYSLOG_IDENTIFIER=", 18) == 0) {
1317                                         char *t;
1318
1319                                         t = strndup(p + 18, l - 18);
1320                                         if (t) {
1321                                                 free(identifier);
1322                                                 identifier = t;
1323                                         }
1324                                 } else if (l >= 8 &&
1325                                            memcmp(p, "MESSAGE=", 8) == 0) {
1326                                         char *t;
1327
1328                                         t = strndup(p + 8, l - 8);
1329                                         if (t) {
1330                                                 free(message);
1331                                                 message = t;
1332                                         }
1333                                 }
1334                         }
1335
1336                         remaining -= (e - p) + 1;
1337                         p = e + 1;
1338                         continue;
1339                 } else {
1340                         le64_t l_le;
1341                         uint64_t l;
1342                         char *k;
1343
1344                         if (remaining < e - p + 1 + sizeof(uint64_t) + 1) {
1345                                 log_debug("Failed to parse message, ignoring.");
1346                                 break;
1347                         }
1348
1349                         memcpy(&l_le, e + 1, sizeof(uint64_t));
1350                         l = le64toh(l_le);
1351
1352                         if (remaining < e - p + 1 + sizeof(uint64_t) + l + 1 ||
1353                             e[1+sizeof(uint64_t)+l] != '\n') {
1354                                 log_debug("Failed to parse message, ignoring.");
1355                                 break;
1356                         }
1357
1358                         k = malloc((e - p) + 1 + l);
1359                         if (!k) {
1360                                 log_oom();
1361                                 break;
1362                         }
1363
1364                         memcpy(k, p, e - p);
1365                         k[e - p] = '=';
1366                         memcpy(k + (e - p) + 1, e + 1 + sizeof(uint64_t), l);
1367
1368                         if (valid_user_field(p, e - p)) {
1369                                 iovec[n].iov_base = k;
1370                                 iovec[n].iov_len = (e - p) + 1 + l;
1371                                 n++;
1372                         } else
1373                                 free(k);
1374
1375                         remaining -= (e - p) + 1 + sizeof(uint64_t) + l + 1;
1376                         p = e + 1 + sizeof(uint64_t) + l + 1;
1377                 }
1378         }
1379
1380         if (n <= 0)
1381                 goto finish;
1382
1383         tn = n++;
1384         IOVEC_SET_STRING(iovec[tn], "_TRANSPORT=journal");
1385
1386         if (message) {
1387                 if (s->forward_to_syslog)
1388                         forward_syslog(s, priority, identifier, message, ucred, tv);
1389
1390                 if (s->forward_to_kmsg)
1391                         forward_kmsg(s, priority, identifier, message, ucred);
1392
1393                 if (s->forward_to_console)
1394                         forward_console(s, priority, identifier, message, ucred);
1395         }
1396
1397         dispatch_message(s, iovec, n, m, ucred, tv, label, label_len, NULL, priority);
1398
1399 finish:
1400         for (j = 0; j < n; j++)  {
1401                 if (j == tn)
1402                         continue;
1403
1404                 if (iovec[j].iov_base < buffer ||
1405                     (const uint8_t*) iovec[j].iov_base >= (const uint8_t*) buffer + buffer_size)
1406                         free(iovec[j].iov_base);
1407         }
1408
1409         free(iovec);
1410         free(identifier);
1411         free(message);
1412 }
1413
1414 static void process_native_file(
1415                 Server *s,
1416                 int fd,
1417                 struct ucred *ucred,
1418                 struct timeval *tv,
1419                 const char *label, size_t label_len) {
1420
1421         struct stat st;
1422         void *p;
1423         ssize_t n;
1424
1425         assert(s);
1426         assert(fd >= 0);
1427
1428         /* Data is in the passed file, since it didn't fit in a
1429          * datagram. We can't map the file here, since clients might
1430          * then truncate it and trigger a SIGBUS for us. So let's
1431          * stupidly read it */
1432
1433         if (fstat(fd, &st) < 0) {
1434                 log_error("Failed to stat passed file, ignoring: %m");
1435                 return;
1436         }
1437
1438         if (!S_ISREG(st.st_mode)) {
1439                 log_error("File passed is not regular. Ignoring.");
1440                 return;
1441         }
1442
1443         if (st.st_size <= 0)
1444                 return;
1445
1446         if (st.st_size > ENTRY_SIZE_MAX) {
1447                 log_error("File passed too large. Ignoring.");
1448                 return;
1449         }
1450
1451         p = malloc(st.st_size);
1452         if (!p) {
1453                 log_oom();
1454                 return;
1455         }
1456
1457         n = pread(fd, p, st.st_size, 0);
1458         if (n < 0)
1459                 log_error("Failed to read file, ignoring: %s", strerror(-n));
1460         else if (n > 0)
1461                 process_native_message(s, p, n, ucred, tv, label, label_len);
1462
1463         free(p);
1464 }
1465
1466 static int stdout_stream_log(StdoutStream *s, const char *p) {
1467         struct iovec iovec[N_IOVEC_META_FIELDS + 5];
1468         char *message = NULL, *syslog_priority = NULL, *syslog_facility = NULL, *syslog_identifier = NULL;
1469         unsigned n = 0;
1470         int priority;
1471         char *label = NULL;
1472         size_t label_len = 0;
1473
1474         assert(s);
1475         assert(p);
1476
1477         if (isempty(p))
1478                 return 0;
1479
1480         priority = s->priority;
1481
1482         if (s->level_prefix)
1483                 parse_syslog_priority((char**) &p, &priority);
1484
1485         if (s->forward_to_syslog || s->server->forward_to_syslog)
1486                 forward_syslog(s->server, fixup_priority(priority), s->identifier, p, &s->ucred, NULL);
1487
1488         if (s->forward_to_kmsg || s->server->forward_to_kmsg)
1489                 forward_kmsg(s->server, priority, s->identifier, p, &s->ucred);
1490
1491         if (s->forward_to_console || s->server->forward_to_console)
1492                 forward_console(s->server, priority, s->identifier, p, &s->ucred);
1493
1494         IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=stdout");
1495
1496         if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1497                 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1498
1499         if (priority & LOG_FACMASK)
1500                 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1501                         IOVEC_SET_STRING(iovec[n++], syslog_facility);
1502
1503         if (s->identifier) {
1504                 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", s->identifier);
1505                 if (syslog_identifier)
1506                         IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1507         }
1508
1509         message = strappend("MESSAGE=", p);
1510         if (message)
1511                 IOVEC_SET_STRING(iovec[n++], message);
1512
1513 #ifdef HAVE_SELINUX
1514         if (s->security_context) {
1515                 label = (char*) s->security_context;
1516                 label_len = strlen((char*) s->security_context);
1517         }
1518 #endif
1519
1520         dispatch_message(s->server, iovec, n, ELEMENTSOF(iovec), &s->ucred, NULL, label, label_len, s->unit_id, priority);
1521
1522         free(message);
1523         free(syslog_priority);
1524         free(syslog_facility);
1525         free(syslog_identifier);
1526
1527         return 0;
1528 }
1529
1530 static int stdout_stream_line(StdoutStream *s, char *p) {
1531         int r;
1532
1533         assert(s);
1534         assert(p);
1535
1536         p = strstrip(p);
1537
1538         switch (s->state) {
1539
1540         case STDOUT_STREAM_IDENTIFIER:
1541                 if (isempty(p))
1542                         s->identifier = NULL;
1543                 else  {
1544                         s->identifier = strdup(p);
1545                         if (!s->identifier)
1546                                 return log_oom();
1547                 }
1548
1549                 s->state = STDOUT_STREAM_UNIT_ID;
1550                 return 0;
1551
1552         case STDOUT_STREAM_UNIT_ID:
1553                 if (s->ucred.uid == 0) {
1554                         if (isempty(p))
1555                                 s->unit_id = NULL;
1556                         else  {
1557                                 s->unit_id = strdup(p);
1558                                 if (!s->unit_id)
1559                                         return log_oom();
1560                         }
1561                 }
1562
1563                 s->state = STDOUT_STREAM_PRIORITY;
1564                 return 0;
1565
1566         case STDOUT_STREAM_PRIORITY:
1567                 r = safe_atoi(p, &s->priority);
1568                 if (r < 0 || s->priority <= 0 || s->priority >= 999) {
1569                         log_warning("Failed to parse log priority line.");
1570                         return -EINVAL;
1571                 }
1572
1573                 s->state = STDOUT_STREAM_LEVEL_PREFIX;
1574                 return 0;
1575
1576         case STDOUT_STREAM_LEVEL_PREFIX:
1577                 r = parse_boolean(p);
1578                 if (r < 0) {
1579                         log_warning("Failed to parse level prefix line.");
1580                         return -EINVAL;
1581                 }
1582
1583                 s->level_prefix = !!r;
1584                 s->state = STDOUT_STREAM_FORWARD_TO_SYSLOG;
1585                 return 0;
1586
1587         case STDOUT_STREAM_FORWARD_TO_SYSLOG:
1588                 r = parse_boolean(p);
1589                 if (r < 0) {
1590                         log_warning("Failed to parse forward to syslog line.");
1591                         return -EINVAL;
1592                 }
1593
1594                 s->forward_to_syslog = !!r;
1595                 s->state = STDOUT_STREAM_FORWARD_TO_KMSG;
1596                 return 0;
1597
1598         case STDOUT_STREAM_FORWARD_TO_KMSG:
1599                 r = parse_boolean(p);
1600                 if (r < 0) {
1601                         log_warning("Failed to parse copy to kmsg line.");
1602                         return -EINVAL;
1603                 }
1604
1605                 s->forward_to_kmsg = !!r;
1606                 s->state = STDOUT_STREAM_FORWARD_TO_CONSOLE;
1607                 return 0;
1608
1609         case STDOUT_STREAM_FORWARD_TO_CONSOLE:
1610                 r = parse_boolean(p);
1611                 if (r < 0) {
1612                         log_warning("Failed to parse copy to console line.");
1613                         return -EINVAL;
1614                 }
1615
1616                 s->forward_to_console = !!r;
1617                 s->state = STDOUT_STREAM_RUNNING;
1618                 return 0;
1619
1620         case STDOUT_STREAM_RUNNING:
1621                 return stdout_stream_log(s, p);
1622         }
1623
1624         assert_not_reached("Unknown stream state");
1625 }
1626
1627 static int stdout_stream_scan(StdoutStream *s, bool force_flush) {
1628         char *p;
1629         size_t remaining;
1630         int r;
1631
1632         assert(s);
1633
1634         p = s->buffer;
1635         remaining = s->length;
1636         for (;;) {
1637                 char *end;
1638                 size_t skip;
1639
1640                 end = memchr(p, '\n', remaining);
1641                 if (end)
1642                         skip = end - p + 1;
1643                 else if (remaining >= sizeof(s->buffer) - 1) {
1644                         end = p + sizeof(s->buffer) - 1;
1645                         skip = remaining;
1646                 } else
1647                         break;
1648
1649                 *end = 0;
1650
1651                 r = stdout_stream_line(s, p);
1652                 if (r < 0)
1653                         return r;
1654
1655                 remaining -= skip;
1656                 p += skip;
1657         }
1658
1659         if (force_flush && remaining > 0) {
1660                 p[remaining] = 0;
1661                 r = stdout_stream_line(s, p);
1662                 if (r < 0)
1663                         return r;
1664
1665                 p += remaining;
1666                 remaining = 0;
1667         }
1668
1669         if (p > s->buffer) {
1670                 memmove(s->buffer, p, remaining);
1671                 s->length = remaining;
1672         }
1673
1674         return 0;
1675 }
1676
1677 static int stdout_stream_process(StdoutStream *s) {
1678         ssize_t l;
1679         int r;
1680
1681         assert(s);
1682
1683         l = read(s->fd, s->buffer+s->length, sizeof(s->buffer)-1-s->length);
1684         if (l < 0) {
1685
1686                 if (errno == EAGAIN)
1687                         return 0;
1688
1689                 log_warning("Failed to read from stream: %m");
1690                 return -errno;
1691         }
1692
1693         if (l == 0) {
1694                 r = stdout_stream_scan(s, true);
1695                 if (r < 0)
1696                         return r;
1697
1698                 return 0;
1699         }
1700
1701         s->length += l;
1702         r = stdout_stream_scan(s, false);
1703         if (r < 0)
1704                 return r;
1705
1706         return 1;
1707
1708 }
1709
1710 static void stdout_stream_free(StdoutStream *s) {
1711         assert(s);
1712
1713         if (s->server) {
1714                 assert(s->server->n_stdout_streams > 0);
1715                 s->server->n_stdout_streams --;
1716                 LIST_REMOVE(StdoutStream, stdout_stream, s->server->stdout_streams, s);
1717         }
1718
1719         if (s->fd >= 0) {
1720                 if (s->server)
1721                         epoll_ctl(s->server->epoll_fd, EPOLL_CTL_DEL, s->fd, NULL);
1722
1723                 close_nointr_nofail(s->fd);
1724         }
1725
1726 #ifdef HAVE_SELINUX
1727         if (s->security_context)
1728                 freecon(s->security_context);
1729 #endif
1730
1731         free(s->identifier);
1732         free(s);
1733 }
1734
1735 static int stdout_stream_new(Server *s) {
1736         StdoutStream *stream;
1737         int fd, r;
1738         socklen_t len;
1739         struct epoll_event ev;
1740
1741         assert(s);
1742
1743         fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1744         if (fd < 0) {
1745                 if (errno == EAGAIN)
1746                         return 0;
1747
1748                 log_error("Failed to accept stdout connection: %m");
1749                 return -errno;
1750         }
1751
1752         if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) {
1753                 log_warning("Too many stdout streams, refusing connection.");
1754                 close_nointr_nofail(fd);
1755                 return 0;
1756         }
1757
1758         stream = new0(StdoutStream, 1);
1759         if (!stream) {
1760                 close_nointr_nofail(fd);
1761                 return log_oom();
1762         }
1763
1764         stream->fd = fd;
1765
1766         len = sizeof(stream->ucred);
1767         if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &stream->ucred, &len) < 0) {
1768                 log_error("Failed to determine peer credentials: %m");
1769                 r = -errno;
1770                 goto fail;
1771         }
1772
1773 #ifdef HAVE_SELINUX
1774         if (getpeercon(fd, &stream->security_context) < 0 && errno != ENOPROTOOPT)
1775                 log_error("Failed to determine peer security context: %m");
1776 #endif
1777
1778         if (shutdown(fd, SHUT_WR) < 0) {
1779                 log_error("Failed to shutdown writing side of socket: %m");
1780                 r = -errno;
1781                 goto fail;
1782         }
1783
1784         zero(ev);
1785         ev.data.ptr = stream;
1786         ev.events = EPOLLIN;
1787         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
1788                 log_error("Failed to add stream to event loop: %m");
1789                 r = -errno;
1790                 goto fail;
1791         }
1792
1793         stream->server = s;
1794         LIST_PREPEND(StdoutStream, stdout_stream, s->stdout_streams, stream);
1795         s->n_stdout_streams ++;
1796
1797         return 0;
1798
1799 fail:
1800         stdout_stream_free(stream);
1801         return r;
1802 }
1803
1804 static int parse_kernel_timestamp(char **_p, usec_t *t) {
1805         usec_t r;
1806         int k, i;
1807         char *p;
1808
1809         assert(_p);
1810         assert(*_p);
1811         assert(t);
1812
1813         p = *_p;
1814
1815         if (strlen(p) < 14 || p[0] != '[' || p[13] != ']' || p[6] != '.')
1816                 return 0;
1817
1818         r = 0;
1819
1820         for (i = 1; i <= 5; i++) {
1821                 r *= 10;
1822
1823                 if (p[i] == ' ')
1824                         continue;
1825
1826                 k = undecchar(p[i]);
1827                 if (k < 0)
1828                         return 0;
1829
1830                 r += k;
1831         }
1832
1833         for (i = 7; i <= 12; i++) {
1834                 r *= 10;
1835
1836                 k = undecchar(p[i]);
1837                 if (k < 0)
1838                         return 0;
1839
1840                 r += k;
1841         }
1842
1843         *t = r;
1844         *_p += 14;
1845         *_p += strspn(*_p, WHITESPACE);
1846
1847         return 1;
1848 }
1849
1850 static bool is_us(const char *pid) {
1851         pid_t t;
1852
1853         assert(pid);
1854
1855         if (parse_pid(pid, &t) < 0)
1856                 return false;
1857
1858         return t == getpid();
1859 }
1860
1861 static void proc_kmsg_line(Server *s, const char *p) {
1862         struct iovec iovec[N_IOVEC_META_FIELDS + 7];
1863         char *message = NULL, *syslog_priority = NULL, *syslog_pid = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *source_time = NULL;
1864         int priority = LOG_KERN | LOG_INFO;
1865         unsigned n = 0;
1866         usec_t usec;
1867         char *identifier = NULL, *pid = NULL;
1868
1869         assert(s);
1870         assert(p);
1871
1872         if (isempty(p))
1873                 return;
1874
1875         parse_syslog_priority((char **) &p, &priority);
1876
1877         if (s->forward_to_kmsg && (priority & LOG_FACMASK) != LOG_KERN)
1878                 return;
1879
1880         if (parse_kernel_timestamp((char **) &p, &usec) > 0) {
1881                 if (asprintf(&source_time, "_SOURCE_MONOTONIC_TIMESTAMP=%llu",
1882                              (unsigned long long) usec) >= 0)
1883                         IOVEC_SET_STRING(iovec[n++], source_time);
1884         }
1885
1886         IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=kernel");
1887
1888         if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1889                 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1890
1891         if ((priority & LOG_FACMASK) == LOG_KERN) {
1892
1893                 if (s->forward_to_syslog)
1894                         forward_syslog(s, priority, "kernel", p, NULL, NULL);
1895
1896                 IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=kernel");
1897         } else {
1898                 read_identifier(&p, &identifier, &pid);
1899
1900                 /* Avoid any messages we generated ourselves via
1901                  * log_info() and friends. */
1902                 if (pid && is_us(pid))
1903                         goto finish;
1904
1905                 if (s->forward_to_syslog)
1906                         forward_syslog(s, priority, identifier, p, NULL, NULL);
1907
1908                 if (identifier) {
1909                         syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
1910                         if (syslog_identifier)
1911                                 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1912                 }
1913
1914                 if (pid) {
1915                         syslog_pid = strappend("SYSLOG_PID=", pid);
1916                         if (syslog_pid)
1917                                 IOVEC_SET_STRING(iovec[n++], syslog_pid);
1918                 }
1919
1920                 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1921                         IOVEC_SET_STRING(iovec[n++], syslog_facility);
1922         }
1923
1924         message = strappend("MESSAGE=", p);
1925         if (message)
1926                 IOVEC_SET_STRING(iovec[n++], message);
1927
1928         dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, NULL, NULL, 0, NULL, priority);
1929
1930 finish:
1931         free(message);
1932         free(syslog_priority);
1933         free(syslog_identifier);
1934         free(syslog_pid);
1935         free(syslog_facility);
1936         free(source_time);
1937         free(identifier);
1938         free(pid);
1939 }
1940
1941 static void proc_kmsg_scan(Server *s) {
1942         char *p;
1943         size_t remaining;
1944
1945         assert(s);
1946
1947         p = s->proc_kmsg_buffer;
1948         remaining = s->proc_kmsg_length;
1949         for (;;) {
1950                 char *end;
1951                 size_t skip;
1952
1953                 end = memchr(p, '\n', remaining);
1954                 if (end)
1955                         skip = end - p + 1;
1956                 else if (remaining >= sizeof(s->proc_kmsg_buffer) - 1) {
1957                         end = p + sizeof(s->proc_kmsg_buffer) - 1;
1958                         skip = remaining;
1959                 } else
1960                         break;
1961
1962                 *end = 0;
1963
1964                 proc_kmsg_line(s, p);
1965
1966                 remaining -= skip;
1967                 p += skip;
1968         }
1969
1970         if (p > s->proc_kmsg_buffer) {
1971                 memmove(s->proc_kmsg_buffer, p, remaining);
1972                 s->proc_kmsg_length = remaining;
1973         }
1974 }
1975
1976 static int system_journal_open(Server *s) {
1977         int r;
1978         char *fn;
1979         sd_id128_t machine;
1980         char ids[33];
1981
1982         r = sd_id128_get_machine(&machine);
1983         if (r < 0)
1984                 return r;
1985
1986         sd_id128_to_string(machine, ids);
1987
1988         if (!s->system_journal &&
1989             (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
1990             access("/run/systemd/journal/flushed", F_OK) >= 0) {
1991
1992                 /* If in auto mode: first try to create the machine
1993                  * path, but not the prefix.
1994                  *
1995                  * If in persistent mode: create /var/log/journal and
1996                  * the machine path */
1997
1998                 if (s->storage == STORAGE_PERSISTENT)
1999                         (void) mkdir("/var/log/journal/", 0755);
2000
2001                 fn = strappend("/var/log/journal/", ids);
2002                 if (!fn)
2003                         return -ENOMEM;
2004
2005                 (void) mkdir(fn, 0755);
2006                 free(fn);
2007
2008                 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
2009                 if (!fn)
2010                         return -ENOMEM;
2011
2012                 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, &s->system_metrics, NULL, &s->system_journal);
2013                 free(fn);
2014
2015                 if (r >= 0) {
2016                         s->system_journal->compress = s->compress;
2017
2018                         server_fix_perms(s, s->system_journal, 0);
2019                 } else if (r < 0) {
2020
2021                         if (r != -ENOENT && r != -EROFS)
2022                                 log_warning("Failed to open system journal: %s", strerror(-r));
2023
2024                         r = 0;
2025                 }
2026         }
2027
2028         if (!s->runtime_journal &&
2029             (s->storage != STORAGE_NONE)) {
2030
2031                 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
2032                 if (!fn)
2033                         return -ENOMEM;
2034
2035                 if (s->system_journal) {
2036
2037                         /* Try to open the runtime journal, but only
2038                          * if it already exists, so that we can flush
2039                          * it into the system journal */
2040
2041                         r = journal_file_open(fn, O_RDWR, 0640, &s->runtime_metrics, NULL, &s->runtime_journal);
2042                         free(fn);
2043
2044                         if (r < 0) {
2045                                 if (r != -ENOENT)
2046                                         log_warning("Failed to open runtime journal: %s", strerror(-r));
2047
2048                                 r = 0;
2049                         }
2050
2051                 } else {
2052
2053                         /* OK, we really need the runtime journal, so create
2054                          * it if necessary. */
2055
2056                         (void) mkdir_parents(fn, 0755);
2057                         r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, &s->runtime_metrics, NULL, &s->runtime_journal);
2058                         free(fn);
2059
2060                         if (r < 0) {
2061                                 log_error("Failed to open runtime journal: %s", strerror(-r));
2062                                 return r;
2063                         }
2064                 }
2065
2066                 if (s->runtime_journal) {
2067                         s->runtime_journal->compress = s->compress;
2068
2069                         server_fix_perms(s, s->runtime_journal, 0);
2070                 }
2071         }
2072
2073         return r;
2074 }
2075
2076 static int server_flush_to_var(Server *s) {
2077         Object *o = NULL;
2078         int r;
2079         sd_id128_t machine;
2080         sd_journal *j;
2081
2082         assert(s);
2083
2084         if (s->storage != STORAGE_AUTO &&
2085             s->storage != STORAGE_PERSISTENT)
2086                 return 0;
2087
2088         if (!s->runtime_journal)
2089                 return 0;
2090
2091         system_journal_open(s);
2092
2093         if (!s->system_journal)
2094                 return 0;
2095
2096         log_info("Flushing to /var...");
2097
2098         r = sd_id128_get_machine(&machine);
2099         if (r < 0) {
2100                 log_error("Failed to get machine id: %s", strerror(-r));
2101                 return r;
2102         }
2103
2104         r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
2105         if (r < 0) {
2106                 log_error("Failed to read runtime journal: %s", strerror(-r));
2107                 return r;
2108         }
2109
2110         SD_JOURNAL_FOREACH(j) {
2111                 JournalFile *f;
2112
2113                 f = j->current_file;
2114                 assert(f && f->current_offset > 0);
2115
2116                 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
2117                 if (r < 0) {
2118                         log_error("Can't read entry: %s", strerror(-r));
2119                         goto finish;
2120                 }
2121
2122                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
2123                 if (r == -E2BIG) {
2124                         log_info("Allocation limit reached.");
2125
2126                         journal_file_post_change(s->system_journal);
2127                         server_rotate(s);
2128                         server_vacuum(s);
2129
2130                         r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
2131                 }
2132
2133                 if (r < 0) {
2134                         log_error("Can't write entry: %s", strerror(-r));
2135                         goto finish;
2136                 }
2137         }
2138
2139 finish:
2140         journal_file_post_change(s->system_journal);
2141
2142         journal_file_close(s->runtime_journal);
2143         s->runtime_journal = NULL;
2144
2145         if (r >= 0)
2146                 rm_rf("/run/log/journal", false, true, false);
2147
2148         return r;
2149 }
2150
2151 static int server_read_proc_kmsg(Server *s) {
2152         ssize_t l;
2153         assert(s);
2154         assert(s->proc_kmsg_fd >= 0);
2155
2156         l = read(s->proc_kmsg_fd, s->proc_kmsg_buffer + s->proc_kmsg_length, sizeof(s->proc_kmsg_buffer) - 1 - s->proc_kmsg_length);
2157         if (l == 0) /* the kernel is stupid and in some race
2158                      * conditions returns 0 in the middle of the
2159                      * stream. */
2160                 return 0;
2161         if (l < 0) {
2162
2163                 if (errno == EAGAIN || errno == EINTR)
2164                         return 0;
2165
2166                 log_error("Failed to read from kernel: %m");
2167                 return -errno;
2168         }
2169
2170         s->proc_kmsg_length += l;
2171
2172         proc_kmsg_scan(s);
2173         return 1;
2174 }
2175
2176 static int server_flush_proc_kmsg(Server *s) {
2177         int r;
2178
2179         assert(s);
2180
2181         if (s->proc_kmsg_fd < 0)
2182                 return 0;
2183
2184         log_info("Flushing /proc/kmsg...");
2185
2186         for (;;) {
2187                 r = server_read_proc_kmsg(s);
2188                 if (r < 0)
2189                         return r;
2190
2191                 if (r == 0)
2192                         break;
2193         }
2194
2195         return 0;
2196 }
2197
2198 static int process_event(Server *s, struct epoll_event *ev) {
2199         assert(s);
2200         assert(ev);
2201
2202         if (ev->data.fd == s->signal_fd) {
2203                 struct signalfd_siginfo sfsi;
2204                 ssize_t n;
2205
2206                 if (ev->events != EPOLLIN) {
2207                         log_info("Got invalid event from epoll.");
2208                         return -EIO;
2209                 }
2210
2211                 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
2212                 if (n != sizeof(sfsi)) {
2213
2214                         if (n >= 0)
2215                                 return -EIO;
2216
2217                         if (errno == EINTR || errno == EAGAIN)
2218                                 return 1;
2219
2220                         return -errno;
2221                 }
2222
2223                 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
2224
2225                 if (sfsi.ssi_signo == SIGUSR1) {
2226                         touch("/run/systemd/journal/flushed");
2227                         server_flush_to_var(s);
2228                         return 1;
2229                 }
2230
2231                 if (sfsi.ssi_signo == SIGUSR2) {
2232                         server_rotate(s);
2233                         server_vacuum(s);
2234                         return 1;
2235                 }
2236
2237                 return 0;
2238
2239         } else if (ev->data.fd == s->proc_kmsg_fd) {
2240                 int r;
2241
2242                 if (ev->events != EPOLLIN) {
2243                         log_info("Got invalid event from epoll.");
2244                         return -EIO;
2245                 }
2246
2247                 r = server_read_proc_kmsg(s);
2248                 if (r < 0)
2249                         return r;
2250
2251                 return 1;
2252
2253         } else if (ev->data.fd == s->native_fd ||
2254                    ev->data.fd == s->syslog_fd) {
2255
2256                 if (ev->events != EPOLLIN) {
2257                         log_info("Got invalid event from epoll.");
2258                         return -EIO;
2259                 }
2260
2261                 for (;;) {
2262                         struct msghdr msghdr;
2263                         struct iovec iovec;
2264                         struct ucred *ucred = NULL;
2265                         struct timeval *tv = NULL;
2266                         struct cmsghdr *cmsg;
2267                         char *label = NULL;
2268                         size_t label_len = 0;
2269                         union {
2270                                 struct cmsghdr cmsghdr;
2271
2272                                 /* We use NAME_MAX space for the
2273                                  * SELinux label here. The kernel
2274                                  * currently enforces no limit, but
2275                                  * according to suggestions from the
2276                                  * SELinux people this will change and
2277                                  * it will probably be identical to
2278                                  * NAME_MAX. For now we use that, but
2279                                  * this should be updated one day when
2280                                  * the final limit is known.*/
2281                                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
2282                                             CMSG_SPACE(sizeof(struct timeval)) +
2283                                             CMSG_SPACE(sizeof(int)) + /* fd */
2284                                             CMSG_SPACE(NAME_MAX)]; /* selinux label */
2285                         } control;
2286                         ssize_t n;
2287                         int v;
2288                         int *fds = NULL;
2289                         unsigned n_fds = 0;
2290
2291                         if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
2292                                 log_error("SIOCINQ failed: %m");
2293                                 return -errno;
2294                         }
2295
2296                         if (s->buffer_size < (size_t) v) {
2297                                 void *b;
2298                                 size_t l;
2299
2300                                 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
2301                                 b = realloc(s->buffer, l+1);
2302
2303                                 if (!b) {
2304                                         log_error("Couldn't increase buffer.");
2305                                         return -ENOMEM;
2306                                 }
2307
2308                                 s->buffer_size = l;
2309                                 s->buffer = b;
2310                         }
2311
2312                         zero(iovec);
2313                         iovec.iov_base = s->buffer;
2314                         iovec.iov_len = s->buffer_size;
2315
2316                         zero(control);
2317                         zero(msghdr);
2318                         msghdr.msg_iov = &iovec;
2319                         msghdr.msg_iovlen = 1;
2320                         msghdr.msg_control = &control;
2321                         msghdr.msg_controllen = sizeof(control);
2322
2323                         n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
2324                         if (n < 0) {
2325
2326                                 if (errno == EINTR || errno == EAGAIN)
2327                                         return 1;
2328
2329                                 log_error("recvmsg() failed: %m");
2330                                 return -errno;
2331                         }
2332
2333                         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
2334
2335                                 if (cmsg->cmsg_level == SOL_SOCKET &&
2336                                     cmsg->cmsg_type == SCM_CREDENTIALS &&
2337                                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
2338                                         ucred = (struct ucred*) CMSG_DATA(cmsg);
2339                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
2340                                          cmsg->cmsg_type == SCM_SECURITY) {
2341                                         label = (char*) CMSG_DATA(cmsg);
2342                                         label_len = cmsg->cmsg_len - CMSG_LEN(0);
2343                                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
2344                                          cmsg->cmsg_type == SO_TIMESTAMP &&
2345                                          cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
2346                                         tv = (struct timeval*) CMSG_DATA(cmsg);
2347                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
2348                                          cmsg->cmsg_type == SCM_RIGHTS) {
2349                                         fds = (int*) CMSG_DATA(cmsg);
2350                                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
2351                                 }
2352                         }
2353
2354                         if (ev->data.fd == s->syslog_fd) {
2355                                 char *e;
2356
2357                                 if (n > 0 && n_fds == 0) {
2358                                         e = memchr(s->buffer, '\n', n);
2359                                         if (e)
2360                                                 *e = 0;
2361                                         else
2362                                                 s->buffer[n] = 0;
2363
2364                                         process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
2365                                 } else if (n_fds > 0)
2366                                         log_warning("Got file descriptors via syslog socket. Ignoring.");
2367
2368                         } else {
2369                                 if (n > 0 && n_fds == 0)
2370                                         process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
2371                                 else if (n == 0 && n_fds == 1)
2372                                         process_native_file(s, fds[0], ucred, tv, label, label_len);
2373                                 else if (n_fds > 0)
2374                                         log_warning("Got too many file descriptors via native socket. Ignoring.");
2375                         }
2376
2377                         close_many(fds, n_fds);
2378                 }
2379
2380                 return 1;
2381
2382         } else if (ev->data.fd == s->stdout_fd) {
2383
2384                 if (ev->events != EPOLLIN) {
2385                         log_info("Got invalid event from epoll.");
2386                         return -EIO;
2387                 }
2388
2389                 stdout_stream_new(s);
2390                 return 1;
2391
2392         } else {
2393                 StdoutStream *stream;
2394
2395                 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
2396                         log_info("Got invalid event from epoll.");
2397                         return -EIO;
2398                 }
2399
2400                 /* If it is none of the well-known fds, it must be an
2401                  * stdout stream fd. Note that this is a bit ugly here
2402                  * (since we rely that none of the well-known fds
2403                  * could be interpreted as pointer), but nonetheless
2404                  * safe, since the well-known fds would never get an
2405                  * fd > 4096, i.e. beyond the first memory page */
2406
2407                 stream = ev->data.ptr;
2408
2409                 if (stdout_stream_process(stream) <= 0)
2410                         stdout_stream_free(stream);
2411
2412                 return 1;
2413         }
2414
2415         log_error("Unknown event.");
2416         return 0;
2417 }
2418
2419 static int open_syslog_socket(Server *s) {
2420         union sockaddr_union sa;
2421         int one, r;
2422         struct epoll_event ev;
2423
2424         assert(s);
2425
2426         if (s->syslog_fd < 0) {
2427
2428                 s->syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2429                 if (s->syslog_fd < 0) {
2430                         log_error("socket() failed: %m");
2431                         return -errno;
2432                 }
2433
2434                 zero(sa);
2435                 sa.un.sun_family = AF_UNIX;
2436                 strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));
2437
2438                 unlink(sa.un.sun_path);
2439
2440                 r = bind(s->syslog_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2441                 if (r < 0) {
2442                         log_error("bind() failed: %m");
2443                         return -errno;
2444                 }
2445
2446                 chmod(sa.un.sun_path, 0666);
2447         } else
2448                 fd_nonblock(s->syslog_fd, 1);
2449
2450         one = 1;
2451         r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
2452         if (r < 0) {
2453                 log_error("SO_PASSCRED failed: %m");
2454                 return -errno;
2455         }
2456
2457 #ifdef HAVE_SELINUX
2458         one = 1;
2459         r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
2460         if (r < 0)
2461                 log_warning("SO_PASSSEC failed: %m");
2462 #endif
2463
2464         one = 1;
2465         r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
2466         if (r < 0) {
2467                 log_error("SO_TIMESTAMP failed: %m");
2468                 return -errno;
2469         }
2470
2471         zero(ev);
2472         ev.events = EPOLLIN;
2473         ev.data.fd = s->syslog_fd;
2474         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->syslog_fd, &ev) < 0) {
2475                 log_error("Failed to add syslog server fd to epoll object: %m");
2476                 return -errno;
2477         }
2478
2479         return 0;
2480 }
2481
2482 static int open_native_socket(Server*s) {
2483         union sockaddr_union sa;
2484         int one, r;
2485         struct epoll_event ev;
2486
2487         assert(s);
2488
2489         if (s->native_fd < 0) {
2490
2491                 s->native_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2492                 if (s->native_fd < 0) {
2493                         log_error("socket() failed: %m");
2494                         return -errno;
2495                 }
2496
2497                 zero(sa);
2498                 sa.un.sun_family = AF_UNIX;
2499                 strncpy(sa.un.sun_path, "/run/systemd/journal/socket", sizeof(sa.un.sun_path));
2500
2501                 unlink(sa.un.sun_path);
2502
2503                 r = bind(s->native_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2504                 if (r < 0) {
2505                         log_error("bind() failed: %m");
2506                         return -errno;
2507                 }
2508
2509                 chmod(sa.un.sun_path, 0666);
2510         } else
2511                 fd_nonblock(s->native_fd, 1);
2512
2513         one = 1;
2514         r = setsockopt(s->native_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
2515         if (r < 0) {
2516                 log_error("SO_PASSCRED failed: %m");
2517                 return -errno;
2518         }
2519
2520 #ifdef HAVE_SELINUX
2521         one = 1;
2522         r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
2523         if (r < 0)
2524                 log_warning("SO_PASSSEC failed: %m");
2525 #endif
2526
2527         one = 1;
2528         r = setsockopt(s->native_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
2529         if (r < 0) {
2530                 log_error("SO_TIMESTAMP failed: %m");
2531                 return -errno;
2532         }
2533
2534         zero(ev);
2535         ev.events = EPOLLIN;
2536         ev.data.fd = s->native_fd;
2537         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->native_fd, &ev) < 0) {
2538                 log_error("Failed to add native server fd to epoll object: %m");
2539                 return -errno;
2540         }
2541
2542         return 0;
2543 }
2544
2545 static int open_stdout_socket(Server *s) {
2546         union sockaddr_union sa;
2547         int r;
2548         struct epoll_event ev;
2549
2550         assert(s);
2551
2552         if (s->stdout_fd < 0) {
2553
2554                 s->stdout_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2555                 if (s->stdout_fd < 0) {
2556                         log_error("socket() failed: %m");
2557                         return -errno;
2558                 }
2559
2560                 zero(sa);
2561                 sa.un.sun_family = AF_UNIX;
2562                 strncpy(sa.un.sun_path, "/run/systemd/journal/stdout", sizeof(sa.un.sun_path));
2563
2564                 unlink(sa.un.sun_path);
2565
2566                 r = bind(s->stdout_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2567                 if (r < 0) {
2568                         log_error("bind() failed: %m");
2569                         return -errno;
2570                 }
2571
2572                 chmod(sa.un.sun_path, 0666);
2573
2574                 if (listen(s->stdout_fd, SOMAXCONN) < 0) {
2575                         log_error("liste() failed: %m");
2576                         return -errno;
2577                 }
2578         } else
2579                 fd_nonblock(s->stdout_fd, 1);
2580
2581         zero(ev);
2582         ev.events = EPOLLIN;
2583         ev.data.fd = s->stdout_fd;
2584         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->stdout_fd, &ev) < 0) {
2585                 log_error("Failed to add stdout server fd to epoll object: %m");
2586                 return -errno;
2587         }
2588
2589         return 0;
2590 }
2591
2592 static int open_proc_kmsg(Server *s) {
2593         struct epoll_event ev;
2594
2595         assert(s);
2596
2597         if (!s->import_proc_kmsg)
2598                 return 0;
2599
2600         s->proc_kmsg_fd = open("/proc/kmsg", O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
2601         if (s->proc_kmsg_fd < 0) {
2602                 log_warning("Failed to open /proc/kmsg, ignoring: %m");
2603                 return 0;
2604         }
2605
2606         zero(ev);
2607         ev.events = EPOLLIN;
2608         ev.data.fd = s->proc_kmsg_fd;
2609         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->proc_kmsg_fd, &ev) < 0) {
2610                 log_error("Failed to add /proc/kmsg fd to epoll object: %m");
2611                 return -errno;
2612         }
2613
2614         return 0;
2615 }
2616
2617 static int open_signalfd(Server *s) {
2618         sigset_t mask;
2619         struct epoll_event ev;
2620
2621         assert(s);
2622
2623         assert_se(sigemptyset(&mask) == 0);
2624         sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
2625         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
2626
2627         s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
2628         if (s->signal_fd < 0) {
2629                 log_error("signalfd(): %m");
2630                 return -errno;
2631         }
2632
2633         zero(ev);
2634         ev.events = EPOLLIN;
2635         ev.data.fd = s->signal_fd;
2636
2637         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
2638                 log_error("epoll_ctl(): %m");
2639                 return -errno;
2640         }
2641
2642         return 0;
2643 }
2644
2645 static int server_parse_proc_cmdline(Server *s) {
2646         char *line, *w, *state;
2647         int r;
2648         size_t l;
2649
2650         if (detect_container(NULL) > 0)
2651                 return 0;
2652
2653         r = read_one_line_file("/proc/cmdline", &line);
2654         if (r < 0) {
2655                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
2656                 return 0;
2657         }
2658
2659         FOREACH_WORD_QUOTED(w, l, line, state) {
2660                 char *word;
2661
2662                 word = strndup(w, l);
2663                 if (!word) {
2664                         r = -ENOMEM;
2665                         goto finish;
2666                 }
2667
2668                 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
2669                         r = parse_boolean(word + 35);
2670                         if (r < 0)
2671                                 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
2672                         else
2673                                 s->forward_to_syslog = r;
2674                 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
2675                         r = parse_boolean(word + 33);
2676                         if (r < 0)
2677                                 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
2678                         else
2679                                 s->forward_to_kmsg = r;
2680                 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
2681                         r = parse_boolean(word + 36);
2682                         if (r < 0)
2683                                 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
2684                         else
2685                                 s->forward_to_console = r;
2686                 } else if (startswith(word, "systemd.journald"))
2687                         log_warning("Invalid systemd.journald parameter. Ignoring.");
2688
2689                 free(word);
2690         }
2691
2692         r = 0;
2693
2694 finish:
2695         free(line);
2696         return r;
2697 }
2698
2699 static int server_parse_config_file(Server *s) {
2700         FILE *f;
2701         const char *fn;
2702         int r;
2703
2704         assert(s);
2705
2706         fn = "/etc/systemd/journald.conf";
2707         f = fopen(fn, "re");
2708         if (!f) {
2709                 if (errno == ENOENT)
2710                         return 0;
2711
2712                 log_warning("Failed to open configuration file %s: %m", fn);
2713                 return -errno;
2714         }
2715
2716         r = config_parse(fn, f, "Journal\0", config_item_perf_lookup, (void*) journald_gperf_lookup, false, s);
2717         if (r < 0)
2718                 log_warning("Failed to parse configuration file: %s", strerror(-r));
2719
2720         fclose(f);
2721
2722         return r;
2723 }
2724
2725 static int server_init(Server *s) {
2726         int n, r, fd;
2727
2728         assert(s);
2729
2730         zero(*s);
2731         s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->proc_kmsg_fd = -1;
2732         s->compress = true;
2733
2734         s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
2735         s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
2736
2737         s->forward_to_syslog = true;
2738
2739         s->max_level_store = LOG_DEBUG;
2740         s->max_level_syslog = LOG_DEBUG;
2741         s->max_level_kmsg = LOG_NOTICE;
2742         s->max_level_console = LOG_INFO;
2743
2744         memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
2745         memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
2746
2747         server_parse_config_file(s);
2748         server_parse_proc_cmdline(s);
2749
2750         s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
2751         if (!s->user_journals)
2752                 return log_oom();
2753
2754         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2755         if (s->epoll_fd < 0) {
2756                 log_error("Failed to create epoll object: %m");
2757                 return -errno;
2758         }
2759
2760         n = sd_listen_fds(true);
2761         if (n < 0) {
2762                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
2763                 return n;
2764         }
2765
2766         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
2767
2768                 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
2769
2770                         if (s->native_fd >= 0) {
2771                                 log_error("Too many native sockets passed.");
2772                                 return -EINVAL;
2773                         }
2774
2775                         s->native_fd = fd;
2776
2777                 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
2778
2779                         if (s->stdout_fd >= 0) {
2780                                 log_error("Too many stdout sockets passed.");
2781                                 return -EINVAL;
2782                         }
2783
2784                         s->stdout_fd = fd;
2785
2786                 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
2787
2788                         if (s->syslog_fd >= 0) {
2789                                 log_error("Too many /dev/log sockets passed.");
2790                                 return -EINVAL;
2791                         }
2792
2793                         s->syslog_fd = fd;
2794
2795                 } else {
2796                         log_error("Unknown socket passed.");
2797                         return -EINVAL;
2798                 }
2799         }
2800
2801         r = open_syslog_socket(s);
2802         if (r < 0)
2803                 return r;
2804
2805         r = open_native_socket(s);
2806         if (r < 0)
2807                 return r;
2808
2809         r = open_stdout_socket(s);
2810         if (r < 0)
2811                 return r;
2812
2813         r = open_proc_kmsg(s);
2814         if (r < 0)
2815                 return r;
2816
2817         r = open_signalfd(s);
2818         if (r < 0)
2819                 return r;
2820
2821         s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
2822         if (!s->rate_limit)
2823                 return -ENOMEM;
2824
2825         r = system_journal_open(s);
2826         if (r < 0)
2827                 return r;
2828
2829         return 0;
2830 }
2831
2832 static void server_done(Server *s) {
2833         JournalFile *f;
2834         assert(s);
2835
2836         while (s->stdout_streams)
2837                 stdout_stream_free(s->stdout_streams);
2838
2839         if (s->system_journal)
2840                 journal_file_close(s->system_journal);
2841
2842         if (s->runtime_journal)
2843                 journal_file_close(s->runtime_journal);
2844
2845         while ((f = hashmap_steal_first(s->user_journals)))
2846                 journal_file_close(f);
2847
2848         hashmap_free(s->user_journals);
2849
2850         if (s->epoll_fd >= 0)
2851                 close_nointr_nofail(s->epoll_fd);
2852
2853         if (s->signal_fd >= 0)
2854                 close_nointr_nofail(s->signal_fd);
2855
2856         if (s->syslog_fd >= 0)
2857                 close_nointr_nofail(s->syslog_fd);
2858
2859         if (s->native_fd >= 0)
2860                 close_nointr_nofail(s->native_fd);
2861
2862         if (s->stdout_fd >= 0)
2863                 close_nointr_nofail(s->stdout_fd);
2864
2865         if (s->proc_kmsg_fd >= 0)
2866                 close_nointr_nofail(s->proc_kmsg_fd);
2867
2868         if (s->rate_limit)
2869                 journal_rate_limit_free(s->rate_limit);
2870
2871         free(s->buffer);
2872         free(s->tty_path);
2873 }
2874
2875 int main(int argc, char *argv[]) {
2876         Server server;
2877         int r;
2878
2879         /* if (getppid() != 1) { */
2880         /*         log_error("This program should be invoked by init only."); */
2881         /*         return EXIT_FAILURE; */
2882         /* } */
2883
2884         if (argc > 1) {
2885                 log_error("This program does not take arguments.");
2886                 return EXIT_FAILURE;
2887         }
2888
2889         log_set_target(LOG_TARGET_SAFE);
2890         log_set_facility(LOG_SYSLOG);
2891         log_parse_environment();
2892         log_open();
2893
2894         umask(0022);
2895
2896         r = server_init(&server);
2897         if (r < 0)
2898                 goto finish;
2899
2900         server_vacuum(&server);
2901         server_flush_to_var(&server);
2902         server_flush_proc_kmsg(&server);
2903
2904         log_debug("systemd-journald running as pid %lu", (unsigned long) getpid());
2905         driver_message(&server, SD_MESSAGE_JOURNAL_START, "Journal started");
2906
2907         sd_notify(false,
2908                   "READY=1\n"
2909                   "STATUS=Processing requests...");
2910
2911         for (;;) {
2912                 struct epoll_event event;
2913
2914                 r = epoll_wait(server.epoll_fd, &event, 1, -1);
2915                 if (r < 0) {
2916
2917                         if (errno == EINTR)
2918                                 continue;
2919
2920                         log_error("epoll_wait() failed: %m");
2921                         r = -errno;
2922                         goto finish;
2923                 } else if (r == 0)
2924                         break;
2925
2926                 r = process_event(&server, &event);
2927                 if (r < 0)
2928                         goto finish;
2929                 else if (r == 0)
2930                         break;
2931         }
2932
2933         log_debug("systemd-journald stopped as pid %lu", (unsigned long) getpid());
2934         driver_message(&server, SD_MESSAGE_JOURNAL_STOP, "Journal stopped");
2935
2936 finish:
2937         sd_notify(false,
2938                   "STATUS=Shutting down...");
2939
2940         server_done(&server);
2941
2942         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
2943 }