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