HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/logs-show.c

87,278 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 513d76558e31319a9b649382f7cde8d9726f9564

Lines 1–1000 of 2,347

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <signal.h>
#include <syslog.h>
#include <unistd.h>
 
#include "sd-id128.h"
#include "sd-journal.h"
#include "sd-json.h"
#include "sd-messages.h"
 
#include "alloc-util.h"
#include "format-util.h"
#include "glyph-util.h"
#include "hashmap.h"
#include "id128-util.h"
#include "journal-internal.h"
#include "journal-util.h"
#include "locale-util.h"
#include "log.h"
#include "logs-show.h"
#include "output-mode.h"
#include "parse-util.h"
#include "pretty-print.h"
#include "rlimit-util.h"
#include "set.h"
#include "sigbus.h"
#include "sparse-endian.h"
#include "stdio-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
#include "time-util.h"
#include "user-util.h"
#include "utf8.h"
#include "web-util.h"
 
/* up to three lines (each up to 100 characters) or 300 characters, whichever is less */
#define PRINT_LINE_THRESHOLD 3
#define PRINT_CHAR_THRESHOLD 300
 
#define JSON_THRESHOLD 4096U
 
static int print_catalog(FILE *f, sd_journal *j) {
        _cleanup_free_ char *t = NULL, *z = NULL;
        const char *newline, *prefix;
        int r;
 
        assert(j);
 
        r = sd_journal_get_catalog(j, &t);
        if (r == -ENOENT)
                return 0;
        if (r < 0)
                return log_error_errno(r, "Failed to find catalog entry: %m");
 
        if (is_locale_utf8())
                prefix = strjoina(glyph(GLYPH_LIGHT_SHADE), glyph(GLYPH_LIGHT_SHADE));
        else
                prefix = "--";
 
        newline = strjoina(ansi_normal(), "\n", ansi_grey(), prefix, ansi_normal(), " ", ansi_green());
 
        z = strreplace(strstrip(t), "\n", newline);
        if (!z)
                return log_oom();
 
        fprintf(f, "%s%s %s%s", ansi_grey(), prefix, ansi_normal(), ansi_green());
        fputs(z, f);
        fprintf(f, "%s\n", ansi_normal());
 
        return 1;
}
 
static int url_from_catalog(sd_journal *j, char **ret) {
        _cleanup_free_ char *t = NULL, *url = NULL;
        const char *weblink;
        int r;
 
        assert(j);
        assert(ret);
 
        r = sd_journal_get_catalog(j, &t);
        if (r == -ENOENT)
                goto notfound;
        if (r < 0)
                return log_error_errno(r, "Failed to find catalog entry: %m");
 
        weblink = find_line_startswith(t, "Documentation:");
        if (!weblink)
                goto notfound;
 
        /* Skip whitespace to value */
        weblink += strspn(weblink, " \t");
 
        /* Cut out till next whitespace/newline */
        url = strdupcspn(weblink, WHITESPACE);
        if (!url)
                return log_oom();
 
        if (!documentation_url_is_valid(url))
                goto notfound;
 
        *ret = TAKE_PTR(url);
        return 1;
 
notfound:
        *ret = NULL;
        return 0;
}
 
static int parse_field(
                const void *data,
                size_t length,
                const char *field,
                size_t field_len,
                char **target,
                size_t *target_len) {
 
        size_t nl;
        char *buf;
 
        assert(data);
        assert(field);
        assert(target);
 
        if (length < field_len)
                return 0;
 
        if (memcmp(data, field, field_len) != 0)
                return 0;
 
        nl = length - field_len;
 
        buf = newdup_suffix0(char, (const char*) data + field_len, nl);
        if (!buf)
                return log_oom();
 
        free_and_replace(*target, buf);
 
        if (target_len)
                *target_len = nl;
 
        return 1;
}
 
typedef struct ParseFieldVec {
        const char *field;
        size_t field_len;
        char **target;
        size_t *target_len;
} ParseFieldVec;
 
#define PARSE_FIELD_VEC_ENTRY(_field, _target, _target_len) {           \
                .field = _field,                                        \
                .field_len = strlen(_field),                            \
                .target = _target,                                      \
                .target_len = _target_len                               \
        }
 
static int parse_fieldv(
                const void *data,
                size_t length,
                const ParseFieldVec *fields,
                size_t n_fields) {
 
        int r;
 
        for (size_t i = 0; i < n_fields; i++) {
                const ParseFieldVec *f = &fields[i];
 
                r = parse_field(data, length, f->field, f->field_len, f->target, f->target_len);
                if (r < 0)
                        return r;
                if (r > 0)
                        break;
        }
 
        return 0;
}
 
