Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <errno.h>
4 : : #include <fcntl.h>
5 : : #include <signal.h>
6 : : #include <stdint.h>
7 : : #include <stdlib.h>
8 : : #include <string.h>
9 : : #include <sys/socket.h>
10 : : #include <syslog.h>
11 : : #include <time.h>
12 : : #include <unistd.h>
13 : :
14 : : #include "sd-id128.h"
15 : : #include "sd-journal.h"
16 : :
17 : : #include "alloc-util.h"
18 : : #include "fd-util.h"
19 : : #include "format-util.h"
20 : : #include "hashmap.h"
21 : : #include "hostname-util.h"
22 : : #include "io-util.h"
23 : : #include "journal-internal.h"
24 : : #include "json.h"
25 : : #include "log.h"
26 : : #include "logs-show.h"
27 : : #include "macro.h"
28 : : #include "namespace-util.h"
29 : : #include "output-mode.h"
30 : : #include "parse-util.h"
31 : : #include "process-util.h"
32 : : #include "pretty-print.h"
33 : : #include "sparse-endian.h"
34 : : #include "stdio-util.h"
35 : : #include "string-table.h"
36 : : #include "string-util.h"
37 : : #include "strv.h"
38 : : #include "terminal-util.h"
39 : : #include "time-util.h"
40 : : #include "utf8.h"
41 : : #include "util.h"
42 : :
43 : : /* up to three lines (each up to 100 characters) or 300 characters, whichever is less */
44 : : #define PRINT_LINE_THRESHOLD 3
45 : : #define PRINT_CHAR_THRESHOLD 300
46 : :
47 : : #define JSON_THRESHOLD 4096U
48 : :
49 : 0 : static int print_catalog(FILE *f, sd_journal *j) {
50 : : int r;
51 : 0 : _cleanup_free_ char *t = NULL, *z = NULL;
52 : :
53 : 0 : r = sd_journal_get_catalog(j, &t);
54 [ # # ]: 0 : if (r < 0)
55 : 0 : return r;
56 : :
57 : 0 : z = strreplace(strstrip(t), "\n", "\n-- ");
58 [ # # ]: 0 : if (!z)
59 : 0 : return log_oom();
60 : :
61 : 0 : fputs("-- ", f);
62 : 0 : fputs(z, f);
63 : 0 : fputc('\n', f);
64 : :
65 : 0 : return 0;
66 : : }
67 : :
68 : 0 : static int parse_field(const void *data, size_t length, const char *field, size_t field_len, char **target, size_t *target_len) {
69 : : size_t nl;
70 : : char *buf;
71 : :
72 [ # # ]: 0 : assert(data);
73 [ # # ]: 0 : assert(field);
74 [ # # ]: 0 : assert(target);
75 : :
76 [ # # ]: 0 : if (length < field_len)
77 : 0 : return 0;
78 : :
79 [ # # ]: 0 : if (memcmp(data, field, field_len))
80 : 0 : return 0;
81 : :
82 : 0 : nl = length - field_len;
83 : :
84 : 0 : buf = newdup_suffix0(char, (const char*) data + field_len, nl);
85 [ # # ]: 0 : if (!buf)
86 : 0 : return log_oom();
87 : :
88 : 0 : free(*target);
89 : 0 : *target = buf;
90 : :
91 [ # # ]: 0 : if (target_len)
92 : 0 : *target_len = nl;
93 : :
94 : 0 : return 1;
95 : : }
96 : :
97 : : typedef struct ParseFieldVec {
98 : : const char *field;
99 : : size_t field_len;
100 : : char **target;
101 : : size_t *target_len;
102 : : } ParseFieldVec;
103 : :
104 : : #define PARSE_FIELD_VEC_ENTRY(_field, _target, _target_len) \
105 : : { .field = _field, .field_len = strlen(_field), .target = _target, .target_len = _target_len }
106 : :
107 : 0 : static int parse_fieldv(const void *data, size_t length, const ParseFieldVec *fields, unsigned n_fields) {
108 : : unsigned i;
109 : :
110 [ # # ]: 0 : for (i = 0; i < n_fields; i++) {
111 : 0 : const ParseFieldVec *f = &fields[i];
112 : : int r;
113 : :
114 : 0 : r = parse_field(data, length, f->field, f->field_len, f->target, f->target_len);
115 [ # # ]: 0 : if (r < 0)
116 : 0 : return r;
117 [ # # ]: 0 : else if (r > 0)
118 : 0 : break;
119 : : }
120 : :
121 : 0 : return 0;
122 : : }
123 : :
124 : 0 : static int field_set_test(Set *fields, const char *name, size_t n) {
125 : 0 : char *s = NULL;
126 : :
127 [ # # ]: 0 : if (!fields)
128 : 0 : return 1;
129 : :
130 : 0 : s = strndupa(name, n);
131 [ # # ]: 0 : if (!s)
132 : 0 : return log_oom();
133 : :
134 : 0 : return set_get(fields, s) ? 1 : 0;
135 : : }
136 : :
137 : 0 : static bool shall_print(const char *p, size_t l, OutputFlags flags) {
138 [ # # ]: 0 : assert(p);
139 : :
140 [ # # ]: 0 : if (flags & OUTPUT_SHOW_ALL)
141 : 0 : return true;
142 : :
143 [ # # ]: 0 : if (l >= PRINT_CHAR_THRESHOLD)
144 : 0 : return false;
145 : :
146 [ # # ]: 0 : if (!utf8_is_printable(p, l))
147 : 0 : return false;
148 : :
149 : 0 : return true;
150 : : }
151 : :
152 : 0 : static bool print_multiline(
153 : : FILE *f,
154 : : unsigned prefix,
155 : : unsigned n_columns,
156 : : OutputFlags flags,
157 : : int priority,
158 : : bool audit,
159 : : const char* message,
160 : : size_t message_len,
161 : : size_t highlight[2]) {
162 : :
163 : 0 : const char *color_on = "", *color_off = "", *highlight_on = "";
164 : : const char *pos, *end;
165 : 0 : bool ellipsized = false;
166 : 0 : int line = 0;
167 : :
168 [ # # ]: 0 : if (flags & OUTPUT_COLOR) {
169 : 0 : get_log_colors(priority, &color_on, &color_off, &highlight_on);
170 : :
171 [ # # # # ]: 0 : if (audit && strempty(color_on)) {
172 : 0 : color_on = ANSI_BLUE;
173 : 0 : color_off = ANSI_NORMAL;
174 : : }
175 : : }
176 : :
177 : : /* A special case: make sure that we print a newline when
178 : : the message is empty. */
179 [ # # ]: 0 : if (message_len == 0)
180 : 0 : fputs("\n", f);
181 : :
182 : 0 : for (pos = message;
183 [ # # ]: 0 : pos < message + message_len;
184 : 0 : pos = end + 1, line++) {
185 : 0 : bool continuation = line > 0;
186 : : bool tail_line;
187 : : int len;
188 [ # # # # ]: 0 : for (end = pos; end < message + message_len && *end != '\n'; end++)
189 : : ;
190 : 0 : len = end - pos;
191 [ # # ]: 0 : assert(len >= 0);
192 : :
193 : : /* We need to figure out when we are showing not-last line, *and*
194 : : * will skip subsequent lines. In that case, we will put the dots
195 : : * at the end of the line, instead of putting dots in the middle
196 : : * or not at all.
197 : : */
198 : 0 : tail_line =
199 [ # # ]: 0 : line + 1 == PRINT_LINE_THRESHOLD ||
200 [ # # ]: 0 : end + 1 >= message + PRINT_CHAR_THRESHOLD;
201 : :
202 [ # # ]: 0 : if (flags & (OUTPUT_FULL_WIDTH | OUTPUT_SHOW_ALL) ||
203 [ # # # # ]: 0 : (prefix + len + 1 < n_columns && !tail_line)) {
204 [ # # ]: 0 : if (highlight &&
205 [ # # ]: 0 : (size_t) (pos - message) <= highlight[0] &&
206 [ # # ]: 0 : highlight[0] < (size_t) len) {
207 : :
208 : 0 : fprintf(f, "%*s%s%.*s",
209 : : continuation * prefix, "",
210 : 0 : color_on, (int) highlight[0], pos);
211 : 0 : fprintf(f, "%s%.*s",
212 : : highlight_on,
213 : 0 : (int) (MIN((size_t) len, highlight[1]) - highlight[0]),
214 : 0 : pos + highlight[0]);
215 [ # # ]: 0 : if ((size_t) len > highlight[1])
216 : 0 : fprintf(f, "%s%.*s",
217 : : color_on,
218 : 0 : (int) (len - highlight[1]),
219 : 0 : pos + highlight[1]);
220 : 0 : fprintf(f, "%s\n", color_off);
221 : :
222 : : } else
223 : 0 : fprintf(f, "%*s%s%.*s%s\n",
224 : : continuation * prefix, "",
225 : : color_on, len, pos, color_off);
226 : 0 : continue;
227 : : }
228 : :
229 : : /* Beyond this point, ellipsization will happen. */
230 : 0 : ellipsized = true;
231 : :
232 [ # # # # ]: 0 : if (prefix < n_columns && n_columns - prefix >= 3) {
233 [ # # ]: 0 : if (n_columns - prefix > (unsigned) len + 3)
234 : 0 : fprintf(f, "%*s%s%.*s...%s\n",
235 : : continuation * prefix, "",
236 : : color_on, len, pos, color_off);
237 : : else {
238 : 0 : _cleanup_free_ char *e;
239 : :
240 [ # # ]: 0 : e = ellipsize_mem(pos, len, n_columns - prefix,
241 : : tail_line ? 100 : 90);
242 [ # # ]: 0 : if (!e)
243 : 0 : fprintf(f, "%*s%s%.*s%s\n",
244 : : continuation * prefix, "",
245 : : color_on, len, pos, color_off);
246 : : else
247 : 0 : fprintf(f, "%*s%s%s%s\n",
248 : : continuation * prefix, "",
249 : : color_on, e, color_off);
250 : : }
251 : : } else
252 : 0 : fputs("...\n", f);
253 : :
254 [ # # ]: 0 : if (tail_line)
255 : 0 : break;
256 : : }
257 : :
258 : 0 : return ellipsized;
259 : : }
260 : :
261 : 0 : static int output_timestamp_monotonic(FILE *f, sd_journal *j, const char *monotonic) {
262 : : sd_id128_t boot_id;
263 : : uint64_t t;
264 : : int r;
265 : :
266 [ # # ]: 0 : assert(f);
267 [ # # ]: 0 : assert(j);
268 : :
269 : 0 : r = -ENXIO;
270 [ # # ]: 0 : if (monotonic)
271 : 0 : r = safe_atou64(monotonic, &t);
272 [ # # ]: 0 : if (r < 0)
273 : 0 : r = sd_journal_get_monotonic_usec(j, &t, &boot_id);
274 [ # # ]: 0 : if (r < 0)
275 [ # # ]: 0 : return log_error_errno(r, "Failed to get monotonic timestamp: %m");
276 : :
277 : 0 : fprintf(f, "[%5"PRI_USEC".%06"PRI_USEC"]", t / USEC_PER_SEC, t % USEC_PER_SEC);
278 : 0 : return 1 + 5 + 1 + 6 + 1;
279 : : }
280 : :
281 : 0 : static int output_timestamp_realtime(FILE *f, sd_journal *j, OutputMode mode, OutputFlags flags, const char *realtime) {
282 : 0 : char buf[MAX(FORMAT_TIMESTAMP_MAX, 64)];
283 : : struct tm *(*gettime_r)(const time_t *, struct tm *);
284 : : struct tm tm;
285 : : uint64_t x;
286 : : time_t t;
287 : : int r;
288 : :
289 [ # # ]: 0 : assert(f);
290 [ # # ]: 0 : assert(j);
291 : :
292 [ # # ]: 0 : if (realtime)
293 : 0 : r = safe_atou64(realtime, &x);
294 [ # # # # : 0 : if (!realtime || r < 0 || !VALID_REALTIME(x))
# # ]
295 : 0 : r = sd_journal_get_realtime_usec(j, &x);
296 [ # # ]: 0 : if (r < 0)
297 [ # # ]: 0 : return log_error_errno(r, "Failed to get realtime timestamp: %m");
298 : :
299 [ # # # # ]: 0 : if (IN_SET(mode, OUTPUT_SHORT_FULL, OUTPUT_WITH_UNIT)) {
300 : : const char *k;
301 : :
302 [ # # ]: 0 : if (flags & OUTPUT_UTC)
303 : 0 : k = format_timestamp_utc(buf, sizeof(buf), x);
304 : : else
305 : 0 : k = format_timestamp(buf, sizeof(buf), x);
306 [ # # ]: 0 : if (!k)
307 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
308 : : "Failed to format timestamp: %" PRIu64, x);
309 : :
310 : : } else {
311 : : char usec[7];
312 : :
313 [ # # ]: 0 : gettime_r = (flags & OUTPUT_UTC) ? gmtime_r : localtime_r;
314 : 0 : t = (time_t) (x / USEC_PER_SEC);
315 : :
316 [ # # # # : 0 : switch (mode) {
# ]
317 : :
318 : 0 : case OUTPUT_SHORT_UNIX:
319 [ # # ]: 0 : xsprintf(buf, "%10"PRI_TIME".%06"PRIu64, t, x % USEC_PER_SEC);
320 : 0 : break;
321 : :
322 : 0 : case OUTPUT_SHORT_ISO:
323 [ # # ]: 0 : if (strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S%z", gettime_r(&t, &tm)) <= 0)
324 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
325 : : "Failed to format ISO time");
326 : 0 : break;
327 : :
328 : 0 : case OUTPUT_SHORT_ISO_PRECISE:
329 : : /* No usec in strftime, so we leave space and copy over */
330 [ # # ]: 0 : if (strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S.xxxxxx%z", gettime_r(&t, &tm)) <= 0)
331 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
332 : : "Failed to format ISO-precise time");
333 [ # # ]: 0 : xsprintf(usec, "%06"PRI_USEC, x % USEC_PER_SEC);
334 : 0 : memcpy(buf + 20, usec, 6);
335 : 0 : break;
336 : :
337 : 0 : case OUTPUT_SHORT:
338 : : case OUTPUT_SHORT_PRECISE:
339 : :
340 [ # # ]: 0 : if (strftime(buf, sizeof(buf), "%b %d %H:%M:%S", gettime_r(&t, &tm)) <= 0)
341 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
342 : : "Failed to format syslog time");
343 : :
344 [ # # ]: 0 : if (mode == OUTPUT_SHORT_PRECISE) {
345 : : size_t k;
346 : :
347 [ # # ]: 0 : assert(sizeof(buf) > strlen(buf));
348 : 0 : k = sizeof(buf) - strlen(buf);
349 : :
350 : 0 : r = snprintf(buf + strlen(buf), k, ".%06"PRIu64, x % USEC_PER_SEC);
351 [ # # # # ]: 0 : if (r <= 0 || (size_t) r >= k) /* too long? */
352 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
353 : : "Failed to format precise time");
354 : : }
355 : 0 : break;
356 : :
357 : 0 : default:
358 : 0 : assert_not_reached("Unknown time format");
359 : : }
360 : : }
361 : :
362 : 0 : fputs(buf, f);
363 : 0 : return (int) strlen(buf);
364 : : }
365 : :
366 : 0 : static int output_short(
367 : : FILE *f,
368 : : sd_journal *j,
369 : : OutputMode mode,
370 : : unsigned n_columns,
371 : : OutputFlags flags,
372 : : Set *output_fields,
373 : : const size_t highlight[2]) {
374 : :
375 : : int r;
376 : : const void *data;
377 : : size_t length;
378 : 0 : size_t n = 0;
379 : 0 : _cleanup_free_ char *hostname = NULL, *identifier = NULL, *comm = NULL, *pid = NULL, *fake_pid = NULL, *message = NULL, *realtime = NULL, *monotonic = NULL, *priority = NULL, *transport = NULL, *config_file = NULL, *unit = NULL, *user_unit = NULL;
380 : 0 : size_t hostname_len = 0, identifier_len = 0, comm_len = 0, pid_len = 0, fake_pid_len = 0, message_len = 0, realtime_len = 0, monotonic_len = 0, priority_len = 0, transport_len = 0, config_file_len = 0, unit_len = 0, user_unit_len = 0;
381 : 0 : int p = LOG_INFO;
382 : 0 : bool ellipsized = false, audit;
383 : 0 : const ParseFieldVec fields[] = {
384 : : PARSE_FIELD_VEC_ENTRY("_PID=", &pid, &pid_len),
385 : : PARSE_FIELD_VEC_ENTRY("_COMM=", &comm, &comm_len),
386 : : PARSE_FIELD_VEC_ENTRY("MESSAGE=", &message, &message_len),
387 : : PARSE_FIELD_VEC_ENTRY("PRIORITY=", &priority, &priority_len),
388 : : PARSE_FIELD_VEC_ENTRY("_TRANSPORT=", &transport, &transport_len),
389 : : PARSE_FIELD_VEC_ENTRY("_HOSTNAME=", &hostname, &hostname_len),
390 : : PARSE_FIELD_VEC_ENTRY("SYSLOG_PID=", &fake_pid, &fake_pid_len),
391 : : PARSE_FIELD_VEC_ENTRY("SYSLOG_IDENTIFIER=", &identifier, &identifier_len),
392 : : PARSE_FIELD_VEC_ENTRY("_SOURCE_REALTIME_TIMESTAMP=", &realtime, &realtime_len),
393 : : PARSE_FIELD_VEC_ENTRY("_SOURCE_MONOTONIC_TIMESTAMP=", &monotonic, &monotonic_len),
394 : : PARSE_FIELD_VEC_ENTRY("CONFIG_FILE=", &config_file, &config_file_len),
395 : : PARSE_FIELD_VEC_ENTRY("_SYSTEMD_UNIT=", &unit, &unit_len),
396 : : PARSE_FIELD_VEC_ENTRY("_SYSTEMD_USER_UNIT=", &user_unit, &user_unit_len),
397 : : };
398 [ # # # # ]: 0 : size_t highlight_shifted[] = {highlight ? highlight[0] : 0, highlight ? highlight[1] : 0};
399 : :
400 [ # # ]: 0 : assert(f);
401 [ # # ]: 0 : assert(j);
402 : :
403 : : /* Set the threshold to one bigger than the actual print
404 : : * threshold, so that if the line is actually longer than what
405 : : * we're willing to print, ellipsization will occur. This way
406 : : * we won't output a misleading line without any indication of
407 : : * truncation.
408 : : */
409 [ # # ]: 0 : sd_journal_set_data_threshold(j, flags & (OUTPUT_SHOW_ALL|OUTPUT_FULL_WIDTH) ? 0 : PRINT_CHAR_THRESHOLD + 1);
410 : :
411 [ # # ]: 0 : JOURNAL_FOREACH_DATA_RETVAL(j, data, length, r) {
412 : 0 : r = parse_fieldv(data, length, fields, ELEMENTSOF(fields));
413 [ # # ]: 0 : if (r < 0)
414 : 0 : return r;
415 : : }
416 [ # # ]: 0 : if (r == -EBADMSG) {
417 [ # # ]: 0 : log_debug_errno(r, "Skipping message we can't read: %m");
418 : 0 : return 0;
419 : : }
420 [ # # ]: 0 : if (r < 0)
421 [ # # ]: 0 : return log_error_errno(r, "Failed to get journal fields: %m");
422 : :
423 [ # # ]: 0 : if (!message) {
424 [ # # ]: 0 : log_debug("Skipping message without MESSAGE= field.");
425 : 0 : return 0;
426 : : }
427 : :
428 [ # # ]: 0 : if (!(flags & OUTPUT_SHOW_ALL))
429 : 0 : strip_tab_ansi(&message, &message_len, highlight_shifted);
430 : :
431 [ # # # # : 0 : if (priority_len == 1 && *priority >= '0' && *priority <= '7')
# # ]
432 : 0 : p = *priority - '0';
433 : :
434 : 0 : audit = streq_ptr(transport, "audit");
435 : :
436 [ # # ]: 0 : if (mode == OUTPUT_SHORT_MONOTONIC)
437 : 0 : r = output_timestamp_monotonic(f, j, monotonic);
438 : : else
439 : 0 : r = output_timestamp_realtime(f, j, mode, flags, realtime);
440 [ # # ]: 0 : if (r < 0)
441 : 0 : return r;
442 : 0 : n += r;
443 : :
444 [ # # ]: 0 : if (flags & OUTPUT_NO_HOSTNAME) {
445 : : /* Suppress display of the hostname if this is requested. */
446 : 0 : hostname = mfree(hostname);
447 : 0 : hostname_len = 0;
448 : : }
449 : :
450 [ # # # # ]: 0 : if (hostname && shall_print(hostname, hostname_len, flags)) {
451 : 0 : fprintf(f, " %.*s", (int) hostname_len, hostname);
452 : 0 : n += hostname_len + 1;
453 : : }
454 : :
455 [ # # # # : 0 : if (mode == OUTPUT_WITH_UNIT && ((unit && shall_print(unit, unit_len, flags)) ||
# # ]
456 [ # # # # ]: 0 : (user_unit && shall_print(user_unit, user_unit_len, flags)))) {
457 [ # # ]: 0 : if (unit) {
458 : 0 : fprintf(f, " %.*s", (int) unit_len, unit);
459 : 0 : n += unit_len + 1;
460 : : }
461 [ # # ]: 0 : if (user_unit) {
462 [ # # ]: 0 : if (unit)
463 : 0 : fprintf(f, "/%.*s", (int) user_unit_len, user_unit);
464 : : else
465 : 0 : fprintf(f, " %.*s", (int) user_unit_len, user_unit);
466 : 0 : n += unit_len + 1;
467 : : }
468 [ # # # # ]: 0 : } else if (identifier && shall_print(identifier, identifier_len, flags)) {
469 : 0 : fprintf(f, " %.*s", (int) identifier_len, identifier);
470 : 0 : n += identifier_len + 1;
471 [ # # # # ]: 0 : } else if (comm && shall_print(comm, comm_len, flags)) {
472 : 0 : fprintf(f, " %.*s", (int) comm_len, comm);
473 : 0 : n += comm_len + 1;
474 : : } else
475 : 0 : fputs(" unknown", f);
476 : :
477 [ # # # # ]: 0 : if (pid && shall_print(pid, pid_len, flags)) {
478 : 0 : fprintf(f, "[%.*s]", (int) pid_len, pid);
479 : 0 : n += pid_len + 2;
480 [ # # # # ]: 0 : } else if (fake_pid && shall_print(fake_pid, fake_pid_len, flags)) {
481 : 0 : fprintf(f, "[%.*s]", (int) fake_pid_len, fake_pid);
482 : 0 : n += fake_pid_len + 2;
483 : : }
484 : :
485 [ # # # # ]: 0 : if (!(flags & OUTPUT_SHOW_ALL) && !utf8_is_printable(message, message_len)) {
486 : : char bytes[FORMAT_BYTES_MAX];
487 : 0 : fprintf(f, ": [%s blob data]\n", format_bytes(bytes, sizeof(bytes), message_len));
488 : : } else {
489 : 0 : fputs(": ", f);
490 : :
491 : : /* URLify config_file string in message, if the message starts with it.
492 : : * Skip URLification if the highlighted pattern overlaps. */
493 [ # # ]: 0 : if (config_file &&
494 [ # # ]: 0 : message_len >= config_file_len &&
495 [ # # ]: 0 : memcmp(message, config_file, config_file_len) == 0 &&
496 [ # # # # : 0 : IN_SET(message[config_file_len], ':', ' ', '\0') &&
# # ]
497 [ # # # # ]: 0 : (!highlight || highlight_shifted[0] == 0 || highlight_shifted[0] > config_file_len)) {
498 : :
499 : 0 : _cleanup_free_ char *t = NULL, *urlified = NULL;
500 : :
501 : 0 : t = strndup(config_file, config_file_len);
502 [ # # # # ]: 0 : if (t && terminal_urlify_path(t, NULL, &urlified) >= 0) {
503 : 0 : size_t shift = strlen(urlified) - config_file_len;
504 : : char *joined;
505 : :
506 : 0 : joined = strjoin(urlified, message + config_file_len);
507 [ # # ]: 0 : if (joined) {
508 : 0 : free_and_replace(message, joined);
509 : 0 : message_len += shift;
510 [ # # ]: 0 : if (highlight) {
511 : 0 : highlight_shifted[0] += shift;
512 : 0 : highlight_shifted[1] += shift;
513 : : }
514 : : }
515 : : }
516 : : }
517 : :
518 : 0 : ellipsized |=
519 : 0 : print_multiline(f, n + 2, n_columns, flags, p, audit,
520 : : message, message_len,
521 : : highlight_shifted);
522 : : }
523 : :
524 [ # # ]: 0 : if (flags & OUTPUT_CATALOG)
525 : 0 : print_catalog(f, j);
526 : :
527 : 0 : return ellipsized;
528 : : }
529 : :
530 : 0 : static int output_verbose(
531 : : FILE *f,
532 : : sd_journal *j,
533 : : OutputMode mode,
534 : : unsigned n_columns,
535 : : OutputFlags flags,
536 : : Set *output_fields,
537 : : const size_t highlight[2]) {
538 : :
539 : : const void *data;
540 : : size_t length;
541 : 0 : _cleanup_free_ char *cursor = NULL;
542 : 0 : uint64_t realtime = 0;
543 : : char ts[FORMAT_TIMESTAMP_MAX + 7];
544 : : const char *timestamp;
545 : : int r;
546 : :
547 [ # # ]: 0 : assert(f);
548 [ # # ]: 0 : assert(j);
549 : :
550 : 0 : sd_journal_set_data_threshold(j, 0);
551 : :
552 : 0 : r = sd_journal_get_data(j, "_SOURCE_REALTIME_TIMESTAMP", &data, &length);
553 [ # # ]: 0 : if (r == -ENOENT)
554 [ # # ]: 0 : log_debug("Source realtime timestamp not found");
555 [ # # ]: 0 : else if (r < 0)
556 [ # # # # ]: 0 : return log_full_errno(r == -EADDRNOTAVAIL ? LOG_DEBUG : LOG_ERR, r, "Failed to get source realtime timestamp: %m");
557 : : else {
558 [ # # ]: 0 : _cleanup_free_ char *value = NULL;
559 : :
560 : 0 : r = parse_field(data, length, "_SOURCE_REALTIME_TIMESTAMP=",
561 : : STRLEN("_SOURCE_REALTIME_TIMESTAMP="), &value,
562 : : NULL);
563 [ # # ]: 0 : if (r < 0)
564 : 0 : return r;
565 [ # # ]: 0 : assert(r > 0);
566 : :
567 : 0 : r = safe_atou64(value, &realtime);
568 [ # # ]: 0 : if (r < 0)
569 [ # # ]: 0 : log_debug_errno(r, "Failed to parse realtime timestamp: %m");
570 : : }
571 : :
572 [ # # ]: 0 : if (r < 0) {
573 : 0 : r = sd_journal_get_realtime_usec(j, &realtime);
574 [ # # ]: 0 : if (r < 0)
575 [ # # # # ]: 0 : return log_full_errno(r == -EADDRNOTAVAIL ? LOG_DEBUG : LOG_ERR, r, "Failed to get realtime timestamp: %m");
576 : : }
577 : :
578 : 0 : r = sd_journal_get_cursor(j, &cursor);
579 [ # # ]: 0 : if (r < 0)
580 [ # # ]: 0 : return log_error_errno(r, "Failed to get cursor: %m");
581 : :
582 [ # # ]: 0 : timestamp = flags & OUTPUT_UTC ? format_timestamp_us_utc(ts, sizeof ts, realtime)
583 : 0 : : format_timestamp_us(ts, sizeof ts, realtime);
584 : 0 : fprintf(f, "%s [%s]\n",
585 [ # # ]: 0 : timestamp ?: "(no timestamp)",
586 : : cursor);
587 : :
588 [ # # ]: 0 : JOURNAL_FOREACH_DATA_RETVAL(j, data, length, r) {
589 : : const char *c, *p;
590 : : int fieldlen;
591 : 0 : const char *on = "", *off = "";
592 [ # # # ]: 0 : _cleanup_free_ char *urlified = NULL;
593 : : size_t valuelen;
594 : :
595 : 0 : c = memchr(data, '=', length);
596 [ # # ]: 0 : if (!c)
597 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
598 : : "Invalid field.");
599 : 0 : fieldlen = c - (const char*) data;
600 : :
601 : 0 : r = field_set_test(output_fields, data, fieldlen);
602 [ # # ]: 0 : if (r < 0)
603 : 0 : return r;
604 [ # # ]: 0 : if (r == 0)
605 : 0 : continue;
606 : :
607 : 0 : valuelen = length - 1 - fieldlen;
608 : :
609 [ # # # # ]: 0 : if ((flags & OUTPUT_COLOR) && (p = startswith(data, "MESSAGE="))) {
610 : 0 : on = ANSI_HIGHLIGHT;
611 : 0 : off = ANSI_NORMAL;
612 [ # # ]: 0 : } else if ((p = startswith(data, "CONFIG_FILE="))) {
613 [ # # ]: 0 : if (terminal_urlify_path(p, NULL, &urlified) >= 0) {
614 : 0 : p = urlified;
615 : 0 : valuelen = strlen(urlified);
616 : : }
617 : : } else
618 : 0 : p = c + 1;
619 : :
620 [ # # ]: 0 : if ((flags & OUTPUT_SHOW_ALL) ||
621 [ # # # # ]: 0 : (((length < PRINT_CHAR_THRESHOLD) || flags & OUTPUT_FULL_WIDTH)
622 [ # # ]: 0 : && utf8_is_printable(data, length))) {
623 : 0 : fprintf(f, " %s%.*s=", on, fieldlen, (const char*)data);
624 : 0 : print_multiline(f, 4 + fieldlen + 1, 0, OUTPUT_FULL_WIDTH, 0, false,
625 : : p, valuelen,
626 : : NULL);
627 : 0 : fputs(off, f);
628 : : } else {
629 : : char bytes[FORMAT_BYTES_MAX];
630 : :
631 : 0 : fprintf(f, " %s%.*s=[%s blob data]%s\n",
632 : : on,
633 : 0 : (int) (c - (const char*) data),
634 : : (const char*) data,
635 : 0 : format_bytes(bytes, sizeof(bytes), length - (c - (const char *) data) - 1),
636 : : off);
637 : : }
638 : : }
639 : :
640 [ # # ]: 0 : if (r < 0)
641 : 0 : return r;
642 : :
643 [ # # ]: 0 : if (flags & OUTPUT_CATALOG)
644 : 0 : print_catalog(f, j);
645 : :
646 : 0 : return 0;
647 : : }
648 : :
649 : 0 : static int output_export(
650 : : FILE *f,
651 : : sd_journal *j,
652 : : OutputMode mode,
653 : : unsigned n_columns,
654 : : OutputFlags flags,
655 : : Set *output_fields,
656 : : const size_t highlight[2]) {
657 : :
658 : : sd_id128_t boot_id;
659 : : char sid[33];
660 : : int r;
661 : : usec_t realtime, monotonic;
662 : 0 : _cleanup_free_ char *cursor = NULL;
663 : : const void *data;
664 : : size_t length;
665 : :
666 [ # # ]: 0 : assert(j);
667 : :
668 : 0 : sd_journal_set_data_threshold(j, 0);
669 : :
670 : 0 : r = sd_journal_get_realtime_usec(j, &realtime);
671 [ # # ]: 0 : if (r < 0)
672 [ # # ]: 0 : return log_error_errno(r, "Failed to get realtime timestamp: %m");
673 : :
674 : 0 : r = sd_journal_get_monotonic_usec(j, &monotonic, &boot_id);
675 [ # # ]: 0 : if (r < 0)
676 [ # # ]: 0 : return log_error_errno(r, "Failed to get monotonic timestamp: %m");
677 : :
678 : 0 : r = sd_journal_get_cursor(j, &cursor);
679 [ # # ]: 0 : if (r < 0)
680 [ # # ]: 0 : return log_error_errno(r, "Failed to get cursor: %m");
681 : :
682 : 0 : fprintf(f,
683 : : "__CURSOR=%s\n"
684 : : "__REALTIME_TIMESTAMP="USEC_FMT"\n"
685 : : "__MONOTONIC_TIMESTAMP="USEC_FMT"\n"
686 : : "_BOOT_ID=%s\n",
687 : : cursor,
688 : : realtime,
689 : : monotonic,
690 : : sd_id128_to_string(boot_id, sid));
691 : :
692 [ # # ]: 0 : JOURNAL_FOREACH_DATA_RETVAL(j, data, length, r) {
693 : : const char *c;
694 : :
695 : : /* We already printed the boot id from the data in the header, hence let's suppress it here */
696 [ # # ]: 0 : if (memory_startswith(data, length, "_BOOT_ID="))
697 : 0 : continue;
698 : :
699 : 0 : c = memchr(data, '=', length);
700 [ # # ]: 0 : if (!c)
701 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
702 : : "Invalid field.");
703 : :
704 : 0 : r = field_set_test(output_fields, data, c - (const char *) data);
705 [ # # ]: 0 : if (r < 0)
706 : 0 : return r;
707 [ # # ]: 0 : if (!r)
708 : 0 : continue;
709 : :
710 [ # # ]: 0 : if (utf8_is_printable_newline(data, length, false))
711 : 0 : fwrite(data, length, 1, f);
712 : : else {
713 : : uint64_t le64;
714 : :
715 : 0 : fwrite(data, c - (const char*) data, 1, f);
716 : 0 : fputc('\n', f);
717 : 0 : le64 = htole64(length - (c - (const char*) data) - 1);
718 : 0 : fwrite(&le64, sizeof(le64), 1, f);
719 : 0 : fwrite(c + 1, length - (c - (const char*) data) - 1, 1, f);
720 : : }
721 : :
722 : 0 : fputc('\n', f);
723 : : }
724 [ # # ]: 0 : if (r == -EBADMSG) {
725 [ # # ]: 0 : log_debug_errno(r, "Skipping message we can't read: %m");
726 : 0 : return 0;
727 : : }
728 : :
729 [ # # ]: 0 : if (r < 0)
730 : 0 : return r;
731 : :
732 : 0 : fputc('\n', f);
733 : :
734 : 0 : return 0;
735 : : }
736 : :
737 : 0 : void json_escape(
738 : : FILE *f,
739 : : const char* p,
740 : : size_t l,
741 : : OutputFlags flags) {
742 : :
743 [ # # ]: 0 : assert(f);
744 [ # # ]: 0 : assert(p);
745 : :
746 [ # # # # ]: 0 : if (!(flags & OUTPUT_SHOW_ALL) && l >= JSON_THRESHOLD)
747 : 0 : fputs("null", f);
748 : :
749 [ # # # # ]: 0 : else if (!(flags & OUTPUT_SHOW_ALL) && !utf8_is_printable(p, l)) {
750 : 0 : bool not_first = false;
751 : :
752 : 0 : fputs("[ ", f);
753 : :
754 [ # # ]: 0 : while (l > 0) {
755 [ # # ]: 0 : if (not_first)
756 : 0 : fprintf(f, ", %u", (uint8_t) *p);
757 : : else {
758 : 0 : not_first = true;
759 : 0 : fprintf(f, "%u", (uint8_t) *p);
760 : : }
761 : :
762 : 0 : p++;
763 : 0 : l--;
764 : : }
765 : :
766 : 0 : fputs(" ]", f);
767 : : } else {
768 : 0 : fputc('"', f);
769 : :
770 [ # # ]: 0 : while (l > 0) {
771 [ # # # # ]: 0 : if (IN_SET(*p, '"', '\\')) {
772 : 0 : fputc('\\', f);
773 : 0 : fputc(*p, f);
774 [ # # ]: 0 : } else if (*p == '\n')
775 : 0 : fputs("\\n", f);
776 [ # # ]: 0 : else if ((uint8_t) *p < ' ')
777 : 0 : fprintf(f, "\\u%04x", (uint8_t) *p);
778 : : else
779 : 0 : fputc(*p, f);
780 : :
781 : 0 : p++;
782 : 0 : l--;
783 : : }
784 : :
785 : 0 : fputc('"', f);
786 : : }
787 : 0 : }
788 : :
789 : : struct json_data {
790 : : JsonVariant* name;
791 : : size_t n_values;
792 : : JsonVariant* values[];
793 : : };
794 : :
795 : 0 : static int update_json_data(
796 : : Hashmap *h,
797 : : OutputFlags flags,
798 : : const char *name,
799 : : const void *value,
800 : : size_t size) {
801 : :
802 : 0 : _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
803 : : struct json_data *d;
804 : : int r;
805 : :
806 [ # # # # ]: 0 : if (!(flags & OUTPUT_SHOW_ALL) && strlen(name) + 1 + size >= JSON_THRESHOLD)
807 : 0 : r = json_variant_new_null(&v);
808 [ # # ]: 0 : else if (utf8_is_printable(value, size))
809 : 0 : r = json_variant_new_stringn(&v, value, size);
810 : : else
811 : 0 : r = json_variant_new_array_bytes(&v, value, size);
812 [ # # ]: 0 : if (r < 0)
813 [ # # ]: 0 : return log_error_errno(r, "Failed to allocate JSON data: %m");
814 : :
815 : 0 : d = hashmap_get(h, name);
816 [ # # ]: 0 : if (d) {
817 : : struct json_data *w;
818 : :
819 : 0 : w = realloc(d, offsetof(struct json_data, values) + sizeof(JsonVariant*) * (d->n_values + 1));
820 [ # # ]: 0 : if (!w)
821 : 0 : return log_oom();
822 : :
823 : 0 : d = w;
824 [ # # ]: 0 : assert_se(hashmap_update(h, json_variant_string(d->name), d) >= 0);
825 : : } else {
826 [ # # ]: 0 : _cleanup_(json_variant_unrefp) JsonVariant *n = NULL;
827 : :
828 : 0 : r = json_variant_new_string(&n, name);
829 [ # # ]: 0 : if (r < 0)
830 [ # # ]: 0 : return log_error_errno(r, "Failed to allocate JSON name variant: %m");
831 : :
832 : 0 : d = malloc0(offsetof(struct json_data, values) + sizeof(JsonVariant*));
833 [ # # ]: 0 : if (!d)
834 : 0 : return log_oom();
835 : :
836 : 0 : r = hashmap_put(h, json_variant_string(n), d);
837 [ # # ]: 0 : if (r < 0) {
838 : 0 : free(d);
839 [ # # ]: 0 : return log_error_errno(r, "Failed to insert JSON name into hashmap: %m");
840 : : }
841 : :
842 : 0 : d->name = TAKE_PTR(n);
843 : : }
844 : :
845 : 0 : d->values[d->n_values++] = TAKE_PTR(v);
846 : 0 : return 0;
847 : : }
848 : :
849 : 0 : static int update_json_data_split(
850 : : Hashmap *h,
851 : : OutputFlags flags,
852 : : Set *output_fields,
853 : : const void *data,
854 : : size_t size) {
855 : :
856 : : const char *eq;
857 : : char *name;
858 : :
859 [ # # ]: 0 : assert(h);
860 [ # # # # ]: 0 : assert(data || size == 0);
861 : :
862 [ # # ]: 0 : if (memory_startswith(data, size, "_BOOT_ID="))
863 : 0 : return 0;
864 : :
865 : 0 : eq = memchr(data, '=', MIN(size, JSON_THRESHOLD));
866 [ # # ]: 0 : if (!eq)
867 : 0 : return 0;
868 : :
869 [ # # ]: 0 : if (eq == data)
870 : 0 : return 0;
871 : :
872 : 0 : name = strndupa(data, eq - (const char*) data);
873 [ # # # # ]: 0 : if (output_fields && !set_get(output_fields, name))
874 : 0 : return 0;
875 : :
876 : 0 : return update_json_data(h, flags, name, eq + 1, size - (eq - (const char*) data) - 1);
877 : : }
878 : :
879 : 0 : static int output_json(
880 : : FILE *f,
881 : : sd_journal *j,
882 : : OutputMode mode,
883 : : unsigned n_columns,
884 : : OutputFlags flags,
885 : : Set *output_fields,
886 : : const size_t highlight[2]) {
887 : :
888 : : char sid[SD_ID128_STRING_MAX], usecbuf[DECIMAL_STR_MAX(usec_t)];
889 : 0 : _cleanup_(json_variant_unrefp) JsonVariant *object = NULL;
890 : 0 : _cleanup_free_ char *cursor = NULL;
891 : : uint64_t realtime, monotonic;
892 : 0 : JsonVariant **array = NULL;
893 : : struct json_data *d;
894 : : sd_id128_t boot_id;
895 : 0 : Hashmap *h = NULL;
896 : 0 : size_t n = 0;
897 : : Iterator i;
898 : : int r;
899 : :
900 [ # # ]: 0 : assert(j);
901 : :
902 [ # # ]: 0 : (void) sd_journal_set_data_threshold(j, flags & OUTPUT_SHOW_ALL ? 0 : JSON_THRESHOLD);
903 : :
904 : 0 : r = sd_journal_get_realtime_usec(j, &realtime);
905 [ # # ]: 0 : if (r < 0)
906 [ # # ]: 0 : return log_error_errno(r, "Failed to get realtime timestamp: %m");
907 : :
908 : 0 : r = sd_journal_get_monotonic_usec(j, &monotonic, &boot_id);
909 [ # # ]: 0 : if (r < 0)
910 [ # # ]: 0 : return log_error_errno(r, "Failed to get monotonic timestamp: %m");
911 : :
912 : 0 : r = sd_journal_get_cursor(j, &cursor);
913 [ # # ]: 0 : if (r < 0)
914 [ # # ]: 0 : return log_error_errno(r, "Failed to get cursor: %m");
915 : :
916 : 0 : h = hashmap_new(&string_hash_ops);
917 [ # # ]: 0 : if (!h)
918 : 0 : return log_oom();
919 : :
920 : 0 : r = update_json_data(h, flags, "__CURSOR", cursor, strlen(cursor));
921 [ # # ]: 0 : if (r < 0)
922 : 0 : goto finish;
923 : :
924 [ # # ]: 0 : xsprintf(usecbuf, USEC_FMT, realtime);
925 : 0 : r = update_json_data(h, flags, "__REALTIME_TIMESTAMP", usecbuf, strlen(usecbuf));
926 [ # # ]: 0 : if (r < 0)
927 : 0 : goto finish;
928 : :
929 [ # # ]: 0 : xsprintf(usecbuf, USEC_FMT, monotonic);
930 : 0 : r = update_json_data(h, flags, "__MONOTONIC_TIMESTAMP", usecbuf, strlen(usecbuf));
931 [ # # ]: 0 : if (r < 0)
932 : 0 : goto finish;
933 : :
934 : 0 : sd_id128_to_string(boot_id, sid);
935 : 0 : r = update_json_data(h, flags, "_BOOT_ID", sid, strlen(sid));
936 [ # # ]: 0 : if (r < 0)
937 : 0 : goto finish;
938 : :
939 : 0 : for (;;) {
940 : : const void *data;
941 : : size_t size;
942 : :
943 : 0 : r = sd_journal_enumerate_data(j, &data, &size);
944 [ # # ]: 0 : if (r == -EBADMSG) {
945 [ # # ]: 0 : log_debug_errno(r, "Skipping message we can't read: %m");
946 : 0 : r = 0;
947 : 0 : goto finish;
948 : : }
949 [ # # ]: 0 : if (r < 0) {
950 [ # # ]: 0 : log_error_errno(r, "Failed to read journal: %m");
951 : 0 : goto finish;
952 : : }
953 [ # # ]: 0 : if (r == 0)
954 : 0 : break;
955 : :
956 : 0 : r = update_json_data_split(h, flags, output_fields, data, size);
957 [ # # ]: 0 : if (r < 0)
958 : 0 : goto finish;
959 : : }
960 : :
961 : 0 : array = new(JsonVariant*, hashmap_size(h)*2);
962 [ # # ]: 0 : if (!array) {
963 : 0 : r = log_oom();
964 : 0 : goto finish;
965 : : }
966 : :
967 [ # # ]: 0 : HASHMAP_FOREACH(d, h, i) {
968 [ # # ]: 0 : assert(d->n_values > 0);
969 : :
970 : 0 : array[n++] = json_variant_ref(d->name);
971 : :
972 [ # # ]: 0 : if (d->n_values == 1)
973 : 0 : array[n++] = json_variant_ref(d->values[0]);
974 : : else {
975 [ # # ]: 0 : _cleanup_(json_variant_unrefp) JsonVariant *q = NULL;
976 : :
977 : 0 : r = json_variant_new_array(&q, d->values, d->n_values);
978 [ # # ]: 0 : if (r < 0) {
979 [ # # ]: 0 : log_error_errno(r, "Failed to create JSON array: %m");
980 : 0 : goto finish;
981 : : }
982 : :
983 : 0 : array[n++] = TAKE_PTR(q);
984 : : }
985 : : }
986 : :
987 : 0 : r = json_variant_new_object(&object, array, n);
988 [ # # ]: 0 : if (r < 0) {
989 [ # # ]: 0 : log_error_errno(r, "Failed to allocate JSON object: %m");
990 : 0 : goto finish;
991 : : }
992 : :
993 : 0 : json_variant_dump(object,
994 : 0 : output_mode_to_json_format_flags(mode) |
995 : 0 : (FLAGS_SET(flags, OUTPUT_COLOR) ? JSON_FORMAT_COLOR : 0),
996 : : f, NULL);
997 : :
998 : 0 : r = 0;
999 : :
1000 : 0 : finish:
1001 [ # # ]: 0 : while ((d = hashmap_steal_first(h))) {
1002 : : size_t k;
1003 : :
1004 : 0 : json_variant_unref(d->name);
1005 [ # # ]: 0 : for (k = 0; k < d->n_values; k++)
1006 : 0 : json_variant_unref(d->values[k]);
1007 : :
1008 : 0 : free(d);
1009 : : }
1010 : :
1011 : 0 : hashmap_free(h);
1012 : :
1013 : 0 : json_variant_unref_many(array, n);
1014 : 0 : free(array);
1015 : :
1016 : 0 : return r;
1017 : : }
1018 : :
1019 : 0 : static int output_cat(
1020 : : FILE *f,
1021 : : sd_journal *j,
1022 : : OutputMode mode,
1023 : : unsigned n_columns,
1024 : : OutputFlags flags,
1025 : : Set *output_fields,
1026 : : const size_t highlight[2]) {
1027 : :
1028 : : const void *data;
1029 : : size_t l;
1030 : : int r;
1031 : 0 : const char *highlight_on = "", *highlight_off = "";
1032 : :
1033 [ # # ]: 0 : assert(j);
1034 [ # # ]: 0 : assert(f);
1035 : :
1036 [ # # ]: 0 : if (flags & OUTPUT_COLOR) {
1037 : 0 : highlight_on = ANSI_HIGHLIGHT_RED;
1038 : 0 : highlight_off = ANSI_NORMAL;
1039 : : }
1040 : :
1041 : 0 : sd_journal_set_data_threshold(j, 0);
1042 : :
1043 : 0 : r = sd_journal_get_data(j, "MESSAGE", &data, &l);
1044 [ # # ]: 0 : if (r == -EBADMSG) {
1045 [ # # ]: 0 : log_debug_errno(r, "Skipping message we can't read: %m");
1046 : 0 : return 0;
1047 : : }
1048 [ # # ]: 0 : if (r < 0) {
1049 : : /* An entry without MESSAGE=? */
1050 [ # # ]: 0 : if (r == -ENOENT)
1051 : 0 : return 0;
1052 : :
1053 [ # # ]: 0 : return log_error_errno(r, "Failed to get data: %m");
1054 : : }
1055 : :
1056 [ # # ]: 0 : assert(l >= 8);
1057 : :
1058 [ # # # # ]: 0 : if (highlight && (flags & OUTPUT_COLOR)) {
1059 [ # # ]: 0 : assert(highlight[0] <= highlight[1]);
1060 [ # # ]: 0 : assert(highlight[1] <= l - 8);
1061 : :
1062 : 0 : fwrite((const char*) data + 8, 1, highlight[0], f);
1063 : 0 : fwrite(highlight_on, 1, strlen(highlight_on), f);
1064 : 0 : fwrite((const char*) data + 8 + highlight[0], 1, highlight[1] - highlight[0], f);
1065 : 0 : fwrite(highlight_off, 1, strlen(highlight_off), f);
1066 : 0 : fwrite((const char*) data + 8 + highlight[1], 1, l - 8 - highlight[1], f);
1067 : : } else
1068 : 0 : fwrite((const char*) data + 8, 1, l - 8, f);
1069 : 0 : fputc('\n', f);
1070 : :
1071 : 0 : return 0;
1072 : : }
1073 : :
1074 : : static int (*output_funcs[_OUTPUT_MODE_MAX])(
1075 : : FILE *f,
1076 : : sd_journal *j,
1077 : : OutputMode mode,
1078 : : unsigned n_columns,
1079 : : OutputFlags flags,
1080 : : Set *output_fields,
1081 : : const size_t highlight[2]) = {
1082 : :
1083 : : [OUTPUT_SHORT] = output_short,
1084 : : [OUTPUT_SHORT_ISO] = output_short,
1085 : : [OUTPUT_SHORT_ISO_PRECISE] = output_short,
1086 : : [OUTPUT_SHORT_PRECISE] = output_short,
1087 : : [OUTPUT_SHORT_MONOTONIC] = output_short,
1088 : : [OUTPUT_SHORT_UNIX] = output_short,
1089 : : [OUTPUT_SHORT_FULL] = output_short,
1090 : : [OUTPUT_VERBOSE] = output_verbose,
1091 : : [OUTPUT_EXPORT] = output_export,
1092 : : [OUTPUT_JSON] = output_json,
1093 : : [OUTPUT_JSON_PRETTY] = output_json,
1094 : : [OUTPUT_JSON_SSE] = output_json,
1095 : : [OUTPUT_JSON_SEQ] = output_json,
1096 : : [OUTPUT_CAT] = output_cat,
1097 : : [OUTPUT_WITH_UNIT] = output_short,
1098 : : };
1099 : :
1100 : 0 : int show_journal_entry(
1101 : : FILE *f,
1102 : : sd_journal *j,
1103 : : OutputMode mode,
1104 : : unsigned n_columns,
1105 : : OutputFlags flags,
1106 : : char **output_fields,
1107 : : const size_t highlight[2],
1108 : : bool *ellipsized) {
1109 : :
1110 : : int ret;
1111 : 0 : _cleanup_set_free_free_ Set *fields = NULL;
1112 [ # # ]: 0 : assert(mode >= 0);
1113 [ # # ]: 0 : assert(mode < _OUTPUT_MODE_MAX);
1114 : :
1115 [ # # ]: 0 : if (n_columns <= 0)
1116 : 0 : n_columns = columns();
1117 : :
1118 [ # # ]: 0 : if (output_fields) {
1119 : 0 : fields = set_new(&string_hash_ops);
1120 [ # # ]: 0 : if (!fields)
1121 : 0 : return log_oom();
1122 : :
1123 : 0 : ret = set_put_strdupv(fields, output_fields);
1124 [ # # ]: 0 : if (ret < 0)
1125 : 0 : return ret;
1126 : : }
1127 : :
1128 : 0 : ret = output_funcs[mode](f, j, mode, n_columns, flags, fields, highlight);
1129 : :
1130 [ # # # # ]: 0 : if (ellipsized && ret > 0)
1131 : 0 : *ellipsized = true;
1132 : :
1133 : 0 : return ret;
1134 : : }
1135 : :
1136 : 0 : static int maybe_print_begin_newline(FILE *f, OutputFlags *flags) {
1137 [ # # ]: 0 : assert(f);
1138 [ # # ]: 0 : assert(flags);
1139 : :
1140 [ # # ]: 0 : if (!(*flags & OUTPUT_BEGIN_NEWLINE))
1141 : 0 : return 0;
1142 : :
1143 : : /* Print a beginning new line if that's request, but only once
1144 : : * on the first line we print. */
1145 : :
1146 : 0 : fputc('\n', f);
1147 : 0 : *flags &= ~OUTPUT_BEGIN_NEWLINE;
1148 : 0 : return 0;
1149 : : }
1150 : :
1151 : 0 : int show_journal(
1152 : : FILE *f,
1153 : : sd_journal *j,
1154 : : OutputMode mode,
1155 : : unsigned n_columns,
1156 : : usec_t not_before,
1157 : : unsigned how_many,
1158 : : OutputFlags flags,
1159 : : bool *ellipsized) {
1160 : :
1161 : : int r;
1162 : 0 : unsigned line = 0;
1163 : 0 : bool need_seek = false;
1164 : 0 : int warn_cutoff = flags & OUTPUT_WARN_CUTOFF;
1165 : :
1166 [ # # ]: 0 : assert(j);
1167 [ # # ]: 0 : assert(mode >= 0);
1168 [ # # ]: 0 : assert(mode < _OUTPUT_MODE_MAX);
1169 : :
1170 [ # # ]: 0 : if (how_many == (unsigned) -1)
1171 : 0 : need_seek = true;
1172 : : else {
1173 : : /* Seek to end */
1174 : 0 : r = sd_journal_seek_tail(j);
1175 [ # # ]: 0 : if (r < 0)
1176 [ # # ]: 0 : return log_error_errno(r, "Failed to seek to tail: %m");
1177 : :
1178 : 0 : r = sd_journal_previous_skip(j, how_many);
1179 [ # # ]: 0 : if (r < 0)
1180 [ # # ]: 0 : return log_error_errno(r, "Failed to skip previous: %m");
1181 : : }
1182 : :
1183 : 0 : for (;;) {
1184 : 0 : for (;;) {
1185 : : usec_t usec;
1186 : :
1187 [ # # ]: 0 : if (need_seek) {
1188 : 0 : r = sd_journal_next(j);
1189 [ # # ]: 0 : if (r < 0)
1190 [ # # ]: 0 : return log_error_errno(r, "Failed to iterate through journal: %m");
1191 : : }
1192 : :
1193 [ # # ]: 0 : if (r == 0)
1194 : 0 : break;
1195 : :
1196 : 0 : need_seek = true;
1197 : :
1198 [ # # ]: 0 : if (not_before > 0) {
1199 : 0 : r = sd_journal_get_monotonic_usec(j, &usec, NULL);
1200 : :
1201 : : /* -ESTALE is returned if the
1202 : : timestamp is not from this boot */
1203 [ # # ]: 0 : if (r == -ESTALE)
1204 : 0 : continue;
1205 [ # # ]: 0 : else if (r < 0)
1206 [ # # ]: 0 : return log_error_errno(r, "Failed to get journal time: %m");
1207 : :
1208 [ # # ]: 0 : if (usec < not_before)
1209 : 0 : continue;
1210 : : }
1211 : :
1212 : 0 : line++;
1213 : 0 : maybe_print_begin_newline(f, &flags);
1214 : :
1215 : 0 : r = show_journal_entry(f, j, mode, n_columns, flags, NULL, NULL, ellipsized);
1216 [ # # ]: 0 : if (r < 0)
1217 : 0 : return r;
1218 : : }
1219 : :
1220 [ # # # # : 0 : if (warn_cutoff && line < how_many && not_before > 0) {
# # ]
1221 : : sd_id128_t boot_id;
1222 : 0 : usec_t cutoff = 0;
1223 : :
1224 : : /* Check whether the cutoff line is too early */
1225 : :
1226 : 0 : r = sd_id128_get_boot(&boot_id);
1227 [ # # ]: 0 : if (r < 0)
1228 [ # # ]: 0 : return log_error_errno(r, "Failed to get boot id: %m");
1229 : :
1230 : 0 : r = sd_journal_get_cutoff_monotonic_usec(j, boot_id, &cutoff, NULL);
1231 [ # # ]: 0 : if (r < 0)
1232 [ # # ]: 0 : return log_error_errno(r, "Failed to get journal cutoff time: %m");
1233 : :
1234 [ # # # # ]: 0 : if (r > 0 && not_before < cutoff) {
1235 : 0 : maybe_print_begin_newline(f, &flags);
1236 : 0 : fprintf(f, "Warning: Journal has been rotated since unit was started. Log output is incomplete or unavailable.\n");
1237 : : }
1238 : :
1239 : 0 : warn_cutoff = false;
1240 : : }
1241 : :
1242 [ # # ]: 0 : if (!(flags & OUTPUT_FOLLOW))
1243 : 0 : break;
1244 : :
1245 : 0 : r = sd_journal_wait(j, USEC_INFINITY);
1246 [ # # ]: 0 : if (r < 0)
1247 [ # # ]: 0 : return log_error_errno(r, "Failed to wait for journal: %m");
1248 : :
1249 : : }
1250 : :
1251 : 0 : return 0;
1252 : : }
1253 : :
1254 : 0 : int add_matches_for_unit(sd_journal *j, const char *unit) {
1255 : : const char *m1, *m2, *m3, *m4;
1256 : : int r;
1257 : :
1258 [ # # ]: 0 : assert(j);
1259 [ # # ]: 0 : assert(unit);
1260 : :
1261 [ # # # # : 0 : m1 = strjoina("_SYSTEMD_UNIT=", unit);
# # # # #
# # # ]
1262 [ # # # # : 0 : m2 = strjoina("COREDUMP_UNIT=", unit);
# # # # #
# # # ]
1263 [ # # # # : 0 : m3 = strjoina("UNIT=", unit);
# # # # #
# # # ]
1264 [ # # # # : 0 : m4 = strjoina("OBJECT_SYSTEMD_UNIT=", unit);
# # # # #
# # # ]
1265 : :
1266 [ # # ]: 0 : (void)(
1267 : : /* Look for messages from the service itself */
1268 [ # # ]: 0 : (r = sd_journal_add_match(j, m1, 0)) ||
1269 : :
1270 : : /* Look for coredumps of the service */
1271 [ # # ]: 0 : (r = sd_journal_add_disjunction(j)) ||
1272 [ # # ]: 0 : (r = sd_journal_add_match(j, "MESSAGE_ID=fc2e22bc6ee647b6b90729ab34a250b1", 0)) ||
1273 [ # # ]: 0 : (r = sd_journal_add_match(j, "_UID=0", 0)) ||
1274 [ # # ]: 0 : (r = sd_journal_add_match(j, m2, 0)) ||
1275 : :
1276 : : /* Look for messages from PID 1 about this service */
1277 [ # # ]: 0 : (r = sd_journal_add_disjunction(j)) ||
1278 [ # # ]: 0 : (r = sd_journal_add_match(j, "_PID=1", 0)) ||
1279 [ # # ]: 0 : (r = sd_journal_add_match(j, m3, 0)) ||
1280 : :
1281 : : /* Look for messages from authorized daemons about this service */
1282 [ # # ]: 0 : (r = sd_journal_add_disjunction(j)) ||
1283 [ # # ]: 0 : (r = sd_journal_add_match(j, "_UID=0", 0)) ||
1284 : 0 : (r = sd_journal_add_match(j, m4, 0))
1285 : : );
1286 : :
1287 [ # # # # ]: 0 : if (r == 0 && endswith(unit, ".slice")) {
1288 : : const char *m5;
1289 : :
1290 [ # # # # : 0 : m5 = strjoina("_SYSTEMD_SLICE=", unit);
# # # # #
# # # ]
1291 : :
1292 : : /* Show all messages belonging to a slice */
1293 [ # # ]: 0 : (void)(
1294 [ # # ]: 0 : (r = sd_journal_add_disjunction(j)) ||
1295 : 0 : (r = sd_journal_add_match(j, m5, 0))
1296 : : );
1297 : : }
1298 : :
1299 : 0 : return r;
1300 : : }
1301 : :
1302 : 0 : int add_matches_for_user_unit(sd_journal *j, const char *unit, uid_t uid) {
1303 : : int r;
1304 : : char *m1, *m2, *m3, *m4;
1305 : : char muid[sizeof("_UID=") + DECIMAL_STR_MAX(uid_t)];
1306 : :
1307 [ # # ]: 0 : assert(j);
1308 [ # # ]: 0 : assert(unit);
1309 : :
1310 [ # # # # : 0 : m1 = strjoina("_SYSTEMD_USER_UNIT=", unit);
# # # # #
# # # ]
1311 [ # # # # : 0 : m2 = strjoina("USER_UNIT=", unit);
# # # # #
# # # ]
1312 [ # # # # : 0 : m3 = strjoina("COREDUMP_USER_UNIT=", unit);
# # # # #
# # # ]
1313 [ # # # # : 0 : m4 = strjoina("OBJECT_SYSTEMD_USER_UNIT=", unit);
# # # # #
# # # ]
1314 : 0 : sprintf(muid, "_UID="UID_FMT, uid);
1315 : :
1316 [ # # ]: 0 : (void) (
1317 : : /* Look for messages from the user service itself */
1318 [ # # ]: 0 : (r = sd_journal_add_match(j, m1, 0)) ||
1319 [ # # ]: 0 : (r = sd_journal_add_match(j, muid, 0)) ||
1320 : :
1321 : : /* Look for messages from systemd about this service */
1322 [ # # ]: 0 : (r = sd_journal_add_disjunction(j)) ||
1323 [ # # ]: 0 : (r = sd_journal_add_match(j, m2, 0)) ||
1324 [ # # ]: 0 : (r = sd_journal_add_match(j, muid, 0)) ||
1325 : :
1326 : : /* Look for coredumps of the service */
1327 [ # # ]: 0 : (r = sd_journal_add_disjunction(j)) ||
1328 [ # # ]: 0 : (r = sd_journal_add_match(j, m3, 0)) ||
1329 [ # # ]: 0 : (r = sd_journal_add_match(j, muid, 0)) ||
1330 [ # # ]: 0 : (r = sd_journal_add_match(j, "_UID=0", 0)) ||
1331 : :
1332 : : /* Look for messages from authorized daemons about this service */
1333 [ # # ]: 0 : (r = sd_journal_add_disjunction(j)) ||
1334 [ # # ]: 0 : (r = sd_journal_add_match(j, m4, 0)) ||
1335 [ # # ]: 0 : (r = sd_journal_add_match(j, muid, 0)) ||
1336 : 0 : (r = sd_journal_add_match(j, "_UID=0", 0))
1337 : : );
1338 : :
1339 [ # # # # ]: 0 : if (r == 0 && endswith(unit, ".slice")) {
1340 : : const char *m5;
1341 : :
1342 [ # # # # : 0 : m5 = strjoina("_SYSTEMD_SLICE=", unit);
# # # # #
# # # ]
1343 : :
1344 : : /* Show all messages belonging to a slice */
1345 [ # # ]: 0 : (void)(
1346 [ # # ]: 0 : (r = sd_journal_add_disjunction(j)) ||
1347 [ # # ]: 0 : (r = sd_journal_add_match(j, m5, 0)) ||
1348 : 0 : (r = sd_journal_add_match(j, muid, 0))
1349 : : );
1350 : : }
1351 : :
1352 : 0 : return r;
1353 : : }
1354 : :
1355 : 0 : static int get_boot_id_for_machine(const char *machine, sd_id128_t *boot_id) {
1356 : 0 : _cleanup_close_pair_ int pair[2] = { -1, -1 };
1357 : 0 : _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, rootfd = -1;
1358 : : pid_t pid, child;
1359 : : char buf[37];
1360 : : ssize_t k;
1361 : : int r;
1362 : :
1363 [ # # ]: 0 : assert(machine);
1364 [ # # ]: 0 : assert(boot_id);
1365 : :
1366 [ # # ]: 0 : if (!machine_name_is_valid(machine))
1367 : 0 : return -EINVAL;
1368 : :
1369 : 0 : r = container_get_leader(machine, &pid);
1370 [ # # ]: 0 : if (r < 0)
1371 : 0 : return r;
1372 : :
1373 : 0 : r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, NULL, &rootfd);
1374 [ # # ]: 0 : if (r < 0)
1375 : 0 : return r;
1376 : :
1377 [ # # ]: 0 : if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
1378 : 0 : return -errno;
1379 : :
1380 : 0 : r = namespace_fork("(sd-bootidns)", "(sd-bootid)", NULL, 0, FORK_RESET_SIGNALS|FORK_DEATHSIG,
1381 : : pidnsfd, mntnsfd, -1, -1, rootfd, &child);
1382 [ # # ]: 0 : if (r < 0)
1383 : 0 : return r;
1384 [ # # ]: 0 : if (r == 0) {
1385 : : int fd;
1386 : :
1387 : 0 : pair[0] = safe_close(pair[0]);
1388 : :
1389 : 0 : fd = open("/proc/sys/kernel/random/boot_id", O_RDONLY|O_CLOEXEC|O_NOCTTY);
1390 [ # # ]: 0 : if (fd < 0)
1391 : 0 : _exit(EXIT_FAILURE);
1392 : :
1393 : 0 : r = loop_read_exact(fd, buf, 36, false);
1394 : 0 : safe_close(fd);
1395 [ # # ]: 0 : if (r < 0)
1396 : 0 : _exit(EXIT_FAILURE);
1397 : :
1398 : 0 : k = send(pair[1], buf, 36, MSG_NOSIGNAL);
1399 [ # # ]: 0 : if (k != 36)
1400 : 0 : _exit(EXIT_FAILURE);
1401 : :
1402 : 0 : _exit(EXIT_SUCCESS);
1403 : : }
1404 : :
1405 : 0 : pair[1] = safe_close(pair[1]);
1406 : :
1407 : 0 : r = wait_for_terminate_and_check("(sd-bootidns)", child, 0);
1408 [ # # ]: 0 : if (r < 0)
1409 : 0 : return r;
1410 [ # # ]: 0 : if (r != EXIT_SUCCESS)
1411 : 0 : return -EIO;
1412 : :
1413 : 0 : k = recv(pair[0], buf, 36, 0);
1414 [ # # ]: 0 : if (k != 36)
1415 : 0 : return -EIO;
1416 : :
1417 : 0 : buf[36] = 0;
1418 : 0 : r = sd_id128_from_string(buf, boot_id);
1419 [ # # ]: 0 : if (r < 0)
1420 : 0 : return r;
1421 : :
1422 : 0 : return 0;
1423 : : }
1424 : :
1425 : 0 : int add_match_this_boot(sd_journal *j, const char *machine) {
1426 : 0 : char match[9+32+1] = "_BOOT_ID=";
1427 : : sd_id128_t boot_id;
1428 : : int r;
1429 : :
1430 [ # # ]: 0 : assert(j);
1431 : :
1432 [ # # ]: 0 : if (machine) {
1433 : 0 : r = get_boot_id_for_machine(machine, &boot_id);
1434 [ # # ]: 0 : if (r < 0)
1435 [ # # ]: 0 : return log_error_errno(r, "Failed to get boot id of container %s: %m", machine);
1436 : : } else {
1437 : 0 : r = sd_id128_get_boot(&boot_id);
1438 [ # # ]: 0 : if (r < 0)
1439 [ # # ]: 0 : return log_error_errno(r, "Failed to get boot id: %m");
1440 : : }
1441 : :
1442 : 0 : sd_id128_to_string(boot_id, match + 9);
1443 : 0 : r = sd_journal_add_match(j, match, strlen(match));
1444 [ # # ]: 0 : if (r < 0)
1445 [ # # ]: 0 : return log_error_errno(r, "Failed to add match: %m");
1446 : :
1447 : 0 : r = sd_journal_add_conjunction(j);
1448 [ # # ]: 0 : if (r < 0)
1449 [ # # ]: 0 : return log_error_errno(r, "Failed to add conjunction: %m");
1450 : :
1451 : 0 : return 0;
1452 : : }
1453 : :
1454 : 0 : int show_journal_by_unit(
1455 : : FILE *f,
1456 : : const char *unit,
1457 : : OutputMode mode,
1458 : : unsigned n_columns,
1459 : : usec_t not_before,
1460 : : unsigned how_many,
1461 : : uid_t uid,
1462 : : OutputFlags flags,
1463 : : int journal_open_flags,
1464 : : bool system_unit,
1465 : : bool *ellipsized) {
1466 : :
1467 : 0 : _cleanup_(sd_journal_closep) sd_journal *j = NULL;
1468 : : int r;
1469 : :
1470 [ # # ]: 0 : assert(mode >= 0);
1471 [ # # ]: 0 : assert(mode < _OUTPUT_MODE_MAX);
1472 [ # # ]: 0 : assert(unit);
1473 : :
1474 [ # # ]: 0 : if (how_many <= 0)
1475 : 0 : return 0;
1476 : :
1477 : 0 : r = sd_journal_open(&j, journal_open_flags);
1478 [ # # ]: 0 : if (r < 0)
1479 [ # # ]: 0 : return log_error_errno(r, "Failed to open journal: %m");
1480 : :
1481 : 0 : r = add_match_this_boot(j, NULL);
1482 [ # # ]: 0 : if (r < 0)
1483 : 0 : return r;
1484 : :
1485 [ # # ]: 0 : if (system_unit)
1486 : 0 : r = add_matches_for_unit(j, unit);
1487 : : else
1488 : 0 : r = add_matches_for_user_unit(j, unit, uid);
1489 [ # # ]: 0 : if (r < 0)
1490 [ # # ]: 0 : return log_error_errno(r, "Failed to add unit matches: %m");
1491 : :
1492 [ # # ]: 0 : if (DEBUG_LOGGING) {
1493 [ # # ]: 0 : _cleanup_free_ char *filter;
1494 : :
1495 : 0 : filter = journal_make_match_string(j);
1496 [ # # ]: 0 : if (!filter)
1497 : 0 : return log_oom();
1498 : :
1499 [ # # ]: 0 : log_debug("Journal filter: %s", filter);
1500 : : }
1501 : :
1502 : 0 : return show_journal(f, j, mode, n_columns, not_before, how_many, flags, ellipsized);
1503 : : }
|
