src/journal/journalctl.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 <locale.h>
  23 #include <fcntl.h>
  24 #include <fnmatch.h>
  25 #include <errno.h>
  26 #include <stddef.h>
  27 #include <string.h>
  28 #include <stdio.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <time.h>
  32 #include <getopt.h>
  33 #include <signal.h>
  34 #include <poll.h>
  35 #include <sys/stat.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/inotify.h>
  38 #include <linux/fs.h>
  39
  40 #ifdef HAVE_ACL
  41 #include <sys/acl.h>
  42 #include "acl-util.h"
  43 #endif
  44
  45 #include "sd-journal.h"
  46 #include "sd-bus.h"
  47
  48 #include "log.h"
  49 #include "logs-show.h"
  50 #include "util.h"
  51 #include "path-util.h"
  52 #include "fileio.h"
  53 #include "build.h"
  54 #include "pager.h"
  55 #include "strv.h"
  56 #include "set.h"
  57 #include "journal-internal.h"
  58 #include "journal-def.h"
  59 #include "journal-verify.h"
  60 #include "journal-authenticate.h"
  61 #include "journal-qrcode.h"
  62 #include "journal-vacuum.h"
  63 #include "fsprg.h"
  64 #include "unit-name.h"
  65 #include "catalog.h"
  66 #include "mkdir.h"
  67 #include "bus-util.h"
  68 #include "bus-error.h"
  69
  70 #define DEFAULT_FSS_INTERVAL_USEC (15*USEC_PER_MINUTE)
  71
  72 enum {
  73         /* Special values for arg_lines */
  74         ARG_LINES_DEFAULT = -2,
  75         ARG_LINES_ALL = -1,
  76 };
  77
  78 static OutputMode arg_output = OUTPUT_SHORT;
  79 static bool arg_utc = false;
  80 static bool arg_pager_end = false;
  81 static bool arg_follow = false;
  82 static bool arg_full = true;
  83 static bool arg_all = false;
  84 static bool arg_no_pager = false;
  85 static int arg_lines = ARG_LINES_DEFAULT;
  86 static bool arg_no_tail = false;
  87 static bool arg_quiet = false;
  88 static bool arg_merge = false;
  89 static bool arg_boot = false;
  90 static sd_id128_t arg_boot_id = {};
  91 static int arg_boot_offset = 0;
  92 static bool arg_dmesg = false;
  93 static const char *arg_cursor = NULL;
  94 static const char *arg_after_cursor = NULL;
  95 static bool arg_show_cursor = false;
  96 static const char *arg_directory = NULL;
  97 static char **arg_file = NULL;
  98 static int arg_priorities = 0xFF;
  99 static const char *arg_verify_key = NULL;
 100 #ifdef HAVE_GCRYPT
 101 static usec_t arg_interval = DEFAULT_FSS_INTERVAL_USEC;
 102 static bool arg_force = false;
 103 #endif
 104 static usec_t arg_since, arg_until;
 105 static bool arg_since_set = false, arg_until_set = false;
 106 static char **arg_syslog_identifier = NULL;
 107 static char **arg_system_units = NULL;
 108 static char **arg_user_units = NULL;
 109 static const char *arg_field = NULL;
 110 static bool arg_catalog = false;
 111 static bool arg_reverse = false;
 112 static int arg_journal_type = 0;
 113 static const char *arg_root = NULL;
 114 static const char *arg_machine = NULL;
 115 static off_t arg_vacuum_size = (off_t) -1;
 116 static usec_t arg_vacuum_time = USEC_INFINITY;
 117
 118 static enum {
 119         ACTION_SHOW,
 120         ACTION_NEW_ID128,
 121         ACTION_PRINT_HEADER,
 122         ACTION_SETUP_KEYS,
 123         ACTION_VERIFY,
 124         ACTION_DISK_USAGE,
 125         ACTION_LIST_CATALOG,
 126         ACTION_DUMP_CATALOG,
 127         ACTION_UPDATE_CATALOG,
 128         ACTION_LIST_BOOTS,
 129         ACTION_FLUSH,
 130         ACTION_VACUUM,
 131 } arg_action = ACTION_SHOW;
 132
 133 typedef struct boot_id_t {
 134         sd_id128_t id;
 135         uint64_t first;
 136         uint64_t last;
 137 } boot_id_t;
 138
 139 static void pager_open_if_enabled(void) {
 140
 141         if (arg_no_pager)
 142                 return;
 143
 144         pager_open(arg_pager_end);
 145 }
 146
 147 static char *format_timestamp_maybe_utc(char *buf, size_t l, usec_t t) {
 148
 149         if (arg_utc)
 150                 return format_timestamp_utc(buf, l, t);
 151
 152         return format_timestamp(buf, l, t);
 153 }
 154
 155 static int parse_boot_descriptor(const char *x, sd_id128_t *boot_id, int *offset) {
 156         sd_id128_t id = SD_ID128_NULL;
 157         int off = 0, r;
 158
 159         if (strlen(x) >= 32) {
 160                 char *t;
 161
 162                 t = strndupa(x, 32);
 163                 r = sd_id128_from_string(t, &id);
 164                 if (r >= 0)
 165                         x += 32;
 166
 167                 if (*x != '-' && *x != '+' && *x != 0)
 168                         return -EINVAL;
 169
 170                 if (*x != 0) {
 171                         r = safe_atoi(x, &off);
 172                         if (r < 0)
 173                                 return r;
 174                 }
 175         } else {
 176                 r = safe_atoi(x, &off);
 177                 if (r < 0)
 178                         return r;
 179         }
 180
 181         if (boot_id)
 182                 *boot_id = id;
 183
 184         if (offset)
 185                 *offset = off;
 186
 187         return 0;
 188 }
 189
 190 static void help(void) {
 191
 192         pager_open_if_enabled();
 193
 194         printf("%s [OPTIONS...] [MATCHES...]\n\n"
 195                "Query the journal.\n\n"
 196                "Flags:\n"
 197                "     --system              Show the system journal\n"
 198                "     --user                Show the user journal for the current user\n"
 199                "  -M --machine=CONTAINER   Operate on local container\n"
 200                "     --since=DATE          Start showing entries on or newer than the specified date\n"
 201                "     --until=DATE          Stop showing entries on or newer than the specified date\n"
 202                "  -c --cursor=CURSOR       Start showing entries from the specified cursor\n"
 203                "     --after-cursor=CURSOR Start showing entries from after the specified cursor\n"
 204                "     --show-cursor         Print the cursor after all the entries\n"
 205                "  -b --boot[=ID]           Show data only from ID or, if unspecified, the current boot\n"
 206                "     --list-boots          Show terse information about recorded boots\n"
 207                "  -k --dmesg               Show kernel message log from the current boot\n"
 208                "  -u --unit=UNIT           Show data only from the specified unit\n"
 209                "     --user-unit=UNIT      Show data only from the specified user session unit\n"
 210                "  -t --identifier=STRING   Show only messages with the specified syslog identifier\n"
 211                "  -p --priority=RANGE      Show only messages within the specified priority range\n"
 212                "  -e --pager-end           Immediately jump to end of the journal in the pager\n"
 213                "  -f --follow              Follow the journal\n"
 214                "  -n --lines[=INTEGER]     Number of journal entries to show\n"
 215                "     --no-tail             Show all lines, even in follow mode\n"
 216                "  -r --reverse             Show the newest entries first\n"
 217                "  -o --output=STRING       Change journal output mode (short, short-iso,\n"
 218                "                                   short-precise, short-monotonic, verbose,\n"
 219                "                                   export, json, json-pretty, json-sse, cat)\n"
 220                "     --utc                 Express time in Coordinated Universal Time (UTC)\n"
 221                "  -x --catalog             Add message explanations where available\n"
 222                "     --no-full             Ellipsize fields\n"
 223                "  -a --all                 Show all fields, including long and unprintable\n"
 224                "  -q --quiet               Do not show privilege warning\n"
 225                "     --no-pager            Do not pipe output into a pager\n"
 226                "  -m --merge               Show entries from all available journals\n"
 227                "  -D --directory=PATH      Show journal files from directory\n"
 228                "     --file=PATH           Show journal file\n"
 229                "     --root=ROOT           Operate on catalog files underneath the root ROOT\n"
 230 #ifdef HAVE_GCRYPT
 231                "     --interval=TIME       Time interval for changing the FSS sealing key\n"
 232                "     --verify-key=KEY      Specify FSS verification key\n"
 233                "     --force               Force overriding of the FSS key pair with --setup-keys\n"
 234 #endif
 235                "\nCommands:\n"
 236                "  -h --help                Show this help text\n"
 237                "     --version             Show package version\n"
 238                "  -F --field=FIELD         List all values that a specified field takes\n"
 239                "     --new-id128           Generate a new 128-bit ID\n"
 240                "     --disk-usage          Show total disk usage of all journal files\n"
 241                "     --vacuum-size=BYTES   Remove old journals until disk space drops below size\n"
 242                "     --vacuum-time=TIME    Remove old journals until none left older than\n"
 243                "     --flush               Flush all journal data from /run into /var\n"
 244                "     --header              Show journal header information\n"
 245                "     --list-catalog        Show message IDs of all entries in the message catalog\n"
 246                "     --dump-catalog        Show entries in the message catalog\n"
 247                "     --update-catalog      Update the message catalog database\n"
 248 #ifdef HAVE_GCRYPT
 249                "     --setup-keys          Generate a new FSS key pair\n"
 250                "     --verify              Verify journal file consistency\n"
 251 #endif
 252                , program_invocation_short_name);
 253 }
 254
 255 static int parse_argv(int argc, char *argv[]) {
 256
 257         enum {
 258                 ARG_VERSION = 0x100,
 259                 ARG_NO_PAGER,
 260                 ARG_NO_FULL,
 261                 ARG_NO_TAIL,
 262                 ARG_NEW_ID128,
 263                 ARG_LIST_BOOTS,
 264                 ARG_USER,
 265                 ARG_SYSTEM,
 266                 ARG_ROOT,
 267                 ARG_HEADER,
 268                 ARG_SETUP_KEYS,
 269                 ARG_FILE,
 270                 ARG_INTERVAL,
 271                 ARG_VERIFY,
 272                 ARG_VERIFY_KEY,
 273                 ARG_DISK_USAGE,
 274                 ARG_SINCE,
 275                 ARG_UNTIL,
 276                 ARG_AFTER_CURSOR,
 277                 ARG_SHOW_CURSOR,
 278                 ARG_USER_UNIT,
 279                 ARG_LIST_CATALOG,
 280                 ARG_DUMP_CATALOG,
 281                 ARG_UPDATE_CATALOG,
 282                 ARG_FORCE,
 283                 ARG_UTC,
 284                 ARG_FLUSH,
 285                 ARG_VACUUM_SIZE,
 286                 ARG_VACUUM_TIME,
 287         };
 288
 289         static const struct option options[] = {
 290                 { "help",           no_argument,       NULL, 'h'                },
 291                 { "version" ,       no_argument,       NULL, ARG_VERSION        },
 292                 { "no-pager",       no_argument,       NULL, ARG_NO_PAGER       },
 293                 { "pager-end",      no_argument,       NULL, 'e'                },
 294                 { "follow",         no_argument,       NULL, 'f'                },
 295                 { "force",          no_argument,       NULL, ARG_FORCE          },
 296                 { "output",         required_argument, NULL, 'o'                },
 297                 { "all",            no_argument,       NULL, 'a'                },
 298                 { "full",           no_argument,       NULL, 'l'                },
 299                 { "no-full",        no_argument,       NULL, ARG_NO_FULL        },
 300                 { "lines",          optional_argument, NULL, 'n'                },
 301                 { "no-tail",        no_argument,       NULL, ARG_NO_TAIL        },
 302                 { "new-id128",      no_argument,       NULL, ARG_NEW_ID128      },
 303                 { "quiet",          no_argument,       NULL, 'q'                },
 304                 { "merge",          no_argument,       NULL, 'm'                },
 305                 { "boot",           optional_argument, NULL, 'b'                },
 306                 { "list-boots",     no_argument,       NULL, ARG_LIST_BOOTS     },
 307                 { "this-boot",      optional_argument, NULL, 'b'                }, /* deprecated */
 308                 { "dmesg",          no_argument,       NULL, 'k'                },
 309                 { "system",         no_argument,       NULL, ARG_SYSTEM         },
 310                 { "user",           no_argument,       NULL, ARG_USER           },
 311                 { "directory",      required_argument, NULL, 'D'                },
 312                 { "file",           required_argument, NULL, ARG_FILE           },
 313                 { "root",           required_argument, NULL, ARG_ROOT           },
 314                 { "header",         no_argument,       NULL, ARG_HEADER         },
 315                 { "identifier",     required_argument, NULL, 't'                },
 316                 { "priority",       required_argument, NULL, 'p'                },
 317                 { "setup-keys",     no_argument,       NULL, ARG_SETUP_KEYS     },
 318                 { "interval",       required_argument, NULL, ARG_INTERVAL       },
 319                 { "verify",         no_argument,       NULL, ARG_VERIFY         },
 320                 { "verify-key",     required_argument, NULL, ARG_VERIFY_KEY     },
 321                 { "disk-usage",     no_argument,       NULL, ARG_DISK_USAGE     },
 322                 { "cursor",         required_argument, NULL, 'c'                },
 323                 { "after-cursor",   required_argument, NULL, ARG_AFTER_CURSOR   },
 324                 { "show-cursor",    no_argument,       NULL, ARG_SHOW_CURSOR    },
 325                 { "since",          required_argument, NULL, ARG_SINCE          },
 326                 { "until",          required_argument, NULL, ARG_UNTIL          },
 327                 { "unit",           required_argument, NULL, 'u'                },
 328                 { "user-unit",      required_argument, NULL, ARG_USER_UNIT      },
 329                 { "field",          required_argument, NULL, 'F'                },
 330                 { "catalog",        no_argument,       NULL, 'x'                },
 331                 { "list-catalog",   no_argument,       NULL, ARG_LIST_CATALOG   },
 332                 { "dump-catalog",   no_argument,       NULL, ARG_DUMP_CATALOG   },
 333                 { "update-catalog", no_argument,       NULL, ARG_UPDATE_CATALOG },
 334                 { "reverse",        no_argument,       NULL, 'r'                },
 335                 { "machine",        required_argument, NULL, 'M'                },
 336                 { "utc",            no_argument,       NULL, ARG_UTC            },
 337                 { "flush",          no_argument,       NULL, ARG_FLUSH          },
 338                 { "vacuum-size",    required_argument, NULL, ARG_VACUUM_SIZE    },
 339                 { "vacuum-time",    required_argument, NULL, ARG_VACUUM_TIME    },
 340                 {}
 341         };
 342
 343         int c, r;
 344
 345         assert(argc >= 0);
 346         assert(argv);
 347
 348         while ((c = getopt_long(argc, argv, "hefo:aln::qmb::kD:p:c:t:u:F:xrM:", options, NULL)) >= 0)
 349
 350                 switch (c) {
 351
 352                 case 'h':
 353                         help();
 354                         return 0;
 355
 356                 case ARG_VERSION:
 357                         puts(PACKAGE_STRING);
 358                         puts(SYSTEMD_FEATURES);
 359                         return 0;
 360
 361                 case ARG_NO_PAGER:
 362                         arg_no_pager = true;
 363                         break;
 364
 365                 case 'e':
 366                         arg_pager_end = true;
 367
 368                         if (arg_lines == ARG_LINES_DEFAULT)
 369                                 arg_lines = 1000;
 370
 371                         break;
 372
 373                 case 'f':
 374                         arg_follow = true;
 375                         break;
 376
 377                 case 'o':
 378                         arg_output = output_mode_from_string(optarg);
 379                         if (arg_output < 0) {
 380                                 log_error("Unknown output format '%s'.", optarg);
 381                                 return -EINVAL;
 382                         }
 383
 384                         if (arg_output == OUTPUT_EXPORT ||
 385                             arg_output == OUTPUT_JSON ||
 386                             arg_output == OUTPUT_JSON_PRETTY ||
 387                             arg_output == OUTPUT_JSON_SSE ||
 388                             arg_output == OUTPUT_CAT)
 389                                 arg_quiet = true;
 390
 391                         break;
 392
 393                 case 'l':
 394                         arg_full = true;
 395                         break;
 396
 397                 case ARG_NO_FULL:
 398                         arg_full = false;
 399                         break;
 400
 401                 case 'a':
 402                         arg_all = true;
 403                         break;
 404
 405                 case 'n':
 406                         if (optarg) {
 407                                 if (streq(optarg, "all"))
 408                                         arg_lines = ARG_LINES_ALL;
 409                                 else {
 410                                         r = safe_atoi(optarg, &arg_lines);
 411                                         if (r < 0 || arg_lines < 0) {
 412                                                 log_error("Failed to parse lines '%s'", optarg);
 413                                                 return -EINVAL;
 414                                         }
 415                                 }
 416                         } else {
 417                                 arg_lines = 10;
 418
 419                                 /* Hmm, no argument? Maybe the next
 420                                  * word on the command line is
 421                                  * supposed to be the argument? Let's
 422                                  * see if there is one, and is
 423                                  * parsable. */
 424                                 if (optind < argc) {
 425                                         int n;
 426                                         if (streq(argv[optind], "all")) {
 427                                                 arg_lines = ARG_LINES_ALL;
 428                                                 optind++;
 429                                         } else if (safe_atoi(argv[optind], &n) >= 0 && n >= 0) {
 430                                                 arg_lines = n;
 431                                                 optind++;
 432                                         }
 433                                 }
 434                         }
 435
 436                         break;
 437
 438                 case ARG_NO_TAIL:
 439                         arg_no_tail = true;
 440                         break;
 441
 442                 case ARG_NEW_ID128:
 443                         arg_action = ACTION_NEW_ID128;
 444                         break;
 445
 446                 case 'q':
 447                         arg_quiet = true;
 448                         break;
 449
 450                 case 'm':
 451                         arg_merge = true;
 452                         break;
 453
 454                 case 'b':
 455                         arg_boot = true;
 456
 457                         if (optarg) {
 458                                 r =  parse_boot_descriptor(optarg, &arg_boot_id, &arg_boot_offset);
 459                                 if (r < 0) {
 460                                         log_error("Failed to parse boot descriptor '%s'", optarg);
 461                                         return -EINVAL;
 462                                 }
 463                         } else {
 464
 465                                 /* Hmm, no argument? Maybe the next
 466                                  * word on the command line is
 467                                  * supposed to be the argument? Let's
 468                                  * see if there is one and is parsable
 469                                  * as a boot descriptor... */
 470
 471                                 if (optind < argc &&
 472                                     parse_boot_descriptor(argv[optind], &arg_boot_id, &arg_boot_offset) >= 0)
 473                                         optind++;
 474                         }
 475
 476                         break;
 477
 478                 case ARG_LIST_BOOTS:
 479                         arg_action = ACTION_LIST_BOOTS;
 480                         break;
 481
 482                 case 'k':
 483                         arg_boot = arg_dmesg = true;
 484                         break;
 485
 486                 case ARG_SYSTEM:
 487                         arg_journal_type |= SD_JOURNAL_SYSTEM;
 488                         break;
 489
 490                 case ARG_USER:
 491                         arg_journal_type |= SD_JOURNAL_CURRENT_USER;
 492                         break;
 493
 494                 case 'M':
 495                         arg_machine = optarg;
 496                         break;
 497
 498                 case 'D':
 499                         arg_directory = optarg;
 500                         break;
 501
 502                 case ARG_FILE:
 503                         r = glob_extend(&arg_file, optarg);
 504                         if (r < 0) {
 505                                 log_error_errno(r, "Failed to add paths: %m");
 506                                 return r;
 507                         };
 508                         break;
 509
 510                 case ARG_ROOT:
 511                         arg_root = optarg;
 512                         break;
 513
 514                 case 'c':
 515                         arg_cursor = optarg;
 516                         break;
 517
 518                 case ARG_AFTER_CURSOR:
 519                         arg_after_cursor = optarg;
 520                         break;
 521
 522                 case ARG_SHOW_CURSOR:
 523                         arg_show_cursor = true;
 524                         break;
 525
 526                 case ARG_HEADER:
 527                         arg_action = ACTION_PRINT_HEADER;
 528                         break;
 529
 530                 case ARG_VERIFY:
 531                         arg_action = ACTION_VERIFY;
 532                         break;
 533
 534                 case ARG_DISK_USAGE:
 535                         arg_action = ACTION_DISK_USAGE;
 536                         break;
 537
 538                 case ARG_VACUUM_SIZE:
 539                         r = parse_size(optarg, 1024, &arg_vacuum_size);
 540                         if (r < 0) {
 541                                 log_error("Failed to parse vacuum size: %s", optarg);
 542                                 return r;
 543                         }
 544
 545                         arg_action = ACTION_VACUUM;
 546                         break;
 547
 548                 case ARG_VACUUM_TIME:
 549                         r = parse_sec(optarg, &arg_vacuum_time);
 550                         if (r < 0) {
 551                                 log_error("Failed to parse vacuum time: %s", optarg);
 552                                 return r;
 553                         }
 554
 555                         arg_action = ACTION_VACUUM;
 556                         break;
 557
 558 #ifdef HAVE_GCRYPT
 559                 case ARG_FORCE:
 560                         arg_force = true;
 561                         break;
 562
 563                 case ARG_SETUP_KEYS:
 564                         arg_action = ACTION_SETUP_KEYS;
 565                         break;
 566
 567
 568                 case ARG_VERIFY_KEY:
 569                         arg_action = ACTION_VERIFY;
 570                         arg_verify_key = optarg;
 571                         arg_merge = false;
 572                         break;
 573
 574                 case ARG_INTERVAL:
 575                         r = parse_sec(optarg, &arg_interval);
 576                         if (r < 0 || arg_interval <= 0) {
 577                                 log_error("Failed to parse sealing key change interval: %s", optarg);
 578                                 return -EINVAL;
 579                         }
 580                         break;
 581 #else
 582                 case ARG_SETUP_KEYS:
 583                 case ARG_VERIFY_KEY:
 584                 case ARG_INTERVAL:
 585                 case ARG_FORCE:
 586                         log_error("Forward-secure sealing not available.");
 587                         return -ENOTSUP;
 588 #endif
 589
 590                 case 'p': {
 591                         const char *dots;
 592
 593                         dots = strstr(optarg, "..");
 594                         if (dots) {
 595                                 char *a;
 596                                 int from, to, i;
 597
 598                                 /* a range */
 599                                 a = strndup(optarg, dots - optarg);
 600                                 if (!a)
 601                                         return log_oom();
 602
 603                                 from = log_level_from_string(a);
 604                                 to = log_level_from_string(dots + 2);
 605                                 free(a);
 606
 607                                 if (from < 0 || to < 0) {
 608                                         log_error("Failed to parse log level range %s", optarg);
 609                                         return -EINVAL;
 610                                 }
 611
 612                                 arg_priorities = 0;
 613
 614                                 if (from < to) {
 615                                         for (i = from; i <= to; i++)
 616                                                 arg_priorities |= 1 << i;
 617                                 } else {
 618                                         for (i = to; i <= from; i++)
 619                                                 arg_priorities |= 1 << i;
 620                                 }
 621
 622                         } else {
 623                                 int p, i;
 624
 625                                 p = log_level_from_string(optarg);
 626                                 if (p < 0) {
 627                                         log_error("Unknown log level %s", optarg);
 628                                         return -EINVAL;
 629                                 }
 630
 631                                 arg_priorities = 0;
 632
 633                                 for (i = 0; i <= p; i++)
 634                                         arg_priorities |= 1 << i;
 635                         }
 636
 637                         break;
 638                 }
 639
 640                 case ARG_SINCE:
 641                         r = parse_timestamp(optarg, &arg_since);
 642                         if (r < 0) {
 643                                 log_error("Failed to parse timestamp: %s", optarg);
 644                                 return -EINVAL;
 645                         }
 646                         arg_since_set = true;
 647                         break;
 648
 649                 case ARG_UNTIL:
 650                         r = parse_timestamp(optarg, &arg_until);
 651                         if (r < 0) {
 652                                 log_error("Failed to parse timestamp: %s", optarg);
 653                                 return -EINVAL;
 654                         }
 655                         arg_until_set = true;
 656                         break;
 657
 658                 case 't':
 659                         r = strv_extend(&arg_syslog_identifier, optarg);
 660                         if (r < 0)
 661                                 return log_oom();
 662                         break;
 663
 664                 case 'u':
 665                         r = strv_extend(&arg_system_units, optarg);
 666                         if (r < 0)
 667                                 return log_oom();
 668                         break;
 669
 670                 case ARG_USER_UNIT:
 671                         r = strv_extend(&arg_user_units, optarg);
 672                         if (r < 0)
 673                                 return log_oom();
 674                         break;
 675
 676                 case 'F':
 677                         arg_field = optarg;
 678                         break;
 679
 680                 case 'x':
 681                         arg_catalog = true;
 682                         break;
 683
 684                 case ARG_LIST_CATALOG:
 685                         arg_action = ACTION_LIST_CATALOG;
 686                         break;
 687
 688                 case ARG_DUMP_CATALOG:
 689                         arg_action = ACTION_DUMP_CATALOG;
 690                         break;
 691
 692                 case ARG_UPDATE_CATALOG:
 693                         arg_action = ACTION_UPDATE_CATALOG;
 694                         break;
 695
 696                 case 'r':
 697                         arg_reverse = true;
 698                         break;
 699
 700                 case ARG_UTC:
 701                         arg_utc = true;
 702                         break;
 703
 704                 case ARG_FLUSH:
 705                         arg_action = ACTION_FLUSH;
 706                         break;
 707
 708                 case '?':
 709                         return -EINVAL;
 710
 711                 default:
 712                         assert_not_reached("Unhandled option");
 713                 }
 714
 715         if (arg_follow && !arg_no_tail && !arg_since && arg_lines == ARG_LINES_DEFAULT)
 716                 arg_lines = 10;
 717
 718         if (!!arg_directory + !!arg_file + !!arg_machine > 1) {
 719                 log_error("Please specify either -D/--directory= or --file= or -M/--machine=, not more than one.");
 720                 return -EINVAL;
 721         }
 722
 723         if (arg_since_set && arg_until_set && arg_since > arg_until) {
 724                 log_error("--since= must be before --until=.");
 725                 return -EINVAL;
 726         }
 727
 728         if (!!arg_cursor + !!arg_after_cursor + !!arg_since_set > 1) {
 729                 log_error("Please specify only one of --since=, --cursor=, and --after-cursor.");
 730                 return -EINVAL;
 731         }
 732
 733         if (arg_follow && arg_reverse) {
 734                 log_error("Please specify either --reverse= or --follow=, not both.");
 735                 return -EINVAL;
 736         }
 737
 738         if (arg_action != ACTION_SHOW && optind < argc) {
 739                 log_error("Extraneous arguments starting with '%s'", argv[optind]);
 740                 return -EINVAL;
 741         }
 742
 743         return 1;
 744 }
 745
 746 static int generate_new_id128(void) {
 747         sd_id128_t id;
 748         int r;
 749         unsigned i;
 750
 751         r = sd_id128_randomize(&id);
 752         if (r < 0) {
 753                 log_error_errno(r, "Failed to generate ID: %m");
 754                 return r;
 755         }
 756
 757         printf("As string:\n"
 758                SD_ID128_FORMAT_STR "\n\n"
 759                "As UUID:\n"
 760                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n\n"
 761                "As macro:\n"
 762                "#define MESSAGE_XYZ SD_ID128_MAKE(",
 763                SD_ID128_FORMAT_VAL(id),
 764                SD_ID128_FORMAT_VAL(id));
 765         for (i = 0; i < 16; i++)
 766                 printf("%02x%s", id.bytes[i], i != 15 ? "," : "");
 767         fputs(")\n\n", stdout);
 768
 769         printf("As Python constant:\n"
 770                ">>> import uuid\n"
 771                ">>> MESSAGE_XYZ = uuid.UUID('" SD_ID128_FORMAT_STR "')\n",
 772                SD_ID128_FORMAT_VAL(id));
 773
 774         return 0;
 775 }
 776
 777 static int add_matches(sd_journal *j, char **args) {
 778         char **i;
 779         bool have_term = false;
 780
 781         assert(j);
 782
 783         STRV_FOREACH(i, args) {
 784                 int r;
 785
 786                 if (streq(*i, "+")) {
 787                         if (!have_term)
 788                                 break;
 789                         r = sd_journal_add_disjunction(j);
 790                         have_term = false;
 791
 792                 } else if (path_is_absolute(*i)) {
 793                         _cleanup_free_ char *p, *t = NULL, *t2 = NULL;
 794                         const char *path;
 795                         _cleanup_free_ char *interpreter = NULL;
 796                         struct stat st;
 797
 798                         p = canonicalize_file_name(*i);
 799                         path = p ? p : *i;
 800
 801                         if (stat(path, &st) < 0)  {
 802                                 log_error("Couldn't stat file: %m");
 803                                 return -errno;
 804                         }
 805
 806                         if (S_ISREG(st.st_mode) && (0111 & st.st_mode)) {
 807                                 if (executable_is_script(path, &interpreter) > 0) {
 808                                         _cleanup_free_ char *comm;
 809
 810                                         comm = strndup(basename(path), 15);
 811                                         if (!comm)
 812                                                 return log_oom();
 813
 814                                         t = strappend("_COMM=", comm);
 815
 816                                         /* Append _EXE only if the interpreter is not a link.
 817                                            Otherwise, it might be outdated often. */
 818                                         if (lstat(interpreter, &st) == 0 &&
 819                                             !S_ISLNK(st.st_mode)) {
 820                                                 t2 = strappend("_EXE=", interpreter);
 821                                                 if (!t2)
 822                                                         return log_oom();
 823                                         }
 824                                 } else
 825                                         t = strappend("_EXE=", path);
 826                         } else if (S_ISCHR(st.st_mode)) {
 827                                 if (asprintf(&t, "_KERNEL_DEVICE=c%u:%u",
 828                                              major(st.st_rdev),
 829                                              minor(st.st_rdev)) < 0)
 830                                         return -ENOMEM;
 831                         } else if (S_ISBLK(st.st_mode)) {
 832                                 if (asprintf(&t, "_KERNEL_DEVICE=b%u:%u",
 833                                              major(st.st_rdev),
 834                                              minor(st.st_rdev)) < 0)
 835                                         return -ENOMEM;
 836                         } else {
 837                                 log_error("File is neither a device node, nor regular file, nor executable: %s", *i);
 838                                 return -EINVAL;
 839                         }
 840
 841                         if (!t)
 842                                 return log_oom();
 843
 844                         r = sd_journal_add_match(j, t, 0);
 845                         if (t2)
 846                                 r = sd_journal_add_match(j, t2, 0);
 847                         have_term = true;
 848
 849                 } else {
 850                         r = sd_journal_add_match(j, *i, 0);
 851                         have_term = true;
 852                 }
 853
 854                 if (r < 0) {
 855                         log_error_errno(r, "Failed to add match '%s': %m", *i);
 856                         return r;
 857                 }
 858         }
 859
 860         if (!strv_isempty(args) && !have_term) {
 861                 log_error("\"+\" can only be used between terms");
 862                 return -EINVAL;
 863         }
 864
 865         return 0;
 866 }
 867
 868 static int boot_id_cmp(const void *a, const void *b) {
 869         uint64_t _a, _b;
 870
 871         _a = ((const boot_id_t *)a)->first;
 872         _b = ((const boot_id_t *)b)->first;
 873
 874         return _a < _b ? -1 : (_a > _b ? 1 : 0);
 875 }
 876
 877 static int get_boots(sd_journal *j,
 878                      boot_id_t **boots,
 879                      unsigned int *count,
 880                      boot_id_t *query_ref_boot) {
 881         int r;
 882         const void *data;
 883         size_t length, allocated = 0;
 884
 885         assert(j);
 886         assert(boots);
 887         assert(count);
 888
 889         r = sd_journal_query_unique(j, "_BOOT_ID");
 890         if (r < 0)
 891                 return r;
 892
 893         *count = 0;
 894         SD_JOURNAL_FOREACH_UNIQUE(j, data, length) {
 895                 boot_id_t *id;
 896
 897                 assert(startswith(data, "_BOOT_ID="));
 898
 899                 if (!GREEDY_REALLOC(*boots, allocated, *count + 1))
 900                         return log_oom();
 901
 902                 id = *boots + *count;
 903
 904                 r = sd_id128_from_string(((const char *)data) + strlen("_BOOT_ID="), &id->id);
 905                 if (r < 0)
 906                         continue;
 907
 908                 r = sd_journal_add_match(j, data, length);
 909                 if (r < 0)
 910                         return r;
 911
 912                 r = sd_journal_seek_head(j);
 913                 if (r < 0)
 914                         return r;
 915
 916                 r = sd_journal_next(j);
 917                 if (r < 0)
 918                         return r;
 919                 else if (r == 0)
 920                         goto flush;
 921
 922                 r = sd_journal_get_realtime_usec(j, &id->first);
 923                 if (r < 0)
 924                         return r;
 925
 926                 if (query_ref_boot) {
 927                         id->last = 0;
 928                         if (sd_id128_equal(id->id, query_ref_boot->id))
 929                                 *query_ref_boot = *id;
 930                 } else {
 931                         r = sd_journal_seek_tail(j);
 932                         if (r < 0)
 933                                 return r;
 934
 935                         r = sd_journal_previous(j);
 936                         if (r < 0)
 937                                 return r;
 938                         else if (r == 0)
 939                                 goto flush;
 940
 941                         r = sd_journal_get_realtime_usec(j, &id->last);
 942                         if (r < 0)
 943                                 return r;
 944                 }
 945
 946                 (*count)++;
 947         flush:
 948                 sd_journal_flush_matches(j);
 949         }
 950
 951         qsort_safe(*boots, *count, sizeof(boot_id_t), boot_id_cmp);
 952         return 0;
 953 }
 954
 955 static int list_boots(sd_journal *j) {
 956         int r, w, i;
 957         unsigned int count;
 958         boot_id_t *id;
 959         _cleanup_free_ boot_id_t *all_ids = NULL;
 960
 961         assert(j);
 962
 963         r = get_boots(j, &all_ids, &count, NULL);
 964         if (r < 0)
 965                 return r;
 966
 967         pager_open_if_enabled();
 968
 969         /* numbers are one less, but we need an extra char for the sign */
 970         w = DECIMAL_STR_WIDTH(count - 1) + 1;
 971
 972         for (id = all_ids, i = 0; id < all_ids + count; id++, i++) {
 973                 char a[FORMAT_TIMESTAMP_MAX], b[FORMAT_TIMESTAMP_MAX];
 974
 975                 printf("% *i " SD_ID128_FORMAT_STR " %s—%s\n",
 976                        w, i - count + 1,
 977                        SD_ID128_FORMAT_VAL(id->id),
 978                        format_timestamp_maybe_utc(a, sizeof(a), id->first),
 979                        format_timestamp_maybe_utc(b, sizeof(b), id->last));
 980         }
 981
 982         return 0;
 983 }
 984
 985 static int get_boot_id_by_offset(sd_journal *j, sd_id128_t *boot_id, int offset) {
 986         int r;
 987         unsigned int count;
 988         boot_id_t ref_boot_id = {}, *id;
 989         _cleanup_free_ boot_id_t *all_ids = NULL;
 990
 991         assert(j);
 992         assert(boot_id);
 993
 994         ref_boot_id.id = *boot_id;
 995         r = get_boots(j, &all_ids, &count, &ref_boot_id);
 996         if (r < 0)
 997                 return r;
 998
 999         if (sd_id128_equal(*boot_id, SD_ID128_NULL)) {
1000                 if (offset > (int) count || offset <= -(int)count)
1001                         return -EADDRNOTAVAIL;
1002
1003                 *boot_id = all_ids[(offset <= 0)*count + offset - 1].id;
1004         } else {
1005                 id = bsearch(&ref_boot_id, all_ids, count, sizeof(boot_id_t), boot_id_cmp);
1006
1007                 if (!id ||
1008                     offset <= 0 ? (id - all_ids) + offset < 0 :
1009                                     (id - all_ids) + offset >= (int) count)
1010                         return -EADDRNOTAVAIL;
1011
1012                 *boot_id = (id + offset)->id;
1013         }
1014
1015         return 0;
1016 }
1017
1018 static int add_boot(sd_journal *j) {
1019         char match[9+32+1] = "_BOOT_ID=";
1020         int r;
1021
1022         assert(j);
1023
1024         if (!arg_boot)
1025                 return 0;
1026
1027         if (arg_boot_offset == 0 && sd_id128_equal(arg_boot_id, SD_ID128_NULL))
1028                 return add_match_this_boot(j, arg_machine);
1029
1030         r = get_boot_id_by_offset(j, &arg_boot_id, arg_boot_offset);
1031         if (r < 0) {
1032                 if (sd_id128_equal(arg_boot_id, SD_ID128_NULL))
1033                         log_error_errno(r, "Failed to look up boot %+i: %m", arg_boot_offset);
1034                 else
1035                         log_error("Failed to look up boot ID "SD_ID128_FORMAT_STR"%+i: %s",
1036                                   SD_ID128_FORMAT_VAL(arg_boot_id), arg_boot_offset, strerror(-r));
1037                 return r;
1038         }
1039
1040         sd_id128_to_string(arg_boot_id, match + 9);
1041
1042         r = sd_journal_add_match(j, match, sizeof(match) - 1);
1043         if (r < 0) {
1044                 log_error_errno(r, "Failed to add match: %m");
1045                 return r;
1046         }
1047
1048         r = sd_journal_add_conjunction(j);
1049         if (r < 0)
1050                 return r;
1051
1052         return 0;
1053 }
1054
1055 static int add_dmesg(sd_journal *j) {
1056         int r;
1057         assert(j);
1058
1059         if (!arg_dmesg)
1060                 return 0;
1061
1062         r = sd_journal_add_match(j, "_TRANSPORT=kernel", strlen("_TRANSPORT=kernel"));
1063         if (r < 0) {
1064                 log_error_errno(r, "Failed to add match: %m");
1065                 return r;
1066         }
1067
1068         r = sd_journal_add_conjunction(j);
1069         if (r < 0)
1070                 return r;
1071
1072         return 0;
1073 }
1074
1075 static int get_possible_units(sd_journal *j,
1076                               const char *fields,
1077                               char **patterns,
1078                               Set **units) {
1079         _cleanup_set_free_free_ Set *found;
1080         const char *field;
1081         int r;
1082
1083         found = set_new(&string_hash_ops);
1084         if (!found)
1085                 return log_oom();
1086
1087         NULSTR_FOREACH(field, fields) {
1088                 const void *data;
1089                 size_t size;
1090
1091                 r = sd_journal_query_unique(j, field);
1092                 if (r < 0)
1093                         return r;
1094
1095                 SD_JOURNAL_FOREACH_UNIQUE(j, data, size) {
1096                         char **pattern, *eq;
1097                         size_t prefix;
1098                         _cleanup_free_ char *u = NULL;
1099
1100                         eq = memchr(data, '=', size);
1101                         if (eq)
1102                                 prefix = eq - (char*) data + 1;
1103                         else
1104                                 prefix = 0;
1105
1106                         u = strndup((char*) data + prefix, size - prefix);
1107                         if (!u)
1108                                 return log_oom();
1109
1110                         STRV_FOREACH(pattern, patterns)
1111                                 if (fnmatch(*pattern, u, FNM_NOESCAPE) == 0) {
1112                                         log_debug("Matched %s with pattern %s=%s", u, field, *pattern);
1113
1114                                         r = set_consume(found, u);
1115                                         u = NULL;
1116                                         if (r < 0 && r != -EEXIST)
1117                                                 return r;
1118
1119                                         break;
1120                                 }
1121                 }
1122         }
1123
1124         *units = found;
1125         found = NULL;
1126         return 0;
1127 }
1128
1129 /* This list is supposed to return the superset of unit names
1130  * possibly matched by rules added with add_matches_for_unit... */
1131 #define SYSTEM_UNITS                 \
1132         "_SYSTEMD_UNIT\0"            \
1133         "COREDUMP_UNIT\0"            \
1134         "UNIT\0"                     \
1135         "OBJECT_SYSTEMD_UNIT\0"      \
1136         "_SYSTEMD_SLICE\0"
1137
1138 /* ... and add_matches_for_user_unit */
1139 #define USER_UNITS                   \
1140         "_SYSTEMD_USER_UNIT\0"       \
1141         "USER_UNIT\0"                \
1142         "COREDUMP_USER_UNIT\0"       \
1143         "OBJECT_SYSTEMD_USER_UNIT\0"
1144
1145 static int add_units(sd_journal *j) {
1146         _cleanup_strv_free_ char **patterns = NULL;
1147         int r, count = 0;
1148         char **i;
1149
1150         assert(j);
1151
1152         STRV_FOREACH(i, arg_system_units) {
1153                 _cleanup_free_ char *u = NULL;
1154
1155                 u = unit_name_mangle(*i, MANGLE_GLOB);
1156                 if (!u)
1157                         return log_oom();
1158
1159                 if (string_is_glob(u)) {
1160                         r = strv_push(&patterns, u);
1161                         if (r < 0)
1162                                 return r;
1163                         u = NULL;
1164                 } else {
1165                         r = add_matches_for_unit(j, u);
1166                         if (r < 0)
1167                                 return r;
1168                         r = sd_journal_add_disjunction(j);
1169                         if (r < 0)
1170                                 return r;
1171                         count ++;
1172                 }
1173         }
1174
1175         if (!strv_isempty(patterns)) {
1176                 _cleanup_set_free_free_ Set *units = NULL;
1177                 Iterator it;
1178                 char *u;
1179
1180                 r = get_possible_units(j, SYSTEM_UNITS, patterns, &units);
1181                 if (r < 0)
1182                         return r;
1183
1184                 SET_FOREACH(u, units, it) {
1185                         r = add_matches_for_unit(j, u);
1186                         if (r < 0)
1187                                 return r;
1188                         r = sd_journal_add_disjunction(j);
1189                         if (r < 0)
1190                                 return r;
1191                         count ++;
1192                 }
1193         }
1194
1195         strv_free(patterns);
1196         patterns = NULL;
1197
1198         STRV_FOREACH(i, arg_user_units) {
1199                 _cleanup_free_ char *u = NULL;
1200
1201                 u = unit_name_mangle(*i, MANGLE_GLOB);
1202                 if (!u)
1203                         return log_oom();
1204
1205                 if (string_is_glob(u)) {
1206                         r = strv_push(&patterns, u);
1207                         if (r < 0)
1208                                 return r;
1209                         u = NULL;
1210                 } else {
1211                         r = add_matches_for_user_unit(j, u, getuid());
1212                         if (r < 0)
1213                                 return r;
1214                         r = sd_journal_add_disjunction(j);
1215                         if (r < 0)
1216                                 return r;
1217                         count ++;
1218                 }
1219         }
1220
1221         if (!strv_isempty(patterns)) {
1222                 _cleanup_set_free_free_ Set *units = NULL;
1223                 Iterator it;
1224                 char *u;
1225
1226                 r = get_possible_units(j, USER_UNITS, patterns, &units);
1227                 if (r < 0)
1228                         return r;
1229
1230                 SET_FOREACH(u, units, it) {
1231                         r = add_matches_for_user_unit(j, u, getuid());
1232                         if (r < 0)
1233                                 return r;
1234                         r = sd_journal_add_disjunction(j);
1235                         if (r < 0)
1236                                 return r;
1237                         count ++;
1238                 }
1239         }
1240
1241         /* Complain if the user request matches but nothing whatsoever was
1242          * found, since otherwise everything would be matched. */
1243         if (!(strv_isempty(arg_system_units) && strv_isempty(arg_user_units)) && count == 0)
1244                 return -ENODATA;
1245
1246         r = sd_journal_add_conjunction(j);
1247         if (r < 0)
1248                 return r;
1249
1250         return 0;
1251 }
1252
1253 static int add_priorities(sd_journal *j) {
1254         char match[] = "PRIORITY=0";
1255         int i, r;
1256         assert(j);
1257
1258         if (arg_priorities == 0xFF)
1259                 return 0;
1260
1261         for (i = LOG_EMERG; i <= LOG_DEBUG; i++)
1262                 if (arg_priorities & (1 << i)) {
1263                         match[sizeof(match)-2] = '0' + i;
1264
1265                         r = sd_journal_add_match(j, match, strlen(match));
1266                         if (r < 0) {
1267                                 log_error_errno(r, "Failed to add match: %m");
1268                                 return r;
1269                         }
1270                 }
1271
1272         r = sd_journal_add_conjunction(j);
1273         if (r < 0)
1274                 return r;
1275
1276         return 0;
1277 }
1278
1279
1280 static int add_syslog_identifier(sd_journal *j) {
1281         int r;
1282         char **i;
1283
1284         assert(j);
1285
1286         STRV_FOREACH(i, arg_syslog_identifier) {
1287                 char *u;
1288
1289                 u = strappenda("SYSLOG_IDENTIFIER=", *i);
1290                 r = sd_journal_add_match(j, u, 0);
1291                 if (r < 0)
1292                         return r;
1293                 r = sd_journal_add_disjunction(j);
1294                 if (r < 0)
1295                         return r;
1296         }
1297
1298         r = sd_journal_add_conjunction(j);
1299         if (r < 0)
1300                 return r;
1301
1302         return 0;
1303 }
1304
1305 static int setup_keys(void) {
1306 #ifdef HAVE_GCRYPT
1307         size_t mpk_size, seed_size, state_size, i;
1308         uint8_t *mpk, *seed, *state;
1309         ssize_t l;
1310         int fd = -1, r, attr = 0;
1311         sd_id128_t machine, boot;
1312         char *p = NULL, *k = NULL;
1313         struct FSSHeader h;
1314         uint64_t n;
1315         struct stat st;
1316
1317         r = stat("/var/log/journal", &st);
1318         if (r < 0 && errno != ENOENT && errno != ENOTDIR) {
1319                 log_error("stat(\"%s\") failed: %m", "/var/log/journal");
1320                 return -errno;
1321         }
1322
1323         if (r < 0 || !S_ISDIR(st.st_mode)) {
1324                 log_error("%s is not a directory, must be using persistent logging for FSS.",
1325                           "/var/log/journal");
1326                 return r < 0 ? -errno : -ENOTDIR;
1327         }
1328
1329         r = sd_id128_get_machine(&machine);
1330         if (r < 0) {
1331                 log_error_errno(r, "Failed to get machine ID: %m");
1332                 return r;
1333         }
1334
1335         r = sd_id128_get_boot(&boot);
1336         if (r < 0) {
1337                 log_error_errno(r, "Failed to get boot ID: %m");
1338                 return r;
1339         }
1340
1341         if (asprintf(&p, "/var/log/journal/" SD_ID128_FORMAT_STR "/fss",
1342                      SD_ID128_FORMAT_VAL(machine)) < 0)
1343                 return log_oom();
1344
1345         if (access(p, F_OK) >= 0) {
1346                 if (arg_force) {
1347                         r = unlink(p);
1348                         if (r < 0) {
1349                                 log_error("unlink(\"%s\") failed: %m", p);
1350                                 r = -errno;
1351                                 goto finish;
1352                         }
1353                 } else {
1354                         log_error("Sealing key file %s exists already. (--force to recreate)", p);
1355                         r = -EEXIST;
1356                         goto finish;
1357                 }
1358         }
1359
1360         if (asprintf(&k, "/var/log/journal/" SD_ID128_FORMAT_STR "/fss.tmp.XXXXXX",
1361                      SD_ID128_FORMAT_VAL(machine)) < 0) {
1362                 r = log_oom();
1363                 goto finish;
1364         }
1365
1366         mpk_size = FSPRG_mskinbytes(FSPRG_RECOMMENDED_SECPAR);
1367         mpk = alloca(mpk_size);
1368
1369         seed_size = FSPRG_RECOMMENDED_SEEDLEN;
1370         seed = alloca(seed_size);
1371
1372         state_size = FSPRG_stateinbytes(FSPRG_RECOMMENDED_SECPAR);
1373         state = alloca(state_size);
1374
1375         fd = open("/dev/random", O_RDONLY|O_CLOEXEC|O_NOCTTY);
1376         if (fd < 0) {
1377                 log_error("Failed to open /dev/random: %m");
1378                 r = -errno;
1379                 goto finish;
1380         }
1381
1382         log_info("Generating seed...");
1383         l = loop_read(fd, seed, seed_size, true);
1384         if (l < 0 || (size_t) l != seed_size) {
1385                 log_error_errno(EIO, "Failed to read random seed: %m");
1386                 r = -EIO;
1387                 goto finish;
1388         }
1389
1390         log_info("Generating key pair...");
1391         FSPRG_GenMK(NULL, mpk, seed, seed_size, FSPRG_RECOMMENDED_SECPAR);
1392
1393         log_info("Generating sealing key...");
1394         FSPRG_GenState0(state, mpk, seed, seed_size);
1395
1396         assert(arg_interval > 0);
1397
1398         n = now(CLOCK_REALTIME);
1399         n /= arg_interval;
1400
1401         safe_close(fd);
1402         fd = mkostemp_safe(k, O_WRONLY|O_CLOEXEC);
1403         if (fd < 0) {
1404                 log_error("Failed to open %s: %m", k);
1405                 r = -errno;
1406                 goto finish;
1407         }
1408
1409         /* Enable secure remove, exclusion from dump, synchronous
1410          * writing and in-place updating */
1411         if (ioctl(fd, FS_IOC_GETFLAGS, &attr) < 0)
1412                 log_warning("FS_IOC_GETFLAGS failed: %m");
1413
1414         attr |= FS_SECRM_FL|FS_NODUMP_FL|FS_SYNC_FL|FS_NOCOW_FL;
1415
1416         if (ioctl(fd, FS_IOC_SETFLAGS, &attr) < 0)
1417                 log_warning("FS_IOC_SETFLAGS failed: %m");
1418
1419         zero(h);
1420         memcpy(h.signature, "KSHHRHLP", 8);
1421         h.machine_id = machine;
1422         h.boot_id = boot;
1423         h.header_size = htole64(sizeof(h));
1424         h.start_usec = htole64(n * arg_interval);
1425         h.interval_usec = htole64(arg_interval);
1426         h.fsprg_secpar = htole16(FSPRG_RECOMMENDED_SECPAR);
1427         h.fsprg_state_size = htole64(state_size);
1428
1429         l = loop_write(fd, &h, sizeof(h), false);
1430         if (l < 0 || (size_t) l != sizeof(h)) {
1431                 log_error_errno(EIO, "Failed to write header: %m");
1432                 r = -EIO;
1433                 goto finish;
1434         }
1435
1436         l = loop_write(fd, state, state_size, false);
1437         if (l < 0 || (size_t) l != state_size) {
1438                 log_error_errno(EIO, "Failed to write state: %m");
1439                 r = -EIO;
1440                 goto finish;
1441         }
1442
1443         if (link(k, p) < 0) {
1444                 log_error("Failed to link file: %m");
1445                 r = -errno;
1446                 goto finish;
1447         }
1448
1449         if (on_tty()) {
1450                 fprintf(stderr,
1451                         "\n"
1452                         "The new key pair has been generated. The " ANSI_HIGHLIGHT_ON "secret sealing key" ANSI_HIGHLIGHT_OFF " has been written to\n"
1453                         "the following local file. This key file is automatically updated when the\n"
1454                         "sealing key is advanced. It should not be used on multiple hosts.\n"
1455                         "\n"
1456                         "\t%s\n"
1457                         "\n"
1458                         "Please write down the following " ANSI_HIGHLIGHT_ON "secret verification key" ANSI_HIGHLIGHT_OFF ". It should be stored\n"
1459                         "at a safe location and should not be saved locally on disk.\n"
1460                         "\n\t" ANSI_HIGHLIGHT_RED_ON, p);
1461                 fflush(stderr);
1462         }
1463         for (i = 0; i < seed_size; i++) {
1464                 if (i > 0 && i % 3 == 0)
1465                         putchar('-');
1466                 printf("%02x", ((uint8_t*) seed)[i]);
1467         }
1468
1469         printf("/%llx-%llx\n", (unsigned long long) n, (unsigned long long) arg_interval);
1470
1471         if (on_tty()) {
1472                 char tsb[FORMAT_TIMESPAN_MAX], *hn;
1473
1474                 fprintf(stderr,
1475                         ANSI_HIGHLIGHT_OFF "\n"
1476                         "The sealing key is automatically changed every %s.\n",
1477                         format_timespan(tsb, sizeof(tsb), arg_interval, 0));
1478
1479                 hn = gethostname_malloc();
1480
1481                 if (hn) {
1482                         hostname_cleanup(hn, false);
1483                         fprintf(stderr, "\nThe keys have been generated for host %s/" SD_ID128_FORMAT_STR ".\n", hn, SD_ID128_FORMAT_VAL(machine));
1484                 } else
1485                         fprintf(stderr, "\nThe keys have been generated for host " SD_ID128_FORMAT_STR ".\n", SD_ID128_FORMAT_VAL(machine));
1486
1487 #ifdef HAVE_QRENCODE
1488                 /* If this is not an UTF-8 system don't print any QR codes */
1489                 if (is_locale_utf8()) {
1490                         fputs("\nTo transfer the verification key to your phone please scan the QR code below:\n\n", stderr);
1491                         print_qr_code(stderr, seed, seed_size, n, arg_interval, hn, machine);
1492                 }
1493 #endif
1494                 free(hn);
1495         }
1496
1497         r = 0;
1498
1499 finish:
1500         safe_close(fd);
1501
1502         if (k) {
1503                 unlink(k);
1504                 free(k);
1505         }
1506
1507         free(p);
1508
1509         return r;
1510 #else
1511         log_error("Forward-secure sealing not available.");
1512         return -ENOTSUP;
1513 #endif
1514 }
1515
1516 static int verify(sd_journal *j) {
1517         int r = 0;
1518         Iterator i;
1519         JournalFile *f;
1520
1521         assert(j);
1522
1523         log_show_color(true);
1524
1525         ORDERED_HASHMAP_FOREACH(f, j->files, i) {
1526                 int k;
1527                 usec_t first, validated, last;
1528
1529 #ifdef HAVE_GCRYPT
1530                 if (!arg_verify_key && JOURNAL_HEADER_SEALED(f->header))
1531                         log_notice("Journal file %s has sealing enabled but verification key has not been passed using --verify-key=.", f->path);
1532 #endif
1533
1534                 k = journal_file_verify(f, arg_verify_key, &first, &validated, &last, true);
1535                 if (k == -EINVAL) {
1536                         /* If the key was invalid give up right-away. */
1537                         return k;
1538                 } else if (k < 0) {
1539                         log_warning("FAIL: %s (%s)", f->path, strerror(-k));
1540                         r = k;
1541                 } else {
1542                         char a[FORMAT_TIMESTAMP_MAX], b[FORMAT_TIMESTAMP_MAX], c[FORMAT_TIMESPAN_MAX];
1543                         log_info("PASS: %s", f->path);
1544
1545                         if (arg_verify_key && JOURNAL_HEADER_SEALED(f->header)) {
1546                                 if (validated > 0) {
1547                                         log_info("=> Validated from %s to %s, final %s entries not sealed.",
1548                                                  format_timestamp_maybe_utc(a, sizeof(a), first),
1549                                                  format_timestamp_maybe_utc(b, sizeof(b), validated),
1550                                                  format_timespan(c, sizeof(c), last > validated ? last - validated : 0, 0));
1551                                 } else if (last > 0)
1552                                         log_info("=> No sealing yet, %s of entries not sealed.",
1553                                                  format_timespan(c, sizeof(c), last - first, 0));
1554                                 else
1555                                         log_info("=> No sealing yet, no entries in file.");
1556                         }
1557                 }
1558         }
1559
1560         return r;
1561 }
1562
1563 #ifdef HAVE_ACL
1564 static int access_check_var_log_journal(sd_journal *j) {
1565         _cleanup_strv_free_ char **g = NULL;
1566         bool have_access;
1567         int r;
1568
1569         assert(j);
1570
1571         have_access = in_group("systemd-journal") > 0;
1572
1573         if (!have_access) {
1574                 /* Let's enumerate all groups from the default ACL of
1575                  * the directory, which generally should allow access
1576                  * to most journal files too */
1577                 r = search_acl_groups(&g, "/var/log/journal/", &have_access);
1578                 if (r < 0)
1579                         return r;
1580         }
1581
1582         if (!have_access) {
1583
1584                 if (strv_isempty(g))
1585                         log_notice("Hint: You are currently not seeing messages from other users and the system.\n"
1586                                    "      Users in the 'systemd-journal' group can see all messages. Pass -q to\n"
1587                                    "      turn off this notice.");
1588                 else {
1589                         _cleanup_free_ char *s = NULL;
1590
1591                         r = strv_extend(&g, "systemd-journal");
1592                         if (r < 0)
1593                                 return log_oom();
1594
1595                         strv_sort(g);
1596                         strv_uniq(g);
1597
1598                         s = strv_join(g, "', '");
1599                         if (!s)
1600                                 return log_oom();
1601
1602                         log_notice("Hint: You are currently not seeing messages from other users and the system.\n"
1603                                    "      Users in the groups '%s' can see all messages.\n"
1604                                    "      Pass -q to turn off this notice.", s);
1605                 }
1606         }
1607
1608         return 0;
1609 }
1610 #endif
1611
1612 static int access_check(sd_journal *j) {
1613         Iterator it;
1614         void *code;
1615         int r = 0;
1616
1617         assert(j);
1618
1619         if (set_isempty(j->errors)) {
1620                 if (ordered_hashmap_isempty(j->files))
1621                         log_notice("No journal files were found.");
1622                 return 0;
1623         }
1624
1625         if (set_contains(j->errors, INT_TO_PTR(-EACCES))) {
1626 #ifdef HAVE_ACL
1627                 /* If /var/log/journal doesn't even exist,
1628                  * unprivileged users have no access at all */
1629                 if (access("/var/log/journal", F_OK) < 0 &&
1630                     geteuid() != 0 &&
1631                     in_group("systemd-journal") <= 0) {
1632                         log_error("Unprivileged users cannot access messages, unless persistent log storage is\n"
1633                                   "enabled. Users in the 'systemd-journal' group may always access messages.");
1634                         return -EACCES;
1635                 }
1636
1637                 /* If /var/log/journal exists, try to pring a nice
1638                    notice if the user lacks access to it */
1639                 if (!arg_quiet && geteuid() != 0) {
1640                         r = access_check_var_log_journal(j);
1641                         if (r < 0)
1642                                 return r;
1643                 }
1644 #else
1645                 if (geteuid() != 0 && in_group("systemd-journal") <= 0) {
1646                         log_error("Unprivileged users cannot access messages. Users in the 'systemd-journal' group\n"
1647                                   "group may access messages.");
1648                         return -EACCES;
1649                 }
1650 #endif
1651
1652                 if (ordered_hashmap_isempty(j->files)) {
1653                         log_error("No journal files were opened due to insufficient permissions.");
1654                         r = -EACCES;
1655                 }
1656         }
1657
1658         SET_FOREACH(code, j->errors, it) {
1659                 int err;
1660
1661                 err = -PTR_TO_INT(code);
1662                 assert(err > 0);
1663
1664                 if (err != EACCES)
1665                         log_warning_errno(err, "Error was encountered while opening journal files: %m");
1666         }
1667
1668         return r;
1669 }
1670
1671 static int flush_to_var(void) {
1672         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1673         _cleanup_bus_close_unref_ sd_bus *bus = NULL;
1674         _cleanup_close_ int watch_fd = -1;
1675         int r;
1676
1677         /* Quick exit */
1678         if (access("/run/systemd/journal/flushed", F_OK) >= 0)
1679                 return 0;
1680
1681         /* OK, let's actually do the full logic, send SIGUSR1 to the
1682          * daemon and set up inotify to wait for the flushed file to appear */
1683         r = bus_open_system_systemd(&bus);
1684         if (r < 0) {
1685                 log_error_errno(r, "Failed to get D-Bus connection: %m");
1686                 return r;
1687         }
1688
1689         r = sd_bus_call_method(
1690                         bus,
1691                         "org.freedesktop.systemd1",
1692                         "/org/freedesktop/systemd1",
1693                         "org.freedesktop.systemd1.Manager",
1694                         "KillUnit",
1695                         &error,
1696                         NULL,
1697                         "ssi", "systemd-journald.service", "main", SIGUSR1);
1698         if (r < 0) {
1699                 log_error("Failed to kill journal service: %s", bus_error_message(&error, r));
1700                 return r;
1701         }
1702
1703         mkdir_p("/run/systemd/journal", 0755);
1704
1705         watch_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
1706         if (watch_fd < 0) {
1707                 log_error("Failed to create inotify watch: %m");
1708                 return -errno;
1709         }
1710
1711         r = inotify_add_watch(watch_fd, "/run/systemd/journal", IN_CREATE|IN_DONT_FOLLOW|IN_ONLYDIR);
1712         if (r < 0) {
1713                 log_error("Failed to watch journal directory: %m");
1714                 return -errno;
1715         }
1716
1717         for (;;) {
1718                 if (access("/run/systemd/journal/flushed", F_OK) >= 0)
1719                         break;
1720
1721                 if (errno != ENOENT) {
1722                         log_error("Failed to check for existance of /run/systemd/journal/flushed: %m");
1723                         return -errno;
1724                 }
1725
1726                 r = fd_wait_for_event(watch_fd, POLLIN, USEC_INFINITY);
1727                 if (r < 0) {
1728                         log_error_errno(r, "Failed to wait for event: %m");
1729                         return r;
1730                 }
1731
1732                 r = flush_fd(watch_fd);
1733                 if (r < 0) {
1734                         log_error_errno(r, "Failed to flush inotify events: %m");
1735                         return r;
1736                 }
1737         }
1738
1739         return 0;
1740 }
1741
1742 int main(int argc, char *argv[]) {
1743         int r;
1744         _cleanup_journal_close_ sd_journal *j = NULL;
1745         bool need_seek = false;
1746         sd_id128_t previous_boot_id;
1747         bool previous_boot_id_valid = false, first_line = true;
1748         int n_shown = 0;
1749         bool ellipsized = false;
1750
1751         setlocale(LC_ALL, "");
1752         log_parse_environment();
1753         log_open();
1754
1755         r = parse_argv(argc, argv);
1756         if (r <= 0)
1757                 goto finish;
1758
1759         signal(SIGWINCH, columns_lines_cache_reset);
1760
1761         if (arg_action == ACTION_NEW_ID128) {
1762                 r = generate_new_id128();
1763                 goto finish;
1764         }
1765
1766         if (arg_action == ACTION_FLUSH) {
1767                 r = flush_to_var();
1768                 goto finish;
1769         }
1770
1771         if (arg_action == ACTION_SETUP_KEYS) {
1772                 r = setup_keys();
1773                 goto finish;
1774         }
1775
1776         if (arg_action == ACTION_UPDATE_CATALOG ||
1777             arg_action == ACTION_LIST_CATALOG ||
1778             arg_action == ACTION_DUMP_CATALOG) {
1779
1780                 _cleanup_free_ char *database;
1781
1782                 database = path_join(arg_root, CATALOG_DATABASE, NULL);
1783                 if (!database) {
1784                         r = log_oom();
1785                         goto finish;
1786                 }
1787
1788                 if (arg_action == ACTION_UPDATE_CATALOG) {
1789                         r = catalog_update(database, arg_root, catalog_file_dirs);
1790                         if (r < 0)
1791                                 log_error_errno(r, "Failed to list catalog: %m");
1792                 } else {
1793                         bool oneline = arg_action == ACTION_LIST_CATALOG;
1794
1795                         if (optind < argc)
1796                                 r = catalog_list_items(stdout, database,
1797                                                        oneline, argv + optind);
1798                         else
1799                                 r = catalog_list(stdout, database, oneline);
1800                         if (r < 0)
1801                                 log_error_errno(r, "Failed to list catalog: %m");
1802                 }
1803
1804                 goto finish;
1805         }
1806
1807         if (arg_directory)
1808                 r = sd_journal_open_directory(&j, arg_directory, arg_journal_type);
1809         else if (arg_file)
1810                 r = sd_journal_open_files(&j, (const char**) arg_file, 0);
1811         else if (arg_machine)
1812                 r = sd_journal_open_container(&j, arg_machine, 0);
1813         else
1814                 r = sd_journal_open(&j, !arg_merge*SD_JOURNAL_LOCAL_ONLY + arg_journal_type);
1815         if (r < 0) {
1816                 log_error_errno(r, "Failed to open %s: %m",
1817                                 arg_directory ? arg_directory : arg_file ? "files" : "journal");
1818                 return EXIT_FAILURE;
1819         }
1820
1821         r = access_check(j);
1822         if (r < 0)
1823                 return EXIT_FAILURE;
1824
1825         if (arg_action == ACTION_VERIFY) {
1826                 r = verify(j);
1827                 goto finish;
1828         }
1829
1830         if (arg_action == ACTION_PRINT_HEADER) {
1831                 journal_print_header(j);
1832                 return EXIT_SUCCESS;
1833         }
1834
1835         if (arg_action == ACTION_DISK_USAGE) {
1836                 uint64_t bytes = 0;
1837                 char sbytes[FORMAT_BYTES_MAX];
1838
1839                 r = sd_journal_get_usage(j, &bytes);
1840                 if (r < 0)
1841                         return EXIT_FAILURE;
1842
1843                 printf("Archived and active journals take up %s on disk.\n",
1844                        format_bytes(sbytes, sizeof(sbytes), bytes));
1845                 return EXIT_SUCCESS;
1846         }
1847
1848         if (arg_action == ACTION_VACUUM) {
1849                 Directory *d;
1850                 Iterator i;
1851
1852                 HASHMAP_FOREACH(d, j->directories_by_path, i) {
1853                         int q;
1854
1855                         if (d->is_root)
1856                                 continue;
1857
1858                         q = journal_directory_vacuum(d->path, arg_vacuum_size, arg_vacuum_time, NULL, true);
1859                         if (q < 0) {
1860                                 log_error_errno(q, "Failed to vacuum: %m");
1861                                 r = q;
1862                         }
1863                 }
1864
1865                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1866         }
1867
1868         if (arg_action == ACTION_LIST_BOOTS) {
1869                 r = list_boots(j);
1870                 goto finish;
1871         }
1872
1873         /* add_boot() must be called first!
1874          * It may need to seek the journal to find parent boot IDs. */
1875         r = add_boot(j);
1876         if (r < 0)
1877                 return EXIT_FAILURE;
1878
1879         r = add_dmesg(j);
1880         if (r < 0)
1881                 return EXIT_FAILURE;
1882
1883         r = add_units(j);
1884         strv_free(arg_system_units);
1885         strv_free(arg_user_units);
1886
1887         if (r < 0) {
1888                 log_error_errno(r, "Failed to add filter for units: %m");
1889                 return EXIT_FAILURE;
1890         }
1891
1892         r = add_syslog_identifier(j);
1893         if (r < 0) {
1894                 log_error_errno(r, "Failed to add filter for syslog identifiers: %m");
1895                 return EXIT_FAILURE;
1896         }
1897
1898         r = add_priorities(j);
1899         if (r < 0) {
1900                 log_error_errno(r, "Failed to add filter for priorities: %m");
1901                 return EXIT_FAILURE;
1902         }
1903
1904         r = add_matches(j, argv + optind);
1905         if (r < 0) {
1906                 log_error_errno(r, "Failed to add filters: %m");
1907                 return EXIT_FAILURE;
1908         }
1909
1910         if (_unlikely_(log_get_max_level() >= LOG_PRI(LOG_DEBUG))) {
1911                 _cleanup_free_ char *filter;
1912
1913                 filter = journal_make_match_string(j);
1914                 log_debug("Journal filter: %s", filter);
1915         }
1916
1917         if (arg_field) {
1918                 const void *data;
1919                 size_t size;
1920
1921                 r = sd_journal_set_data_threshold(j, 0);
1922                 if (r < 0) {
1923                         log_error("Failed to unset data size threshold");
1924                         return EXIT_FAILURE;
1925                 }
1926
1927                 r = sd_journal_query_unique(j, arg_field);
1928                 if (r < 0) {
1929                         log_error_errno(r, "Failed to query unique data objects: %m");
1930                         return EXIT_FAILURE;
1931                 }
1932
1933                 SD_JOURNAL_FOREACH_UNIQUE(j, data, size) {
1934                         const void *eq;
1935
1936                         if (arg_lines >= 0 && n_shown >= arg_lines)
1937                                 break;
1938
1939                         eq = memchr(data, '=', size);
1940                         if (eq)
1941                                 printf("%.*s\n", (int) (size - ((const uint8_t*) eq - (const uint8_t*) data + 1)), (const char*) eq + 1);
1942                         else
1943                                 printf("%.*s\n", (int) size, (const char*) data);
1944
1945                         n_shown ++;
1946                 }
1947
1948                 return EXIT_SUCCESS;
1949         }
1950
1951         /* Opening the fd now means the first sd_journal_wait() will actually wait */
1952         if (arg_follow) {
1953                 r = sd_journal_get_fd(j);
1954                 if (r < 0)
1955                         return EXIT_FAILURE;
1956         }
1957
1958         if (arg_cursor || arg_after_cursor) {
1959                 r = sd_journal_seek_cursor(j, arg_cursor ?: arg_after_cursor);
1960                 if (r < 0) {
1961                         log_error_errno(r, "Failed to seek to cursor: %m");
1962                         return EXIT_FAILURE;
1963                 }
1964                 if (!arg_reverse)
1965                         r = sd_journal_next_skip(j, 1 + !!arg_after_cursor);
1966                 else
1967                         r = sd_journal_previous_skip(j, 1 + !!arg_after_cursor);
1968
1969                 if (arg_after_cursor && r < 2 && !arg_follow)
1970                         /* We couldn't find the next entry after the cursor. */
1971                         arg_lines = 0;
1972
1973         } else if (arg_since_set && !arg_reverse) {
1974                 r = sd_journal_seek_realtime_usec(j, arg_since);
1975                 if (r < 0) {
1976                         log_error_errno(r, "Failed to seek to date: %m");
1977                         return EXIT_FAILURE;
1978                 }
1979                 r = sd_journal_next(j);
1980
1981         } else if (arg_until_set && arg_reverse) {
1982                 r = sd_journal_seek_realtime_usec(j, arg_until);
1983                 if (r < 0) {
1984                         log_error_errno(r, "Failed to seek to date: %m");
1985                         return EXIT_FAILURE;
1986                 }
1987                 r = sd_journal_previous(j);
1988
1989         } else if (arg_lines >= 0) {
1990                 r = sd_journal_seek_tail(j);
1991                 if (r < 0) {
1992                         log_error_errno(r, "Failed to seek to tail: %m");
1993                         return EXIT_FAILURE;
1994                 }
1995
1996                 r = sd_journal_previous_skip(j, arg_lines);
1997
1998         } else if (arg_reverse) {
1999                 r = sd_journal_seek_tail(j);
2000                 if (r < 0) {
2001                         log_error_errno(r, "Failed to seek to tail: %m");
2002                         return EXIT_FAILURE;
2003                 }
2004
2005                 r = sd_journal_previous(j);
2006
2007         } else {
2008                 r = sd_journal_seek_head(j);
2009                 if (r < 0) {
2010                         log_error_errno(r, "Failed to seek to head: %m");
2011                         return EXIT_FAILURE;
2012                 }
2013
2014                 r = sd_journal_next(j);
2015         }
2016
2017         if (r < 0) {
2018                 log_error_errno(r, "Failed to iterate through journal: %m");
2019                 return EXIT_FAILURE;
2020         }
2021
2022         if (!arg_follow)
2023                 pager_open_if_enabled();
2024
2025         if (!arg_quiet) {
2026                 usec_t start, end;
2027                 char start_buf[FORMAT_TIMESTAMP_MAX], end_buf[FORMAT_TIMESTAMP_MAX];
2028
2029                 r = sd_journal_get_cutoff_realtime_usec(j, &start, &end);
2030                 if (r < 0) {
2031                         log_error_errno(r, "Failed to get cutoff: %m");
2032                         goto finish;
2033                 }
2034
2035                 if (r > 0) {
2036                         if (arg_follow)
2037                                 printf("-- Logs begin at %s. --\n",
2038                                        format_timestamp_maybe_utc(start_buf, sizeof(start_buf), start));
2039                         else
2040                                 printf("-- Logs begin at %s, end at %s. --\n",
2041                                        format_timestamp_maybe_utc(start_buf, sizeof(start_buf), start),
2042                                        format_timestamp_maybe_utc(end_buf, sizeof(end_buf), end));
2043                 }
2044         }
2045
2046         for (;;) {
2047                 while (arg_lines < 0 || n_shown < arg_lines || (arg_follow && !first_line)) {
2048                         int flags;
2049
2050                         if (need_seek) {
2051                                 if (!arg_reverse)
2052                                         r = sd_journal_next(j);
2053                                 else
2054                                         r = sd_journal_previous(j);
2055                                 if (r < 0) {
2056                                         log_error_errno(r, "Failed to iterate through journal: %m");
2057                                         goto finish;
2058                                 }
2059                                 if (r == 0)
2060                                         break;
2061                         }
2062
2063                         if (arg_until_set && !arg_reverse) {
2064                                 usec_t usec;
2065
2066                                 r = sd_journal_get_realtime_usec(j, &usec);
2067                                 if (r < 0) {
2068                                         log_error_errno(r, "Failed to determine timestamp: %m");
2069                                         goto finish;
2070                                 }
2071                                 if (usec > arg_until)
2072                                         goto finish;
2073                         }
2074
2075                         if (arg_since_set && arg_reverse) {
2076                                 usec_t usec;
2077
2078                                 r = sd_journal_get_realtime_usec(j, &usec);
2079                                 if (r < 0) {
2080                                         log_error_errno(r, "Failed to determine timestamp: %m");
2081                                         goto finish;
2082                                 }
2083                                 if (usec < arg_since)
2084                                         goto finish;
2085                         }
2086
2087                         if (!arg_merge && !arg_quiet) {
2088                                 sd_id128_t boot_id;
2089
2090                                 r = sd_journal_get_monotonic_usec(j, NULL, &boot_id);
2091                                 if (r >= 0) {
2092                                         if (previous_boot_id_valid &&
2093                                             !sd_id128_equal(boot_id, previous_boot_id))
2094                                                 printf("%s-- Reboot --%s\n",
2095                                                        ansi_highlight(), ansi_highlight_off());
2096
2097                                         previous_boot_id = boot_id;
2098                                         previous_boot_id_valid = true;
2099                                 }
2100                         }
2101
2102                         flags =
2103                                 arg_all * OUTPUT_SHOW_ALL |
2104                                 arg_full * OUTPUT_FULL_WIDTH |
2105                                 on_tty() * OUTPUT_COLOR |
2106                                 arg_catalog * OUTPUT_CATALOG |
2107                                 arg_utc * OUTPUT_UTC;
2108
2109                         r = output_journal(stdout, j, arg_output, 0, flags, &ellipsized);
2110                         need_seek = true;
2111                         if (r == -EADDRNOTAVAIL)
2112                                 break;
2113                         else if (r < 0 || ferror(stdout))
2114                                 goto finish;
2115
2116                         n_shown++;
2117                 }
2118
2119                 if (!arg_follow) {
2120                         if (arg_show_cursor) {
2121                                 _cleanup_free_ char *cursor = NULL;
2122
2123                                 r = sd_journal_get_cursor(j, &cursor);
2124                                 if (r < 0 && r != -EADDRNOTAVAIL)
2125                                         log_error_errno(r, "Failed to get cursor: %m");
2126                                 else if (r >= 0)
2127                                         printf("-- cursor: %s\n", cursor);
2128                         }
2129
2130                         break;
2131                 }
2132
2133                 r = sd_journal_wait(j, (uint64_t) -1);
2134                 if (r < 0) {
2135                         log_error_errno(r, "Couldn't wait for journal event: %m");
2136                         goto finish;
2137                 }
2138
2139                 first_line = false;
2140         }
2141
2142 finish:
2143         pager_close();
2144
2145         strv_free(arg_file);
2146
2147         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
2148 }