HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/shared/logs-show.c
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);