#include <errno.h>

#include <fcntl.h>

#include <fnmatch.h>

#include <getopt.h>

#include <linux/fs.h>

#include <signal.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/inotify.h>

#include <sys/stat.h>

#include <unistd.h>

#if HAVE_PCRE2

# define PCRE2_CODE_UNIT_WIDTH 8

# include <pcre2.h>

#include "sd-bus.h"

#include "sd-device.h"

#include "sd-journal.h"

#include "acl-util.h"

#include "alloc-util.h"

#include "bus-error.h"

#include "bus-util.h"

#include "catalog.h"

#include "chase-symlinks.h"

#include "chattr-util.h"

#include "def.h"

#include "dissect-image.h"

#include "fd-util.h"

#include "fileio.h"

#include "format-table.h"

#include "format-util.h"

#include "fs-util.h"

#include "fsprg.h"

#include "glob-util.h"

#include "hostname-util.h"

#include "id128-print.h"

#include "io-util.h"

#include "journal-def.h"

#include "journal-internal.h"

#include "journal-util.h"

#include "journal-vacuum.h"

#include "journal-verify.h"

#include "locale-util.h"

#include "log.h"

#include "logs-show.h"

#include "memory-util.h"

#include "mkdir.h"

#include "mount-util.h"

#include "mountpoint-util.h"

#include "nulstr-util.h"

#include "pager.h"

#include "parse-argument.h"

#include "parse-util.h"

#include "path-util.h"

#include "pcre2-dlopen.h"

#include "pretty-print.h"

#include "qrcode-util.h"

#include "random-util.h"

#include "rlimit-util.h"

#include "set.h"

#include "sigbus.h"

#include "stdio-util.h"

#include "string-table.h"

#include "strv.h"

#include "syslog-util.h"

#include "terminal-util.h"

#include "tmpfile-util.h"

#include "unit-name.h"

#include "user-util.h"

#include "varlink.h"

#define DEFAULT_FSS_INTERVAL_USEC (15*USEC_PER_MINUTE)

#define PROCESS_INOTIFY_INTERVAL 1024 /* Every 1,024 messages processed */

enum {

/* Special values for arg_lines */

ARG_LINES_DEFAULT = -2,

ARG_LINES_ALL = -1,

};

static OutputMode arg_output = OUTPUT_SHORT;

static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;

static bool arg_utc = false;

static bool arg_follow = false;

static bool arg_full = true;

static bool arg_all = false;

static PagerFlags arg_pager_flags = 0;

static int arg_lines = ARG_LINES_DEFAULT;

static bool arg_no_tail = false;

static bool arg_quiet = false;

static bool arg_merge = false;

static bool arg_boot = false;

static sd_id128_t arg_boot_id = {};

static int arg_boot_offset = 0;

static bool arg_dmesg = false;

static bool arg_no_hostname = false;

static const char *arg_cursor = NULL;

static const char *arg_cursor_file = NULL;

static const char *arg_after_cursor = NULL;

static bool arg_show_cursor = false;

static const char *arg_directory = NULL;

static char **arg_file = NULL;

static bool arg_file_stdin = false;

static int arg_priorities = 0xFF;

static Set *arg_facilities = NULL;

static char *arg_verify_key = NULL;

#if HAVE_GCRYPT

static usec_t arg_interval = DEFAULT_FSS_INTERVAL_USEC;

static bool arg_force = false;

static usec_t arg_since, arg_until;

static bool arg_since_set = false, arg_until_set = false;

static char **arg_syslog_identifier = NULL;

static char **arg_system_units = NULL;

static char **arg_user_units = NULL;

static const char *arg_field = NULL;

static bool arg_catalog = false;

static bool arg_reverse = false;

static int arg_journal_type = 0;

static int arg_namespace_flags = 0;

static char *arg_root = NULL;

static char *arg_image = NULL;

static const char *arg_machine = NULL;

static const char *arg_namespace = NULL;

static uint64_t arg_vacuum_size = 0;

static uint64_t arg_vacuum_n_files = 0;

static usec_t arg_vacuum_time = 0;

static char **arg_output_fields = NULL;

#if HAVE_PCRE2

static const char *arg_pattern = NULL;

static pcre2_code *arg_compiled_pattern = NULL;

static int arg_case_sensitive = -1; /* -1 means be smart */