static int field_set_test(const Set *fields, const char *name, size_t n) {
        char *s;
 
        if (!fields)
                return 1;
 
        s = strndupa_safe(name, n);
        return set_contains(fields, s);
}
 
static bool shall_print(const char *p, size_t l, OutputFlags flags) {
        assert(p);
 
        if (flags & OUTPUT_SHOW_ALL)
                return true;
 
        if (l >= PRINT_CHAR_THRESHOLD)
                return false;
 
        if (!utf8_is_printable(p, l))
                return false;
 
        return true;
}
 
static bool print_multiline(
                FILE *f,
                unsigned prefix,
                unsigned n_columns,
                OutputFlags flags,
                int priority,
                bool audit,
                const char* message,
                size_t message_len,
                size_t highlight[2]) {
 
        const char *color_on = "", *color_off = "", *highlight_on = "";
        const char *pos, *end;
        bool ellipsized = false;
        int line = 0;
 
        if (flags & OUTPUT_COLOR) {
                get_log_colors(priority, &color_on, &color_off, &highlight_on);
 
                if (audit && strempty(color_on)) {
                        color_on = ansi_blue();
                        color_off = ansi_normal();
                }
        }
 
        /* A special case: make sure that we print a newline when
           the message is empty. */
        if (message_len == 0)
                fputs("\n", f);
 
        for (pos = message;
             pos < message + message_len;
             pos = end + 1, line++) {
                bool tail_line;
                int len, indent = (line > 0) * prefix;
                for (end = pos; end < message + message_len && *end != '\n'; end++)
                        ;
                len = end - pos;
                assert(len >= 0);
 
                /* We need to figure out when we are showing not-last line, *and*
                 * will skip subsequent lines. In that case, we will put the dots
                 * at the end of the line, instead of putting dots in the middle
                 * or not at all.
                 */
                tail_line =
                        line + 1 == PRINT_LINE_THRESHOLD ||
                        end + 1 >= message + PRINT_CHAR_THRESHOLD;
 
                if (flags & (OUTPUT_FULL_WIDTH | OUTPUT_SHOW_ALL) ||
                    (prefix + len + 1 < n_columns && !tail_line)) {
                        if (highlight &&
                            (size_t) (pos - message) <= highlight[0] &&
                            highlight[0] < (size_t) len) {
 
                                fprintf(f, "%*s%s%.*s",
                                        indent, "",
                                        color_on, (int) highlight[0], pos);
                                fprintf(f, "%s%.*s",
                                        highlight_on,
                                        (int) (MIN((size_t) len, highlight[1]) - highlight[0]),
                                        pos + highlight[0]);
                                if ((size_t) len > highlight[1])
                                        fprintf(f, "%s%.*s",
                                                color_on,
                                                (int) (len - highlight[1]),
                                                pos + highlight[1]);
                                fprintf(f, "%s\n", color_off);
 
                        } else
                                fprintf(f, "%*s%s%.*s%s\n",
                                        indent, "",
                                        color_on, len, pos, color_off);
                        continue;
                }
 
                /* Beyond this point, ellipsization will happen. */
                ellipsized = true;
 
                if (prefix < n_columns && n_columns - prefix >= 3) {
                        if (n_columns - prefix > (unsigned) len + 3)
                                fprintf(f, "%*s%s%.*s...%s\n",
                                        indent, "",
                                        color_on, len, pos, color_off);
                        else {
                                _cleanup_free_ char *e = NULL;
 
                                e = ellipsize_mem(pos, len, n_columns - prefix,
                                                  tail_line ? 100 : 90);
                                if (!e)
                                        fprintf(f, "%*s%s%.*s%s\n",
                                                indent, "",
                                                color_on, len, pos, color_off);
                                else
                                        fprintf(f, "%*s%s%s%s\n",
                                                indent, "",
                                                color_on, e, color_off);
                        }
                } else
                        fputs("...\n", f);
 
                if (tail_line)
                        break;
        }
 
        return ellipsized;
}
 
