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