static enum {

ACTION_SHOW,

ACTION_NEW_ID128,

ACTION_PRINT_HEADER,

ACTION_SETUP_KEYS,

ACTION_VERIFY,

ACTION_DISK_USAGE,

ACTION_LIST_CATALOG,

ACTION_DUMP_CATALOG,

ACTION_UPDATE_CATALOG,

ACTION_LIST_BOOTS,

ACTION_FLUSH,

ACTION_RELINQUISH_VAR,

ACTION_SYNC,

ACTION_ROTATE,

ACTION_VACUUM,

ACTION_ROTATE_AND_VACUUM,

ACTION_LIST_FIELDS,

ACTION_LIST_FIELD_NAMES,

} arg_action = ACTION_SHOW;

typedef struct BootId {

} BootId;

#if HAVE_PCRE2

DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(pcre2_match_data*, sym_pcre2_match_data_free, NULL);

DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(pcre2_code*, sym_pcre2_code_free, NULL);

static int pattern_compile(const char *pattern, unsigned flags, pcre2_code **out) {

int errorcode, r;

PCRE2_SIZE erroroffset;

pcre2_code *p;

p = sym_pcre2_compile((PCRE2_SPTR8) pattern,

PCRE2_ZERO_TERMINATED, flags, &errorcode, &erroroffset, NULL);

if (!p) {

unsigned char buf[LINE_MAX];

r = sym_pcre2_get_error_message(errorcode, buf, sizeof buf);

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"Bad pattern \"%s\": %s", pattern,

r < 0 ? "unknown error" : (char *)buf);

}

*out = p;

return 0;

}

static int add_matches_for_device(sd_journal *j, const char *devpath) {

_cleanup_(sd_device_unrefp) sd_device *device = NULL;

sd_device *d = NULL;

struct stat st;

int r;

assert(j);

assert(devpath);

if (!path_startswith(devpath, "/dev/"))

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"Devpath does not start with /dev/");

if (stat(devpath, &st) < 0)

return log_error_errno(errno, "Couldn't stat file: %m");

r = sd_device_new_from_stat_rdev(&device, &st);

if (r < 0)

return log_error_errno(r, "Failed to get device from devnum %u:%u: %m", major(st.st_rdev), minor(st.st_rdev));

for (d = device; d; ) {

_cleanup_free_ char *match = NULL;

const char *subsys, *sysname, *devnode;

sd_device *parent;

r = sd_device_get_subsystem(d, &subsys);

if (r < 0)

goto get_parent;

r = sd_device_get_sysname(d, &sysname);

if (r < 0)

goto get_parent;

match = strjoin("_KERNEL_DEVICE=+", subsys, ":", sysname);

if (!match)

return log_oom();

r = sd_journal_add_match(j, match, 0);

if (r < 0)

return log_error_errno(r, "Failed to add match: %m");

if (sd_device_get_devname(d, &devnode) >= 0) {

_cleanup_free_ char *match1 = NULL;

r = stat(devnode, &st);

if (r < 0)

return log_error_errno(r, "Failed to stat() device node \"%s\": %m", devnode);

r = asprintf(&match1, "_KERNEL_DEVICE=%c%u:%u", S_ISBLK(st.st_mode) ? 'b' : 'c', major(st.st_rdev), minor(st.st_rdev));

if (r < 0)

return log_oom();

r = sd_journal_add_match(j, match1, 0);

if (r < 0)

return log_error_errno(r, "Failed to add match: %m");

}

get_parent:

if (sd_device_get_parent(d, &parent) < 0)

break;

d = parent;

}

r = add_match_this_boot(j, arg_machine);

if (r < 0)

return log_error_errno(r, "Failed to add match for the current boot: %m");

return 0;

}

static char *format_timestamp_maybe_utc(char *buf, size_t l, usec_t t) {

if (arg_utc)

return format_timestamp_style(buf, l, t, TIMESTAMP_UTC);

return format_timestamp(buf, l, t);

}

static int parse_boot_descriptor(const char *x, sd_id128_t *boot_id, int *offset) {

sd_id128_t id = SD_ID128_NULL;

int off = 0, r;

if (streq(x, "all")) {

*boot_id = SD_ID128_NULL;

*offset = 0;

return 0;

} else if (strlen(x) >= SD_ID128_STRING_MAX - 1) {

char *t;

t = strndupa_safe(x, SD_ID128_STRING_MAX - 1);

r = sd_id128_from_string(t, &id);

if (r >= 0)

x += SD_ID128_STRING_MAX - 1;

if (!IN_SET(*x, 0, '-', '+'))

return -EINVAL;

if (*x != 0) {

r = safe_atoi(x, &off);

if (r < 0)

return r;

}

} else {

r = safe_atoi(x, &off);

if (r < 0)

return r;

}

if (boot_id)

*boot_id = id;

if (offset)

*offset = off;

return 1;

}