static int output_timestamp_monotonic(
                FILE *f,
                OutputMode mode,
                const dual_timestamp *display_ts,
                const sd_id128_t *boot_id,
                const dual_timestamp *previous_display_ts,
                const sd_id128_t *previous_boot_id) {
 
        int written_chars = 0;
 
        assert(f);
        assert(display_ts);
        assert(boot_id);
        assert(previous_display_ts);
        assert(previous_boot_id);
 
        if (!VALID_MONOTONIC(display_ts->monotonic))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "No valid monotonic timestamp available, skipping showing journal entry.");
 
        written_chars += fprintf(f, "[%5"PRI_USEC".%06"PRI_USEC, display_ts->monotonic / USEC_PER_SEC, display_ts->monotonic % USEC_PER_SEC);
 
        if (mode == OUTPUT_SHORT_DELTA) {
                uint64_t delta;
                bool reliable_ts = true;
 
                if (VALID_MONOTONIC(previous_display_ts->monotonic) && sd_id128_equal(*boot_id, *previous_boot_id))
                        delta = usec_sub_unsigned(display_ts->monotonic, previous_display_ts->monotonic);
                else if (VALID_REALTIME(display_ts->realtime) && VALID_REALTIME(previous_display_ts->realtime)) {
                        delta = usec_sub_unsigned(display_ts->realtime, previous_display_ts->realtime);
                        reliable_ts = false;
                } else {
                        written_chars += fprintf(f, "%16s", "");
                        goto finish;
                }
 
                written_chars += fprintf(f, " <%5"PRI_USEC".%06"PRI_USEC"%s>", delta / USEC_PER_SEC, delta % USEC_PER_SEC, reliable_ts ? " " : "*");
        }
 
finish:
        written_chars += fprintf(f, "%s", "]");
        return written_chars;
}
 
static int output_timestamp_realtime(
                FILE *f,
                OutputMode mode,
                OutputFlags flags,
                usec_t usec) {
 
        char buf[CONST_MAX(FORMAT_TIMESTAMP_MAX, 64U)];
        int r;
 
        assert(f);
 
        if (!VALID_REALTIME(usec))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "No valid realtime timestamp available, skipping showing journal entry.");
 
        switch (mode) {
 
        case OUTPUT_SHORT_FULL:
        case OUTPUT_WITH_UNIT: {
                if (!format_timestamp_style(buf, sizeof(buf), usec, flags & OUTPUT_UTC ? TIMESTAMP_UTC : TIMESTAMP_PRETTY))
                        return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to format timestamp (%"PRIu64"), skipping showing journal entry.", usec);
                break;
        }
 
        case OUTPUT_SHORT_UNIX:
                xsprintf(buf, "%10" PRI_USEC ".%06" PRI_USEC, usec / USEC_PER_SEC, usec % USEC_PER_SEC);
                break;
 
        case OUTPUT_SHORT:
        case OUTPUT_SHORT_PRECISE:
        case OUTPUT_SHORT_ISO:
        case OUTPUT_SHORT_ISO_PRECISE: {
                struct tm tm;
                size_t tail = 0;
 
                r = localtime_or_gmtime_usec(usec, flags & OUTPUT_UTC, &tm);
                if (r < 0)
                        log_debug_errno(r, "Failed to convert timestamp to calendar time, generating fallback timestamp: %m");
                else {
                        tail = strftime(
                                        buf, sizeof(buf),
                                        IN_SET(mode, OUTPUT_SHORT_ISO, OUTPUT_SHORT_ISO_PRECISE) ? "%Y-%m-%dT%H:%M:%S" : "%b %d %H:%M:%S",
                                        &tm);
                        if (tail <= 0)
                                log_debug("Failed to format calendar time, generating fallback timestamp.");
                }
 
                if (tail <= 0) {
                        /* Generate fallback timestamp if regular formatting didn't work. (This might happen on systems where time_t is 32bit) */
 
                        static const char *const xxx[_OUTPUT_MODE_MAX] = {
                                [OUTPUT_SHORT]             = "XXX XX XX:XX:XX",
                                [OUTPUT_SHORT_PRECISE]     = "XXX XX XX:XX:XX.XXXXXX",
                                [OUTPUT_SHORT_ISO]         = "XXXX-XX-XXTXX:XX:XX+XX:XX",
                                [OUTPUT_SHORT_ISO_PRECISE] = "XXXX-XX-XXTXX:XX:XX.XXXXXX+XX:XX",
                        };
 
                        fputs(xxx[mode], f);
                        return strlen(xxx[mode]);
                }
 
                assert(tail <= sizeof(buf));
 
                /* No usec in strftime, need to append */
                if (IN_SET(mode, OUTPUT_SHORT_ISO_PRECISE, OUTPUT_SHORT_PRECISE)) {
                        assert_se(snprintf_ok(buf + tail, sizeof(buf) - tail, ".%06" PRI_USEC, usec % USEC_PER_SEC));
 
                        tail += 7;
 
                        assert(tail <= sizeof(buf));
                }
 
                if (IN_SET(mode, OUTPUT_SHORT_ISO, OUTPUT_SHORT_ISO_PRECISE)) {
                        int h = tm.tm_gmtoff / 60 / 60,
                                m = ABS((int) ((tm.tm_gmtoff / 60) % 60));
 
                        assert_se(snprintf_ok(buf + tail, sizeof(buf) - tail, "%+03d:%02d", h, m));
                }
 
                break;
        }
 
        default:
                assert_not_reached();
        }
 
        fputs(buf, f);
        return (int) strlen(buf);
}
 