static int help_facilities(void) {

if (!arg_quiet)

puts("Available facilities:");

for (int i = 0; i < LOG_NFACILITIES; i++) {

_cleanup_free_ char *t = NULL;

if (log_facility_unshifted_to_string_alloc(i, &t))

return log_oom();

puts(t);

}

return 0;

}

static int help(void) {

_cleanup_free_ char *link = NULL;

int r;

pager_open(arg_pager_flags);

r = terminal_urlify_man("journalctl", "1", &link);

if (r < 0)

return log_oom();

printf("%1$s [OPTIONS...] [MATCHES...]\n\n"

"%5$sQuery the journal.%6$s\n\n"

"%3$sOptions:%4$s\n"

" --system Show the system journal\n"

" --user Show the user journal for the current user\n"

" -M --machine=CONTAINER Operate on local container\n"

" -S --since=DATE Show entries not older than the specified date\n"

" -U --until=DATE Show entries not newer than the specified date\n"

" -c --cursor=CURSOR Show entries starting at the specified cursor\n"

" --after-cursor=CURSOR Show entries after the specified cursor\n"

" --show-cursor Print the cursor after all the entries\n"

" --cursor-file=FILE Show entries after cursor in FILE and update FILE\n"

" -b --boot[=ID] Show current boot or the specified boot\n"

" --list-boots Show terse information about recorded boots\n"

" -k --dmesg Show kernel message log from the current boot\n"

" -u --unit=UNIT Show logs from the specified unit\n"

" --user-unit=UNIT Show logs from the specified user unit\n"

" -t --identifier=STRING Show entries with the specified syslog identifier\n"

" -p --priority=RANGE Show entries with the specified priority\n"

" --facility=FACILITY... Show entries with the specified facilities\n"

" -g --grep=PATTERN Show entries with MESSAGE matching PATTERN\n"

" --case-sensitive[=BOOL] Force case sensitive or insensitive matching\n"

" -e --pager-end Immediately jump to the end in the pager\n"

" -f --follow Follow the journal\n"

" -n --lines[=INTEGER] Number of journal entries to show\n"

" --no-tail Show all lines, even in follow mode\n"

" -r --reverse Show the newest entries first\n"

" -o --output=STRING Change journal output mode (short, short-precise,\n"

" short-iso, short-iso-precise, short-full,\n"

" short-monotonic, short-unix, verbose, export,\n"

" json, json-pretty, json-sse, json-seq, cat,\n"

" with-unit)\n"

" --output-fields=LIST Select fields to print in verbose/export/json modes\n"

" --utc Express time in Coordinated Universal Time (UTC)\n"

" -x --catalog Add message explanations where available\n"

" --no-full Ellipsize fields\n"

" -a --all Show all fields, including long and unprintable\n"

" -q --quiet Do not show info messages and privilege warning\n"

" --no-pager Do not pipe output into a pager\n"

" --no-hostname Suppress output of hostname field\n"

" -m --merge Show entries from all available journals\n"

" -D --directory=PATH Show journal files from directory\n"

" --file=PATH Show journal file\n"

" --root=ROOT Operate on files below a root directory\n"

" --image=IMAGE Operate on files in filesystem image\n"

" --namespace=NAMESPACE Show journal data from specified namespace\n"

" --interval=TIME Time interval for changing the FSS sealing key\n"

" --verify-key=KEY Specify FSS verification key\n"

" --force Override of the FSS key pair with --setup-keys\n"

"\n%3$sCommands:%4$s\n"

" -h --help Show this help text\n"

" --version Show package version\n"

" -N --fields List all field names currently used\n"

" -F --field=FIELD List all values that a specified field takes\n"

" --disk-usage Show total disk usage of all journal files\n"

" --vacuum-size=BYTES Reduce disk usage below specified size\n"

" --vacuum-files=INT Leave only the specified number of journal files\n"

" --vacuum-time=TIME Remove journal files older than specified time\n"

" --verify Verify journal file consistency\n"

" --sync Synchronize unwritten journal messages to disk\n"

" --relinquish-var Stop logging to disk, log to temporary file system\n"

" --smart-relinquish-var Similar, but NOP if log directory is on root mount\n"

" --flush Flush all journal data from /run into /var\n"

" --rotate Request immediate rotation of the journal files\n"

" --header Show journal header information\n"

" --list-catalog Show all message IDs in the catalog\n"

" --dump-catalog Show entries in the message catalog\n"

" --update-catalog Update the message catalog database\n"

" --setup-keys Generate a new FSS key pair\n"

"\nSee the %2$s for details.\n",

program_invocation_short_name,

link,

ansi_underline(),

ansi_normal(),

ansi_highlight(),

ansi_normal());

return 0;

}