static void parse_display_realtime(
                sd_journal *j,
                const char *source_realtime,
                const char *source_monotonic,
                usec_t *ret) {
 
        usec_t t;
 
        assert(j);
        assert(ret);
 
        /* First, try _SOURCE_REALTIME_TIMESTAMP. */
        if (source_realtime && safe_atou64(source_realtime, &t) >= 0 && VALID_REALTIME(t)) {
                *ret = t;
                return;
        }
 
        /* Read realtime timestamp in the entry header. */
        if (sd_journal_get_realtime_usec(j, &t) < 0) {
                *ret = USEC_INFINITY;
                return;
        }
 
        /* If _SOURCE_MONOTONIC_TIMESTAMP is provided, adjust the header timestamp. */
        // FIXME: _SOURCE_MONOTONIC_TIMESTAMP is in CLOCK_BOOTTIME, hence we cannot use it for adjusting realtime.
        /*
        usec_t s, u;
        if (source_monotonic && safe_atou64(source_monotonic, &s) >= 0 && VALID_MONOTONIC(s) &&
            sd_journal_get_monotonic_usec(j, &u, &(sd_id128_t) {}) >= 0) {
                *ret = map_clock_usec_raw(t, u, s);
                return;
        }
        */
 
        /* Otherwise, use the header timestamp as is. */
        *ret = t;
}
 
static void parse_display_timestamp(
                sd_journal *j,
                const char *source_realtime,
                const char *source_monotonic,
                dual_timestamp *ret_display_ts,
                sd_id128_t *ret_boot_id) {
 
        dual_timestamp header_ts = DUAL_TIMESTAMP_INFINITY, source_ts = DUAL_TIMESTAMP_INFINITY;
        sd_id128_t boot_id = SD_ID128_NULL;
        usec_t t;
 
        assert(j);
        assert(ret_display_ts);
        assert(ret_boot_id);
 
        if (source_realtime && safe_atou64(source_realtime, &t) >= 0 && VALID_REALTIME(t))
                source_ts.realtime = t;
 
        // FIXME: _SOURCE_MONOTONIC_TIMESTAMP is in CLOCK_BOOTTIME, hence we cannot use it for adjusting realtime.
        /*
        if (source_monotonic && safe_atou64(source_monotonic, &t) >= 0 && VALID_MONOTONIC(t))
                source_ts.monotonic = t;
        */
 
        (void) sd_journal_get_realtime_usec(j, &header_ts.realtime);
        (void) sd_journal_get_monotonic_usec(j, &header_ts.monotonic, &boot_id);
 
        /* Adjust timestamp if possible. */
        if (header_ts.realtime != USEC_INFINITY && header_ts.monotonic != USEC_INFINITY) {
                if (source_ts.realtime == USEC_INFINITY && source_ts.monotonic != USEC_INFINITY)
                        source_ts.realtime = map_clock_usec_raw(header_ts.realtime, header_ts.monotonic, source_ts.monotonic);
                else if (source_ts.realtime != USEC_INFINITY && source_ts.monotonic == USEC_INFINITY)
                        source_ts.monotonic = map_clock_usec_raw(header_ts.monotonic, header_ts.realtime, source_ts.realtime);
        }
 
        ret_display_ts->realtime = source_ts.realtime != USEC_INFINITY ? source_ts.realtime : header_ts.realtime;
        ret_display_ts->monotonic = source_ts.monotonic != USEC_INFINITY ? source_ts.monotonic : header_ts.monotonic;
        *ret_boot_id = boot_id;
}
 