static int parse_argv(int argc, char *argv[]) {

enum {

ARG_VERSION = 0x100,

ARG_NO_PAGER,

ARG_NO_FULL,

ARG_NO_TAIL,

ARG_NEW_ID128,

ARG_THIS_BOOT,

ARG_LIST_BOOTS,

ARG_USER,

ARG_SYSTEM,

ARG_ROOT,

ARG_IMAGE,

ARG_HEADER,

ARG_FACILITY,

ARG_SETUP_KEYS,

ARG_FILE,

ARG_INTERVAL,

ARG_VERIFY,

ARG_VERIFY_KEY,

ARG_DISK_USAGE,

ARG_AFTER_CURSOR,

ARG_CURSOR_FILE,

ARG_SHOW_CURSOR,

ARG_USER_UNIT,

ARG_LIST_CATALOG,

ARG_DUMP_CATALOG,

ARG_UPDATE_CATALOG,

ARG_FORCE,

ARG_CASE_SENSITIVE,

ARG_UTC,

ARG_SYNC,

ARG_FLUSH,

ARG_RELINQUISH_VAR,

ARG_SMART_RELINQUISH_VAR,

ARG_ROTATE,

ARG_VACUUM_SIZE,

ARG_VACUUM_FILES,

ARG_VACUUM_TIME,

ARG_NO_HOSTNAME,

ARG_OUTPUT_FIELDS,

ARG_NAMESPACE,

};

static const struct option options[] = {

{ "help", no_argument, NULL, 'h' },

{ "version" , no_argument, NULL, ARG_VERSION },

{ "no-pager", no_argument, NULL, ARG_NO_PAGER },

{ "pager-end", no_argument, NULL, 'e' },

{ "follow", no_argument, NULL, 'f' },

{ "force", no_argument, NULL, ARG_FORCE },

{ "output", required_argument, NULL, 'o' },

{ "all", no_argument, NULL, 'a' },

{ "full", no_argument, NULL, 'l' },

{ "no-full", no_argument, NULL, ARG_NO_FULL },

{ "lines", optional_argument, NULL, 'n' },

{ "no-tail", no_argument, NULL, ARG_NO_TAIL },

{ "new-id128", no_argument, NULL, ARG_NEW_ID128 }, /* deprecated */

{ "quiet", no_argument, NULL, 'q' },

{ "merge", no_argument, NULL, 'm' },

{ "this-boot", no_argument, NULL, ARG_THIS_BOOT }, /* deprecated */

{ "boot", optional_argument, NULL, 'b' },

{ "list-boots", no_argument, NULL, ARG_LIST_BOOTS },

{ "dmesg", no_argument, NULL, 'k' },

{ "system", no_argument, NULL, ARG_SYSTEM },

{ "user", no_argument, NULL, ARG_USER },

{ "directory", required_argument, NULL, 'D' },

{ "file", required_argument, NULL, ARG_FILE },

{ "root", required_argument, NULL, ARG_ROOT },

{ "image", required_argument, NULL, ARG_IMAGE },

{ "header", no_argument, NULL, ARG_HEADER },

{ "identifier", required_argument, NULL, 't' },

{ "priority", required_argument, NULL, 'p' },

{ "facility", required_argument, NULL, ARG_FACILITY },

{ "grep", required_argument, NULL, 'g' },

{ "case-sensitive", optional_argument, NULL, ARG_CASE_SENSITIVE },

{ "setup-keys", no_argument, NULL, ARG_SETUP_KEYS },

{ "interval", required_argument, NULL, ARG_INTERVAL },

{ "verify", no_argument, NULL, ARG_VERIFY },

{ "verify-key", required_argument, NULL, ARG_VERIFY_KEY },

{ "disk-usage", no_argument, NULL, ARG_DISK_USAGE },

{ "cursor", required_argument, NULL, 'c' },

{ "cursor-file", required_argument, NULL, ARG_CURSOR_FILE },

{ "after-cursor", required_argument, NULL, ARG_AFTER_CURSOR },

{ "show-cursor", no_argument, NULL, ARG_SHOW_CURSOR },

{ "since", required_argument, NULL, 'S' },

{ "until", required_argument, NULL, 'U' },

{ "unit", required_argument, NULL, 'u' },

{ "user-unit", required_argument, NULL, ARG_USER_UNIT },

{ "field", required_argument, NULL, 'F' },

{ "fields", no_argument, NULL, 'N' },

{ "catalog", no_argument, NULL, 'x' },

{ "list-catalog", no_argument, NULL, ARG_LIST_CATALOG },

{ "dump-catalog", no_argument, NULL, ARG_DUMP_CATALOG },

{ "update-catalog", no_argument, NULL, ARG_UPDATE_CATALOG },

{ "reverse", no_argument, NULL, 'r' },

{ "machine", required_argument, NULL, 'M' },

{ "utc", no_argument, NULL, ARG_UTC },

{ "flush", no_argument, NULL, ARG_FLUSH },

{ "relinquish-var", no_argument, NULL, ARG_RELINQUISH_VAR },

{ "smart-relinquish-var", no_argument, NULL, ARG_SMART_RELINQUISH_VAR },

{ "sync", no_argument, NULL, ARG_SYNC },

{ "rotate", no_argument, NULL, ARG_ROTATE },

{ "vacuum-size", required_argument, NULL, ARG_VACUUM_SIZE },

{ "vacuum-files", required_argument, NULL, ARG_VACUUM_FILES },

{ "vacuum-time", required_argument, NULL, ARG_VACUUM_TIME },

{ "no-hostname", no_argument, NULL, ARG_NO_HOSTNAME },

{ "output-fields", required_argument, NULL, ARG_OUTPUT_FIELDS },

{ "namespace", required_argument, NULL, ARG_NAMESPACE },

{}

};

int c, r;

assert(argc >= 0);

assert(argv);

while ((c = getopt_long(argc, argv, "hefo:aln::qmb::kD:p:g:c:S:U:t:u:NF:xrM:", options, NULL)) >= 0)

switch (c) {

case 'h':

return help();

case ARG_VERSION:

return version();

case ARG_NO_PAGER:

arg_pager_flags |= PAGER_DISABLE;

break;

case 'e':

arg_pager_flags |= PAGER_JUMP_TO_END;

if (arg_lines == ARG_LINES_DEFAULT)

arg_lines = 1000;

arg_boot = true;

break;

case 'f':

arg_follow = true;

arg_boot = true;

arg_boot_id = SD_ID128_NULL;

arg_boot_offset = 0;

break;

case 'o':

if (streq(optarg, "help")) {

DUMP_STRING_TABLE(output_mode, OutputMode, _OUTPUT_MODE_MAX);

return 0;

}

arg_output = output_mode_from_string(optarg);

if (arg_output < 0)

return log_error_errno(arg_output, "Unknown output format '%s'.", optarg);

if (IN_SET(arg_output, OUTPUT_EXPORT, OUTPUT_JSON, OUTPUT_JSON_PRETTY, OUTPUT_JSON_SSE, OUTPUT_JSON_SEQ, OUTPUT_CAT))

arg_quiet = true;

if (OUTPUT_MODE_IS_JSON(arg_output))

arg_json_format_flags = output_mode_to_json_format_flags(arg_output) | JSON_FORMAT_COLOR_AUTO;

else

arg_json_format_flags = JSON_FORMAT_OFF;

break;

case 'l':

arg_full = true;

break;

case ARG_NO_FULL:

arg_full = false;

break;

case 'a':

arg_all = true;

break;

case 'n':

if (optarg) {

if (streq(optarg, "all"))

arg_lines = ARG_LINES_ALL;

else {

r = safe_atoi(optarg, &arg_lines);

if (r < 0 || arg_lines < 0)

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse lines '%s'", optarg);

}

} else {

arg_lines = 10;

/* Hmm, no argument? Maybe the next

if (optind < argc) {

int n;

if (streq(argv[optind], "all")) {

arg_lines = ARG_LINES_ALL;

optind++;

} else if (safe_atoi(argv[optind], &n) >= 0 && n >= 0) {

arg_lines = n;

optind++;

}

}

}

break;

case ARG_NO_TAIL:

arg_no_tail = true;

break;

case ARG_NEW_ID128:

arg_action = ACTION_NEW_ID128;

break;

case 'q':

arg_quiet = true;

break;

case 'm':

arg_merge = true;

break;

case ARG_THIS_BOOT:

arg_boot = true;

arg_boot_id = SD_ID128_NULL;

arg_boot_offset = 0;

break;

case 'b':

arg_boot = true;

arg_boot_id = SD_ID128_NULL;

arg_boot_offset = 0;

if (optarg) {

r = parse_boot_descriptor(optarg, &arg_boot_id, &arg_boot_offset);

if (r < 0)

return log_error_errno(r, "Failed to parse boot descriptor '%s'", optarg);

arg_boot = r;

/* Hmm, no argument? Maybe the next

} else if (optind < argc) {

r = parse_boot_descriptor(argv[optind], &arg_boot_id, &arg_boot_offset);

if (r >= 0) {

arg_boot = r;

optind++;

}

}

break;

case ARG_LIST_BOOTS:

arg_action = ACTION_LIST_BOOTS;

break;

case 'k':

arg_boot = arg_dmesg = true;

break;

case ARG_SYSTEM:

arg_journal_type |= SD_JOURNAL_SYSTEM;

break;

case ARG_USER:

arg_journal_type |= SD_JOURNAL_CURRENT_USER;

break;

case 'M':

arg_machine = optarg;

break;

case ARG_NAMESPACE:

if (streq(optarg, "*")) {

arg_namespace_flags = SD_JOURNAL_ALL_NAMESPACES;

arg_namespace = NULL;

} else if (startswith(optarg, "+")) {

arg_namespace_flags = SD_JOURNAL_INCLUDE_DEFAULT_NAMESPACE;

arg_namespace = optarg + 1;

} else if (isempty(optarg)) {

arg_namespace_flags = 0;

arg_namespace = NULL;

} else {

arg_namespace_flags = 0;

arg_namespace = optarg;

}

break;

case 'D':

arg_directory = optarg;

break;

case ARG_FILE:

if (streq(optarg, "-"))

/* An undocumented feature: we can read journal files from STDIN. We don't document

arg_file_stdin = true;

else {

r = glob_extend(&arg_file, optarg, GLOB_NOCHECK);

if (r < 0)

return log_error_errno(r, "Failed to add paths: %m");

}

break;

case ARG_ROOT:

r = parse_path_argument(optarg, /* suppress_root= */ true, &arg_root);

if (r < 0)

return r;

break;

case ARG_IMAGE:

r = parse_path_argument(optarg, /* suppress_root= */ false, &arg_image);

if (r < 0)

return r;

break;

case 'c':

arg_cursor = optarg;

break;

case ARG_CURSOR_FILE:

arg_cursor_file = optarg;

break;

case ARG_AFTER_CURSOR:

arg_after_cursor = optarg;

break;

case ARG_SHOW_CURSOR:

arg_show_cursor = true;

break;

case ARG_HEADER:

arg_action = ACTION_PRINT_HEADER;

break;

case ARG_VERIFY:

arg_action = ACTION_VERIFY;

break;

case ARG_DISK_USAGE:

arg_action = ACTION_DISK_USAGE;

break;

case ARG_VACUUM_SIZE:

r = parse_size(optarg, 1024, &arg_vacuum_size);

if (r < 0)

return log_error_errno(r, "Failed to parse vacuum size: %s", optarg);

arg_action = arg_action == ACTION_ROTATE ? ACTION_ROTATE_AND_VACUUM : ACTION_VACUUM;

break;

case ARG_VACUUM_FILES:

r = safe_atou64(optarg, &arg_vacuum_n_files);

if (r < 0)

return log_error_errno(r, "Failed to parse vacuum files: %s", optarg);

arg_action = arg_action == ACTION_ROTATE ? ACTION_ROTATE_AND_VACUUM : ACTION_VACUUM;

break;

case ARG_VACUUM_TIME:

r = parse_sec(optarg, &arg_vacuum_time);

if (r < 0)

return log_error_errno(r, "Failed to parse vacuum time: %s", optarg);

arg_action = arg_action == ACTION_ROTATE ? ACTION_ROTATE_AND_VACUUM : ACTION_VACUUM;

break;

#if HAVE_GCRYPT

case ARG_FORCE:

arg_force = true;

break;

case ARG_SETUP_KEYS:

arg_action = ACTION_SETUP_KEYS;

break;

case ARG_VERIFY_KEY:

r = free_and_strdup(&arg_verify_key, optarg);

if (r < 0)

return r;

/* Use memset not explicit_bzero() or similar so this doesn't look confusing

memset(optarg, 'x', strlen(optarg));

arg_action = ACTION_VERIFY;

arg_merge = false;

break;

case ARG_INTERVAL:

r = parse_sec(optarg, &arg_interval);

if (r < 0 || arg_interval <= 0)

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"Failed to parse sealing key change interval: %s", optarg);

break;

case ARG_SETUP_KEYS:

case ARG_VERIFY_KEY:

case ARG_INTERVAL:

case ARG_FORCE:

return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),

"Compiled without forward-secure sealing support.");

case 'p': {

const char *dots;

dots = strstr(optarg, "..");

if (dots) {

_cleanup_free_ char *a = NULL;

int from, to, i;

/* a range */

a = strndup(optarg, dots - optarg);

if (!a)

return log_oom();

from = log_level_from_string(a);

to = log_level_from_string(dots + 2);

if (from < 0 || to < 0)

return log_error_errno(from < 0 ? from : to,

"Failed to parse log level range %s", optarg);

arg_priorities = 0;

if (from < to) {

for (i = from; i <= to; i++)

arg_priorities |= 1 << i;

} else {

for (i = to; i <= from; i++)

arg_priorities |= 1 << i;

}

} else {

int p, i;

p = log_level_from_string(optarg);

if (p < 0)

return log_error_errno(p, "Unknown log level %s", optarg);

arg_priorities = 0;

for (i = 0; i <= p; i++)

arg_priorities |= 1 << i;

}

break;

}