static int output_short(
                FILE *f,
                sd_journal *j,
                OutputMode mode,
                unsigned n_columns,
                OutputFlags flags,
                const Set *output_fields,
                const size_t highlight[2],
                dual_timestamp *previous_display_ts, /* in and out, used only when mode is OUTPUT_SHORT_MONOTONIC, OUTPUT_SHORT_DELTA. */
                sd_id128_t *previous_boot_id) {      /* in and out, used only when mode is OUTPUT_SHORT_MONOTONIC, OUTPUT_SHORT_DELTA. */
 
        int r;
        const void *data;
        size_t length, n = 0;
        _cleanup_free_ char *hostname = NULL, *identifier = NULL, *comm = NULL, *pid = NULL, *fake_pid = NULL,
                *message = NULL, *priority = NULL, *transport = NULL,
                *config_file = NULL, *unit = NULL, *user_unit = NULL, *documentation_url = NULL,
                *realtime = NULL, *monotonic = NULL;
        size_t hostname_len = 0, identifier_len = 0, comm_len = 0, pid_len = 0, fake_pid_len = 0, message_len = 0,
                priority_len = 0, transport_len = 0, config_file_len = 0,
                unit_len = 0, user_unit_len = 0, documentation_url_len = 0;
        dual_timestamp display_ts;
        sd_id128_t boot_id;
        int p = LOG_INFO;
        bool ellipsized = false, audit;
        const ParseFieldVec fields[] = {
                PARSE_FIELD_VEC_ENTRY("_PID=",                        &pid,               &pid_len              ),
                PARSE_FIELD_VEC_ENTRY("_COMM=",                       &comm,              &comm_len             ),
                PARSE_FIELD_VEC_ENTRY("MESSAGE=",                     &message,           &message_len          ),
                PARSE_FIELD_VEC_ENTRY("PRIORITY=",                    &priority,          &priority_len         ),
                PARSE_FIELD_VEC_ENTRY("_TRANSPORT=",                  &transport,         &transport_len        ),
                PARSE_FIELD_VEC_ENTRY("_HOSTNAME=",                   &hostname,          &hostname_len         ),
                PARSE_FIELD_VEC_ENTRY("SYSLOG_PID=",                  &fake_pid,          &fake_pid_len         ),
                PARSE_FIELD_VEC_ENTRY("SYSLOG_IDENTIFIER=",           &identifier,        &identifier_len       ),
                PARSE_FIELD_VEC_ENTRY("CONFIG_FILE=",                 &config_file,       &config_file_len      ),
                PARSE_FIELD_VEC_ENTRY("_SYSTEMD_UNIT=",               &unit,              &unit_len             ),
                PARSE_FIELD_VEC_ENTRY("_SYSTEMD_USER_UNIT=",          &user_unit,         &user_unit_len        ),
                PARSE_FIELD_VEC_ENTRY("DOCUMENTATION=",               &documentation_url, &documentation_url_len),
                PARSE_FIELD_VEC_ENTRY("_SOURCE_REALTIME_TIMESTAMP=",  &realtime,          NULL                  ),
                PARSE_FIELD_VEC_ENTRY("_SOURCE_MONOTONIC_TIMESTAMP=", &monotonic,         NULL                  ),
        };
        size_t highlight_shifted[] = {highlight ? highlight[0] : 0, highlight ? highlight[1] : 0};
 
        assert(f);
        assert(j);
        assert(previous_display_ts);
        assert(previous_boot_id);
 
        /* Set the threshold to one bigger than the actual print threshold, so that if the line is actually
         * longer than what we're willing to print, ellipsization will occur. This way we won't output a
         * misleading line without any indication of truncation.
         */
        (void) sd_journal_set_data_threshold(j, flags & (OUTPUT_SHOW_ALL|OUTPUT_FULL_WIDTH) ? 0 : PRINT_CHAR_THRESHOLD + 1);
 
        JOURNAL_FOREACH_DATA_RETVAL(j, data, length, r) {
                r = parse_fieldv(data, length, fields, ELEMENTSOF(fields));
                if (r < 0)
                        return r;
        }
        if (IN_SET(r, -EBADMSG, -EADDRNOTAVAIL)) {
                log_debug_errno(r, "Skipping message we can't read: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to get journal fields: %m");
 
        if (!message) {
                log_debug("Skipping message without MESSAGE= field.");
                return 0;
        }
 
        if (identifier && set_contains(j->exclude_syslog_identifiers, identifier))
                return 0;
 
        if (!(flags & OUTPUT_SHOW_ALL))
                strip_tab_ansi(&message, &message_len, highlight_shifted);
 
        if (flags & OUTPUT_TRUNCATE_NEWLINE)
                truncate_nl_full(message, &message_len);
 
        if (priority_len == 1 && *priority >= '0' && *priority <= '7')
                p = *priority - '0';
 
        audit = streq_ptr(transport, "audit");
 
        if (IN_SET(mode, OUTPUT_SHORT_MONOTONIC, OUTPUT_SHORT_DELTA)) {
                parse_display_timestamp(j, realtime, monotonic, &display_ts, &boot_id);
                r = output_timestamp_monotonic(f, mode, &display_ts, &boot_id, previous_display_ts, previous_boot_id);
        } else {
                usec_t usec;
                parse_display_realtime(j, realtime, monotonic, &usec);
                r = output_timestamp_realtime(f, mode, flags, usec);
        }
        if (r == -EINVAL)
                return 0;
        if (r < 0)
                return r;
        n += r;
 
        if (flags & OUTPUT_NO_HOSTNAME) {
                /* Suppress display of the hostname if this is requested. */
                hostname = mfree(hostname);
                hostname_len = 0;
        }
 
        if (hostname && shall_print(hostname, hostname_len, flags)) {
                fprintf(f, " %.*s", (int) hostname_len, hostname);
                n += hostname_len + 1;
        }
 
        if (mode == OUTPUT_WITH_UNIT && ((unit && shall_print(unit, unit_len, flags)) ||
                                         (user_unit && shall_print(user_unit, user_unit_len, flags)))) {
                if (unit) {
                        fprintf(f, " %.*s", (int) unit_len, unit);
                        n += unit_len + 1;
                }
                if (user_unit) {
                        if (unit)
                                fprintf(f, "/%.*s", (int) user_unit_len, user_unit);
                        else
                                fprintf(f, " %.*s", (int) user_unit_len, user_unit);
                        n += unit_len + 1;
                }
        } else if (identifier && shall_print(identifier, identifier_len, flags)) {
                fprintf(f, " %.*s", (int) identifier_len, identifier);
                n += identifier_len + 1;
        } else if (comm && shall_print(comm, comm_len, flags)) {
                fprintf(f, " %.*s", (int) comm_len, comm);
                n += comm_len + 1;
        } else
                fputs(" unknown", f);
 
        if (pid && shall_print(pid, pid_len, flags)) {
                fprintf(f, "[%.*s]", (int) pid_len, pid);
                n += pid_len + 2;
        } else if (fake_pid && shall_print(fake_pid, fake_pid_len, flags)) {
                fprintf(f, "[%.*s]", (int) fake_pid_len, fake_pid);
                n += fake_pid_len + 2;
        }
 
        fputs(": ", f);
 
        if (urlify_enabled()) {
                _cleanup_free_ char *c = NULL;
 
                /* Insert a hyperlink to a documentation URL before the message. Note that we don't make the
                 * whole message a hyperlink, since otherwise the whole screen might end up being just
                 * hyperlinks. Moreover, we want to be able to highlight parts of the message (such as the
                 * config file, see below) hence let's keep the documentation URL link separate. */
 
                if (documentation_url && shall_print(documentation_url, documentation_url_len, flags)) {
                        c = strndup(documentation_url, documentation_url_len);
                        if (!c)
                                return log_oom();
 
                        if (!documentation_url_is_valid(c)) /* Eat up invalid links */
                                c = mfree(c);
                }
 
                if (!c)
                        (void) url_from_catalog(j, &c); /* Acquire from catalog if not embedded in log message itself */
 
                if (c) {
                        _cleanup_free_ char *urlified = NULL;
 
                        if (terminal_urlify(c, glyph(GLYPH_EXTERNAL_LINK), &urlified) >= 0) {
                                fputs(urlified, f);
                                fputc(' ', f);
                        }
                }
        }
 
        if (!(flags & OUTPUT_SHOW_ALL) && !utf8_is_printable(message, message_len))
                fprintf(f, "[%s blob data]\n", FORMAT_BYTES(message_len));
        else {
 
                /* URLify config_file string in message, if the message starts with it.
                 * Skip URLification if the highlighted pattern overlaps. */
                if (config_file &&
                    message_len >= config_file_len &&
                    memcmp(message, config_file, config_file_len) == 0 &&
                    (message_len == config_file_len || IN_SET(message[config_file_len], ':', ' ')) &&
                    (!highlight || highlight_shifted[0] == 0 || highlight_shifted[0] > config_file_len)) {
 
                        _cleanup_free_ char *t = NULL, *urlified = NULL;
 
                        t = strndup(config_file, config_file_len);
                        if (t && terminal_urlify_path(t, NULL, &urlified) >= 0) {
                                size_t urlified_len = strlen(urlified);
                                size_t shift = urlified_len - config_file_len;
                                char *joined;
 
                                joined = realloc(urlified, message_len + shift);
                                if (joined) {
                                        memcpy(joined + urlified_len, message + config_file_len, message_len - config_file_len);
                                        free_and_replace(message, joined);
                                        TAKE_PTR(urlified);
                                        message_len += shift;
                                        if (highlight) {
                                                highlight_shifted[0] += shift;
                                                highlight_shifted[1] += shift;
                                        }
                                }
                        }
                }
 
                ellipsized |=
                        print_multiline(f, n + 2, n_columns, flags, p, audit,
                                        message, message_len,
                                        highlight_shifted);
        }
 
        if (flags & OUTPUT_CATALOG)
                (void) print_catalog(f, j);
 
        if (IN_SET(mode, OUTPUT_SHORT_MONOTONIC, OUTPUT_SHORT_DELTA)) {
                *previous_display_ts = display_ts;
                *previous_boot_id = boot_id;
        }
 
        return ellipsized;
}
 
static int get_display_realtime(sd_journal *j, usec_t *ret) {
        const void *data;
        _cleanup_free_ char *realtime = NULL, *monotonic = NULL;
        size_t length;
        const ParseFieldVec message_fields[] = {
                PARSE_FIELD_VEC_ENTRY("_SOURCE_REALTIME_TIMESTAMP=",  &realtime,  NULL),
                PARSE_FIELD_VEC_ENTRY("_SOURCE_MONOTONIC_TIMESTAMP=", &monotonic, NULL),
        };
        int r;
 
        assert(j);
        assert(ret);
 
        JOURNAL_FOREACH_DATA_RETVAL(j, data, length, r) {
                r = parse_fieldv(data, length, message_fields, ELEMENTSOF(message_fields));
                if (r < 0)
                        return r;
 
                if (realtime && monotonic)
                        break;
        }
        if (r < 0)
                return r;
 
        parse_display_realtime(j, realtime, monotonic, ret);
 
        /* Restart all data before */
        sd_journal_restart_data(j);
        sd_journal_restart_unique(j);
        sd_journal_restart_fields(j);
 
        return 0;
}
 
static int output_verbose(
                FILE *f,
                sd_journal *j,
                OutputMode mode,
                unsigned n_columns,
                OutputFlags flags,
                const Set *output_fields,
                const size_t highlight[2],
                dual_timestamp *previous_display_ts, /* unused */
                sd_id128_t *previous_boot_id) {      /* unused */
 
        const void *data;
        size_t length;
        _cleanup_free_ char *cursor = NULL;
        char buf[FORMAT_TIMESTAMP_MAX + 7];
        const char *timestamp;
        usec_t usec;
        int r;
 
        assert(f);
        assert(j);
 
        (void) sd_journal_set_data_threshold(j, 0);
 
        r = get_display_realtime(j, &usec);
        if (IN_SET(r, -EBADMSG, -EADDRNOTAVAIL)) {
                log_debug_errno(r, "Unable to read realtime timestamp from entry, assuming bad or partially written entry: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to get journal fields: %m");
 
        if (!VALID_REALTIME(usec))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No valid realtime timestamp available");
 
        r = sd_journal_get_cursor(j, &cursor);
        if (r == -EBADMSG) {
                log_debug_errno(r, "Unable to determine cursor for entry, assuming bad or partially written entry: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to get cursor: %m");
 
        timestamp = format_timestamp_style(buf, sizeof buf, usec,
                                           flags & OUTPUT_UTC ? TIMESTAMP_US_UTC : TIMESTAMP_US);
        fprintf(f, "%s%s%s %s[%s]%s\n",
                timestamp && (flags & OUTPUT_COLOR) ? ansi_underline() : "",
                timestamp ?: "(no timestamp)",
                timestamp && (flags & OUTPUT_COLOR) ? ansi_normal() : "",
                (flags & OUTPUT_COLOR) ? ansi_grey() : "",
                cursor,
                (flags & OUTPUT_COLOR) ? ansi_grey() : "");
 
        JOURNAL_FOREACH_DATA_RETVAL(j, data, length, r) {
                _cleanup_free_ char *urlified = NULL;
                const char *on = "", *off = "";
                const char *c, *p = NULL;
                size_t fieldlen, valuelen;
 
                c = memchr(data, '=', length);
                if (!c) {
                        log_debug("Encountered field without '=', assuming bad or partially written entry, leaving.");
                        break;
                }
 
                fieldlen = c - (const char*) data;
                if (!journal_field_valid(data, fieldlen, /* allow_protected= */ true)) {
                        log_debug("Encountered invalid field, assuming bad or partially written entry, leaving.");
                        break;
                }
 
                r = field_set_test(output_fields, data, fieldlen);
                if (r < 0)
                        return r;
                if (r == 0)
                        continue;
 
                valuelen = length - 1 - fieldlen;
                p = c + 1;
 
                if (flags & OUTPUT_COLOR) {
                        if (memory_startswith(data, length, "MESSAGE=")) {
                                on = ansi_highlight();
                                off = ansi_normal();
                        } else if (memory_startswith(data, length, "CONFIG_FILE=")) {
                                _cleanup_free_ char *u = NULL;
 
                                u = memdup_suffix0(p, valuelen);
                                if (!u)
                                        return log_oom();
 
                                if (terminal_urlify_path(u, NULL, &urlified) >= 0) {
                                        p = urlified;
                                        valuelen = strlen(urlified);
                                }
 
                        } else if (memory_startswith(data, length, "_")) {
                                /* Highlight trusted data as such */
                                on = ansi_green();
                                off = ansi_normal();
                        }
                }
 
                if ((flags & OUTPUT_SHOW_ALL) ||
                    (((length < PRINT_CHAR_THRESHOLD) || flags & OUTPUT_FULL_WIDTH)
                     && utf8_is_printable(data, length))) {
                        fprintf(f, "    %s%.*s=", on, (int) fieldlen, (const char*)data);
                        print_multiline(f, 4 + fieldlen + 1, 0, OUTPUT_FULL_WIDTH, 0, false,
                                        p, valuelen,
                                        NULL);
                        fputs(off, f);
                } else
                        fprintf(f, "    %s%.*s=[%s blob data]%s\n",
                                on,
                                (int) (c - (const char*) data),
                                (const char*) data,
                                FORMAT_BYTES(length - (c - (const char *) data) - 1),
                                off);
        }
        if (r < 0)
                return r;
 
        if (flags & OUTPUT_CATALOG)
                (void) print_catalog(f, j);
 
        return 0;
}
 
static int output_export(
                FILE *f,
                sd_journal *j,
                OutputMode mode,
                unsigned n_columns,
                OutputFlags flags,
                const Set *output_fields,
                const size_t highlight[2],
                dual_timestamp *previous_display_ts, /* unused */
                sd_id128_t *previous_boot_id) {      /* unused */
 
        sd_id128_t journal_boot_id, seqnum_id;
        _cleanup_free_ char *cursor = NULL;
        usec_t monotonic, realtime;
        const void *data;
        uint64_t seqnum;
        size_t length;
        int r;
 
        assert(j);
 
        (void) sd_journal_set_data_threshold(j, 0);
 
        r = sd_journal_get_cursor(j, &cursor);
        if (IN_SET(r, -EBADMSG, -EADDRNOTAVAIL)) {
                log_debug_errno(r, "Unable to determine cursor of entry, assuming bad or partially written entry: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to get cursor: %m");
 
        r = sd_journal_get_realtime_usec(j, &realtime);
        if (r == -EBADMSG) {
                log_debug_errno(r, "Unable to read realtime timestamp of entry, assuming bad or partially written entry: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to get realtime timestamp: %m");
 
        r = sd_journal_get_monotonic_usec(j, &monotonic, &journal_boot_id);
        if (r == -EBADMSG) {
                log_debug_errno(r, "Unable to read monotonic timestamp of entry, assuming bad or partially written entry: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to get monotonic timestamp: %m");
 
        r = sd_journal_get_seqnum(j, &seqnum, &seqnum_id);
        if (r == -EBADMSG) {
                log_debug_errno(r, "Unable to read sequence number of entry, assuming bad or partially written entry: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to get seqnum: %m");
 
        fprintf(f,
                "__CURSOR=%s\n"
                "__REALTIME_TIMESTAMP=" USEC_FMT "\n"
                "__MONOTONIC_TIMESTAMP=" USEC_FMT "\n"
                "__SEQNUM=%" PRIu64 "\n"
                "__SEQNUM_ID=%s\n"
                "_BOOT_ID=%s\n",
                cursor,
                realtime,
                monotonic,
                seqnum,
                SD_ID128_TO_STRING(seqnum_id),
                SD_ID128_TO_STRING(journal_boot_id));
 
        JOURNAL_FOREACH_DATA_RETVAL(j, data, length, r) {
                size_t fieldlen;
                const char *c;
 
                /* We already printed the boot id from the data in the header, hence let's suppress it here */
                if (memory_startswith(data, length, "_BOOT_ID="))
                        continue;
 
                c = memchr(data, '=', length);
                if (!c) {
                        log_debug("Encountered data field without '=', assuming bad or partially written entry, leaving.");
                        break;
                }
 
                fieldlen = c - (const char*) data;
                if (!journal_field_valid(data, fieldlen, /* allow_protected= */ true)) {
                        log_debug("Encountered invalid field, assuming bad or partially written entry, leaving.");
                        break;
                }
 
                r = field_set_test(output_fields, data, fieldlen);