case ARG_FACILITY: {

const char *p;

for (p = optarg;;) {

_cleanup_free_ char *fac = NULL;

int num;

r = extract_first_word(&p, &fac, ",", 0);

if (r < 0)

return log_error_errno(r, "Failed to parse facilities: %s", optarg);

if (r == 0)

break;

if (streq(fac, "help")) {

help_facilities();

return 0;

}

num = log_facility_unshifted_from_string(fac);

if (num < 0)

return log_error_errno(num, "Bad --facility= argument \"%s\".", fac);

if (set_ensure_put(&arg_facilities, NULL, INT_TO_PTR(num)) < 0)

return log_oom();

}

break;

}

#if HAVE_PCRE2

case 'g':

arg_pattern = optarg;

break;

case ARG_CASE_SENSITIVE:

if (optarg) {

r = parse_boolean(optarg);

if (r < 0)

return log_error_errno(r, "Bad --case-sensitive= argument \"%s\": %m", optarg);

arg_case_sensitive = r;

} else

arg_case_sensitive = true;

break;

case 'g':

case ARG_CASE_SENSITIVE:

return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Compiled without pattern matching support");

case 'S':

r = parse_timestamp(optarg, &arg_since);

if (r < 0)

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"Failed to parse timestamp: %s", optarg);

arg_since_set = true;

break;

case 'U':

r = parse_timestamp(optarg, &arg_until);

if (r < 0)

return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

"Failed to parse timestamp: %s", optarg);

arg_until_set = true;

break;

case 't':

r = strv_extend(&arg_syslog_identifier, optarg);

if (r < 0)

return log_oom();

break;

case 'u':

r = strv_extend(&arg_system_units, optarg);

if (r < 0)

return log_oom();

break;

case ARG_USER_UNIT:

r = strv_extend(&arg_user_units, optarg);

if (r < 0)

return log_oom();

break;

case 'F':

arg_action = ACTION_LIST_FIELDS;

arg_field = optarg;

break;

case 'N':

arg_action = ACTION_LIST_FIELD_NAMES;

break;

case ARG_NO_HOSTNAME:

arg_no_hostname = true;

break;

case 'x':

arg_catalog = true;

break;

case ARG_LIST_CATALOG:

arg_action = ACTION_LIST_CATALOG;

break;

case ARG_DUMP_CATALOG:

arg_action = ACTION_DUMP_CATALOG;

break;

case ARG_UPDATE_CATALOG:

arg_action = ACTION_UPDATE_CATALOG;

break;

case 'r':

arg_reverse = true;

break;

case ARG_UTC:

arg_utc = true;

break;