]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/sd-journal.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
journal: remember last direction of search and keep offset cache
[thirdparty/systemd.git] / src / journal / sd-journal.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2011 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <stddef.h>
25 #include <unistd.h>
26 #include <sys/inotify.h>
27 #include <sys/poll.h>
28 #include <sys/vfs.h>
29 #include <linux/magic.h>
30
31 #include "sd-journal.h"
32 #include "journal-def.h"
33 #include "journal-file.h"
34 #include "hashmap.h"
35 #include "list.h"
36 #include "strv.h"
37 #include "path-util.h"
38 #include "lookup3.h"
39 #include "compress.h"
40 #include "journal-internal.h"
41 #include "missing.h"
42 #include "catalog.h"
43 #include "replace-var.h"
44
45 #define JOURNAL_FILES_MAX 1024
46
47 #define JOURNAL_FILES_RECHECK_USEC (2 * USEC_PER_SEC)
48
49 #define REPLACE_VAR_MAX 256
50
51 #define DEFAULT_DATA_THRESHOLD (64*1024)
52
53 /* We return an error here only if we didn't manage to
54 memorize the real error. */
55 static int set_put_error(sd_journal *j, int r) {
56 int k;
57
58 if (r >= 0)
59 return r;
60
61 k = set_ensure_allocated(&j->errors, trivial_hash_func, trivial_compare_func);
62 if (k < 0)
63 return k;
64
65 return set_put(j->errors, INT_TO_PTR(r));
66 }
67
68 static void detach_location(sd_journal *j) {
69 Iterator i;
70 JournalFile *f;
71
72 assert(j);
73
74 j->current_file = NULL;
75 j->current_field = 0;
76
77 HASHMAP_FOREACH(f, j->files, i)
78 f->current_offset = 0;
79 }
80
81 static void reset_location(sd_journal *j) {
82 assert(j);
83
84 detach_location(j);
85 zero(j->current_location);
86 }
87
88 static void init_location(Location *l, LocationType type, JournalFile *f, Object *o) {
89 assert(l);
90 assert(type == LOCATION_DISCRETE || type == LOCATION_SEEK);
91 assert(f);
92 assert(o->object.type == OBJECT_ENTRY);
93
94 l->type = type;
95 l->seqnum = le64toh(o->entry.seqnum);
96 l->seqnum_id = f->header->seqnum_id;
97 l->realtime = le64toh(o->entry.realtime);
98 l->monotonic = le64toh(o->entry.monotonic);
99 l->boot_id = o->entry.boot_id;
100 l->xor_hash = le64toh(o->entry.xor_hash);
101
102 l->seqnum_set = l->realtime_set = l->monotonic_set = l->xor_hash_set = true;
103 }
104
105 static void set_location(sd_journal *j, LocationType type, JournalFile *f, Object *o,
106 direction_t direction, uint64_t offset) {
107 assert(j);
108 assert(type == LOCATION_DISCRETE || type == LOCATION_SEEK);
109 assert(f);
110 assert(o);
111
112 init_location(&j->current_location, type, f, o);
113
114 j->current_file = f;
115 j->current_field = 0;
116
117 f->last_direction = direction;
118 f->current_offset = offset;
119 }
120
121 static int match_is_valid(const void *data, size_t size) {
122 const char *b, *p;
123
124 assert(data);
125
126 if (size < 2)
127 return false;
128
129 if (startswith(data, "__"))
130 return false;
131
132 b = data;
133 for (p = b; p < b + size; p++) {
134
135 if (*p == '=')
136 return p > b;
137
138 if (*p == '_')
139 continue;
140
141 if (*p >= 'A' && *p <= 'Z')
142 continue;
143
144 if (*p >= '0' && *p <= '9')
145 continue;
146
147 return false;
148 }
149
150 return false;
151 }
152
153 static bool same_field(const void *_a, size_t s, const void *_b, size_t t) {
154 const uint8_t *a = _a, *b = _b;
155 size_t j;
156
157 for (j = 0; j < s && j < t; j++) {
158
159 if (a[j] != b[j])
160 return false;
161
162 if (a[j] == '=')
163 return true;
164 }
165
166 return true;
167 }
168
169 static Match *match_new(Match *p, MatchType t) {
170 Match *m;
171
172 m = new0(Match, 1);
173 if (!m)
174 return NULL;
175
176 m->type = t;
177
178 if (p) {
179 m->parent = p;
180 LIST_PREPEND(Match, matches, p->matches, m);
181 }
182
183 return m;
184 }
185
186 static void match_free(Match *m) {
187 assert(m);
188
189 while (m->matches)
190 match_free(m->matches);
191
192 if (m->parent)
193 LIST_REMOVE(Match, matches, m->parent->matches, m);
194
195 free(m->data);
196 free(m);
197 }
198
199 static void match_free_if_empty(Match *m) {
200 if (!m || m->matches)
201 return;
202
203 match_free(m);
204 }
205
206 _public_ int sd_journal_add_match(sd_journal *j, const void *data, size_t size) {
207 Match *l3, *l4, *add_here = NULL, *m;
208 le64_t le_hash;
209
210 if (!j)
211 return -EINVAL;
212
213 if (!data)
214 return -EINVAL;
215
216 if (size == 0)
217 size = strlen(data);
218
219 if (!match_is_valid(data, size))
220 return -EINVAL;
221
222 /* level 0: AND term
223 * level 1: OR terms
224 * level 2: AND terms
225 * level 3: OR terms
226 * level 4: concrete matches */
227
228 if (!j->level0) {
229 j->level0 = match_new(NULL, MATCH_AND_TERM);
230 if (!j->level0)
231 return -ENOMEM;
232 }
233
234 if (!j->level1) {
235 j->level1 = match_new(j->level0, MATCH_OR_TERM);
236 if (!j->level1)
237 return -ENOMEM;
238 }
239
240 if (!j->level2) {
241 j->level2 = match_new(j->level1, MATCH_AND_TERM);
242 if (!j->level2)
243 return -ENOMEM;
244 }
245
246 assert(j->level0->type == MATCH_AND_TERM);
247 assert(j->level1->type == MATCH_OR_TERM);
248 assert(j->level2->type == MATCH_AND_TERM);
249
250 le_hash = htole64(hash64(data, size));
251
252 LIST_FOREACH(matches, l3, j->level2->matches) {
253 assert(l3->type == MATCH_OR_TERM);
254
255 LIST_FOREACH(matches, l4, l3->matches) {
256 assert(l4->type == MATCH_DISCRETE);
257
258 /* Exactly the same match already? Then ignore
259 * this addition */
260 if (l4->le_hash == le_hash &&
261 l4->size == size &&
262 memcmp(l4->data, data, size) == 0)
263 return 0;
264
265 /* Same field? Then let's add this to this OR term */
266 if (same_field(data, size, l4->data, l4->size)) {
267 add_here = l3;
268 break;
269 }
270 }
271
272 if (add_here)
273 break;
274 }
275
276 if (!add_here) {
277 add_here = match_new(j->level2, MATCH_OR_TERM);
278 if (!add_here)
279 goto fail;
280 }
281
282 m = match_new(add_here, MATCH_DISCRETE);
283 if (!m)
284 goto fail;
285
286 m->le_hash = le_hash;
287 m->size = size;
288 m->data = memdup(data, size);
289 if (!m->data)
290 goto fail;
291
292 detach_location(j);
293
294 return 0;
295
296 fail:
297 match_free_if_empty(add_here);
298 match_free_if_empty(j->level2);
299 match_free_if_empty(j->level1);
300 match_free_if_empty(j->level0);
301
302 return -ENOMEM;
303 }
304
305 _public_ int sd_journal_add_conjunction(sd_journal *j) {
306 assert(j);
307
308 if (!j->level0)
309 return 0;
310
311 if (!j->level1)
312 return 0;
313
314 if (!j->level1->matches)
315 return 0;
316
317 j->level1 = NULL;
318 j->level2 = NULL;
319
320 return 0;
321 }
322
323 _public_ int sd_journal_add_disjunction(sd_journal *j) {
324 assert(j);
325
326 if (!j->level0)
327 return 0;
328
329 if (!j->level1)
330 return 0;
331
332 if (!j->level2)
333 return 0;
334
335 if (!j->level2->matches)
336 return 0;
337
338 j->level2 = NULL;
339 return 0;
340 }
341
342 static char *match_make_string(Match *m) {
343 char *p, *r;
344 Match *i;
345 bool enclose = false;
346
347 if (!m)
348 return strdup("");
349
350 if (m->type == MATCH_DISCRETE)
351 return strndup(m->data, m->size);
352
353 p = NULL;
354 LIST_FOREACH(matches, i, m->matches) {
355 char *t, *k;
356
357 t = match_make_string(i);
358 if (!t) {
359 free(p);
360 return NULL;
361 }
362
363 if (p) {
364 k = strjoin(p, m->type == MATCH_OR_TERM ? " OR " : " AND ", t, NULL);
365 free(p);
366 free(t);
367
368 if (!k)
369 return NULL;
370
371 p = k;
372
373 enclose = true;
374 } else {
375 free(p);
376 p = t;
377 }
378 }
379
380 if (enclose) {
381 r = strjoin("(", p, ")", NULL);
382 free(p);
383 return r;
384 }
385
386 return p;
387 }
388
389 char *journal_make_match_string(sd_journal *j) {
390 assert(j);
391
392 return match_make_string(j->level0);
393 }
394
395 _public_ void sd_journal_flush_matches(sd_journal *j) {
396
397 if (!j)
398 return;
399
400 if (j->level0)
401 match_free(j->level0);
402
403 j->level0 = j->level1 = j->level2 = NULL;
404
405 detach_location(j);
406 }
407
408 static int compare_entry_order(JournalFile *af, Object *_ao,
409 JournalFile *bf, uint64_t bp) {
410
411 uint64_t a, b;
412 Object *ao, *bo;
413 int r;
414
415 assert(af);
416 assert(bf);
417 assert(_ao);
418
419 /* The mmap cache might invalidate the object from the first
420 * file if we look at the one from the second file. Hence
421 * temporarily copy the header of the first one, and look at
422 * that only. */
423 ao = alloca(offsetof(EntryObject, items));
424 memcpy(ao, _ao, offsetof(EntryObject, items));
425
426 r = journal_file_move_to_object(bf, OBJECT_ENTRY, bp, &bo);
427 if (r < 0)
428 return strcmp(af->path, bf->path);
429
430 /* We operate on two different files here, hence we can access
431 * two objects at the same time, which we normally can't.
432 *
433 * If contents and timestamps match, these entries are
434 * identical, even if the seqnum does not match */
435
436 if (sd_id128_equal(ao->entry.boot_id, bo->entry.boot_id) &&
437 ao->entry.monotonic == bo->entry.monotonic &&
438 ao->entry.realtime == bo->entry.realtime &&
439 ao->entry.xor_hash == bo->entry.xor_hash)
440 return 0;
441
442 if (sd_id128_equal(af->header->seqnum_id, bf->header->seqnum_id)) {
443
444 /* If this is from the same seqnum source, compare
445 * seqnums */
446 a = le64toh(ao->entry.seqnum);
447 b = le64toh(bo->entry.seqnum);
448
449 if (a < b)
450 return -1;
451 if (a > b)
452 return 1;
453
454 /* Wow! This is weird, different data but the same
455 * seqnums? Something is borked, but let's make the
456 * best of it and compare by time. */
457 }
458
459 if (sd_id128_equal(ao->entry.boot_id, bo->entry.boot_id)) {
460
461 /* If the boot id matches compare monotonic time */
462 a = le64toh(ao->entry.monotonic);
463 b = le64toh(bo->entry.monotonic);
464
465 if (a < b)
466 return -1;
467 if (a > b)
468 return 1;
469 }
470
471 /* Otherwise compare UTC time */
472 a = le64toh(ao->entry.realtime);
473 b = le64toh(bo->entry.realtime);
474
475 if (a < b)
476 return -1;
477 if (a > b)
478 return 1;
479
480 /* Finally, compare by contents */
481 a = le64toh(ao->entry.xor_hash);
482 b = le64toh(bo->entry.xor_hash);
483
484 if (a < b)
485 return -1;
486 if (a > b)
487 return 1;
488
489 return 0;
490 }
491
492 _pure_ static int compare_with_location(JournalFile *af, Object *ao, Location *l) {
493 uint64_t a;
494
495 assert(af);
496 assert(ao);
497 assert(l);
498 assert(l->type == LOCATION_DISCRETE || l->type == LOCATION_SEEK);
499
500 if (l->monotonic_set &&
501 sd_id128_equal(ao->entry.boot_id, l->boot_id) &&
502 l->realtime_set &&
503 le64toh(ao->entry.realtime) == l->realtime &&
504 l->xor_hash_set &&
505 le64toh(ao->entry.xor_hash) == l->xor_hash)
506 return 0;
507
508 if (l->seqnum_set &&
509 sd_id128_equal(af->header->seqnum_id, l->seqnum_id)) {
510
511 a = le64toh(ao->entry.seqnum);
512
513 if (a < l->seqnum)
514 return -1;
515 if (a > l->seqnum)
516 return 1;
517 }
518
519 if (l->monotonic_set &&
520 sd_id128_equal(ao->entry.boot_id, l->boot_id)) {
521
522 a = le64toh(ao->entry.monotonic);
523
524 if (a < l->monotonic)
525 return -1;
526 if (a > l->monotonic)
527 return 1;
528 }
529
530 if (l->realtime_set) {
531
532 a = le64toh(ao->entry.realtime);
533
534 if (a < l->realtime)
535 return -1;
536 if (a > l->realtime)
537 return 1;
538 }
539
540 if (l->xor_hash_set) {
541 a = le64toh(ao->entry.xor_hash);
542
543 if (a < l->xor_hash)
544 return -1;
545 if (a > l->xor_hash)
546 return 1;
547 }
548
549 return 0;
550 }
551
552 static int next_for_match(
553 sd_journal *j,
554 Match *m,
555 JournalFile *f,
556 uint64_t after_offset,
557 direction_t direction,
558 Object **ret,
559 uint64_t *offset) {
560
561 int r;
562 uint64_t np = 0;
563 Object *n;
564
565 assert(j);
566 assert(m);
567 assert(f);
568
569 if (m->type == MATCH_DISCRETE) {
570 uint64_t dp;
571
572 r = journal_file_find_data_object_with_hash(f, m->data, m->size, le64toh(m->le_hash), NULL, &dp);
573 if (r <= 0)
574 return r;
575
576 return journal_file_move_to_entry_by_offset_for_data(f, dp, after_offset, direction, ret, offset);
577
578 } else if (m->type == MATCH_OR_TERM) {
579 Match *i;
580
581 /* Find the earliest match beyond after_offset */
582
583 LIST_FOREACH(matches, i, m->matches) {
584 uint64_t cp;
585
586 r = next_for_match(j, i, f, after_offset, direction, NULL, &cp);
587 if (r < 0)
588 return r;
589 else if (r > 0) {
590 if (np == 0 || (direction == DIRECTION_DOWN ? np > cp : np < cp))
591 np = cp;
592 }
593 }
594
595 } else if (m->type == MATCH_AND_TERM) {
596 Match *i, *last_moved;
597
598 /* Always jump to the next matching entry and repeat
599 * this until we find an offset that matches for all
600 * matches. */
601
602 if (!m->matches)
603 return 0;
604
605 r = next_for_match(j, m->matches, f, after_offset, direction, NULL, &np);
606 if (r <= 0)
607 return r;
608
609 assert(direction == DIRECTION_DOWN ? np >= after_offset : np <= after_offset);
610 last_moved = m->matches;
611
612 LIST_LOOP_BUT_ONE(matches, i, m->matches, last_moved) {
613 uint64_t cp;
614
615 r = next_for_match(j, i, f, np, direction, NULL, &cp);
616 if (r <= 0)
617 return r;
618
619 assert(direction == DIRECTION_DOWN ? cp >= np : cp <= np);
620 if (direction == DIRECTION_DOWN ? cp > np : cp < np) {
621 np = cp;
622 last_moved = i;
623 }
624 }
625 }
626
627 if (np == 0)
628 return 0;
629
630 r = journal_file_move_to_object(f, OBJECT_ENTRY, np, &n);
631 if (r < 0)
632 return r;
633
634 if (ret)
635 *ret = n;
636 if (offset)
637 *offset = np;
638
639 return 1;
640 }
641
642 static int find_location_for_match(
643 sd_journal *j,
644 Match *m,
645 JournalFile *f,
646 direction_t direction,
647 Object **ret,
648 uint64_t *offset) {
649
650 int r;
651
652 assert(j);
653 assert(m);
654 assert(f);
655
656 if (m->type == MATCH_DISCRETE) {
657 uint64_t dp;
658
659 r = journal_file_find_data_object_with_hash(f, m->data, m->size, le64toh(m->le_hash), NULL, &dp);
660 if (r <= 0)
661 return r;
662
663 /* FIXME: missing: find by monotonic */
664
665 if (j->current_location.type == LOCATION_HEAD)
666 return journal_file_next_entry_for_data(f, NULL, 0, dp, DIRECTION_DOWN, ret, offset);
667 if (j->current_location.type == LOCATION_TAIL)
668 return journal_file_next_entry_for_data(f, NULL, 0, dp, DIRECTION_UP, ret, offset);
669 if (j->current_location.seqnum_set && sd_id128_equal(j->current_location.seqnum_id, f->header->seqnum_id))
670 return journal_file_move_to_entry_by_seqnum_for_data(f, dp, j->current_location.seqnum, direction, ret, offset);
671 if (j->current_location.monotonic_set) {
672 r = journal_file_move_to_entry_by_monotonic_for_data(f, dp, j->current_location.boot_id, j->current_location.monotonic, direction, ret, offset);
673 if (r != -ENOENT)
674 return r;
675 }
676 if (j->current_location.realtime_set)
677 return journal_file_move_to_entry_by_realtime_for_data(f, dp, j->current_location.realtime, direction, ret, offset);
678
679 return journal_file_next_entry_for_data(f, NULL, 0, dp, direction, ret, offset);
680
681 } else if (m->type == MATCH_OR_TERM) {
682 uint64_t np = 0;
683 Object *n;
684 Match *i;
685
686 /* Find the earliest match */
687
688 LIST_FOREACH(matches, i, m->matches) {
689 uint64_t cp;
690
691 r = find_location_for_match(j, i, f, direction, NULL, &cp);
692 if (r < 0)
693 return r;
694 else if (r > 0) {
695 if (np == 0 || (direction == DIRECTION_DOWN ? np > cp : np < cp))
696 np = cp;
697 }
698 }
699
700 if (np == 0)
701 return 0;
702
703 r = journal_file_move_to_object(f, OBJECT_ENTRY, np, &n);
704 if (r < 0)
705 return r;
706
707 if (ret)
708 *ret = n;
709 if (offset)
710 *offset = np;
711
712 return 1;
713
714 } else {
715 Match *i;
716 uint64_t np = 0;
717
718 assert(m->type == MATCH_AND_TERM);
719
720 /* First jump to the last match, and then find the
721 * next one where all matches match */
722
723 if (!m->matches)
724 return 0;
725
726 LIST_FOREACH(matches, i, m->matches) {
727 uint64_t cp;
728
729 r = find_location_for_match(j, i, f, direction, NULL, &cp);
730 if (r <= 0)
731 return r;
732
733 if (np == 0 || (direction == DIRECTION_DOWN ? np < cp : np > cp))
734 np = cp;
735 }
736
737 return next_for_match(j, m, f, np, direction, ret, offset);
738 }
739 }
740
741 static int find_location_with_matches(
742 sd_journal *j,
743 JournalFile *f,
744 direction_t direction,
745 Object **ret,
746 uint64_t *offset) {
747
748 int r;
749
750 assert(j);
751 assert(f);
752 assert(ret);
753 assert(offset);
754
755 if (!j->level0) {
756 /* No matches is simple */
757
758 if (j->current_location.type == LOCATION_HEAD)
759 return journal_file_next_entry(f, NULL, 0, DIRECTION_DOWN, ret, offset);
760 if (j->current_location.type == LOCATION_TAIL)
761 return journal_file_next_entry(f, NULL, 0, DIRECTION_UP, ret, offset);
762 if (j->current_location.seqnum_set && sd_id128_equal(j->current_location.seqnum_id, f->header->seqnum_id))
763 return journal_file_move_to_entry_by_seqnum(f, j->current_location.seqnum, direction, ret, offset);
764 if (j->current_location.monotonic_set) {
765 r = journal_file_move_to_entry_by_monotonic(f, j->current_location.boot_id, j->current_location.monotonic, direction, ret, offset);
766 if (r != -ENOENT)
767 return r;
768 }
769 if (j->current_location.realtime_set)
770 return journal_file_move_to_entry_by_realtime(f, j->current_location.realtime, direction, ret, offset);
771
772 return journal_file_next_entry(f, NULL, 0, direction, ret, offset);
773 } else
774 return find_location_for_match(j, j->level0, f, direction, ret, offset);
775 }
776
777 static int next_with_matches(
778 sd_journal *j,
779 JournalFile *f,
780 direction_t direction,
781 Object **ret,
782 uint64_t *offset) {
783
784 Object *c;
785 uint64_t cp;
786
787 assert(j);
788 assert(f);
789 assert(ret);
790 assert(offset);
791
792 c = *ret;
793 cp = *offset;
794
795 /* No matches is easy. We simple advance the file
796 * pointer by one. */
797 if (!j->level0)
798 return journal_file_next_entry(f, c, cp, direction, ret, offset);
799
800 /* If we have a match then we look for the next matching entry
801 * with an offset at least one step larger */
802 return next_for_match(j, j->level0, f, direction == DIRECTION_DOWN ? cp+1 : cp-1, direction, ret, offset);
803 }
804
805 static int next_beyond_location(sd_journal *j, JournalFile *f, direction_t direction, Object **ret, uint64_t *offset) {
806 Object *c;
807 uint64_t cp;
808 int r;
809
810 assert(j);
811 assert(f);
812
813 if (f->last_direction == direction && f->current_offset > 0) {
814 cp = f->current_offset;
815
816 r = journal_file_move_to_object(f, OBJECT_ENTRY, cp, &c);
817 if (r < 0)
818 return r;
819
820 r = next_with_matches(j, f, direction, &c, &cp);
821 if (r <= 0)
822 return r;
823 } else {
824 r = find_location_with_matches(j, f, direction, &c, &cp);
825 if (r <= 0)
826 return r;
827 }
828
829 /* OK, we found the spot, now let's advance until to an entry
830 * that is actually different from what we were previously
831 * looking at. This is necessary to handle entries which exist
832 * in two (or more) journal files, and which shall all be
833 * suppressed but one. */
834
835 for (;;) {
836 bool found;
837
838 if (j->current_location.type == LOCATION_DISCRETE) {
839 int k;
840
841 k = compare_with_location(f, c, &j->current_location);
842 if (direction == DIRECTION_DOWN)
843 found = k > 0;
844 else
845 found = k < 0;
846 } else
847 found = true;
848
849 if (found) {
850 if (ret)
851 *ret = c;
852 if (offset)
853 *offset = cp;
854 return 1;
855 }
856
857 r = next_with_matches(j, f, direction, &c, &cp);
858 if (r <= 0)
859 return r;
860 }
861 }
862
863 static int real_journal_next(sd_journal *j, direction_t direction) {
864 JournalFile *f, *new_file = NULL;
865 uint64_t new_offset = 0;
866 Object *o;
867 uint64_t p;
868 Iterator i;
869 int r;
870
871 if (!j)
872 return -EINVAL;
873
874 HASHMAP_FOREACH(f, j->files, i) {
875 bool found;
876
877 r = next_beyond_location(j, f, direction, &o, &p);
878 if (r < 0) {
879 log_debug("Can't iterate through %s, ignoring: %s", f->path, strerror(-r));
880 continue;
881 } else if (r == 0)
882 continue;
883
884 if (!new_file)
885 found = true;
886 else {
887 int k;
888
889 k = compare_entry_order(f, o, new_file, new_offset);
890
891 if (direction == DIRECTION_DOWN)
892 found = k < 0;
893 else
894 found = k > 0;
895 }
896
897 if (found) {
898 new_file = f;
899 new_offset = p;
900 }
901 }
902
903 if (!new_file)
904 return 0;
905
906 r = journal_file_move_to_object(new_file, OBJECT_ENTRY, new_offset, &o);
907 if (r < 0)
908 return r;
909
910 set_location(j, LOCATION_DISCRETE, new_file, o, direction, new_offset);
911
912 return 1;
913 }
914
915 _public_ int sd_journal_next(sd_journal *j) {
916 return real_journal_next(j, DIRECTION_DOWN);
917 }
918
919 _public_ int sd_journal_previous(sd_journal *j) {
920 return real_journal_next(j, DIRECTION_UP);
921 }
922
923 static int real_journal_next_skip(sd_journal *j, direction_t direction, uint64_t skip) {
924 int c = 0, r;
925
926 if (!j)
927 return -EINVAL;
928
929 if (skip == 0) {
930 /* If this is not a discrete skip, then at least
931 * resolve the current location */
932 if (j->current_location.type != LOCATION_DISCRETE)
933 return real_journal_next(j, direction);
934
935 return 0;
936 }
937
938 do {
939 r = real_journal_next(j, direction);
940 if (r < 0)
941 return r;
942
943 if (r == 0)
944 return c;
945
946 skip--;
947 c++;
948 } while (skip > 0);
949
950 return c;
951 }
952
953 _public_ int sd_journal_next_skip(sd_journal *j, uint64_t skip) {
954 return real_journal_next_skip(j, DIRECTION_DOWN, skip);
955 }
956
957 _public_ int sd_journal_previous_skip(sd_journal *j, uint64_t skip) {
958 return real_journal_next_skip(j, DIRECTION_UP, skip);
959 }
960
961 _public_ int sd_journal_get_cursor(sd_journal *j, char **cursor) {
962 Object *o;
963 int r;
964 char bid[33], sid[33];
965
966 if (!j)
967 return -EINVAL;
968 if (!cursor)
969 return -EINVAL;
970
971 if (!j->current_file || j->current_file->current_offset <= 0)
972 return -EADDRNOTAVAIL;
973
974 r = journal_file_move_to_object(j->current_file, OBJECT_ENTRY, j->current_file->current_offset, &o);
975 if (r < 0)
976 return r;
977
978 sd_id128_to_string(j->current_file->header->seqnum_id, sid);
979 sd_id128_to_string(o->entry.boot_id, bid);
980
981 if (asprintf(cursor,
982 "s=%s;i=%"PRIx64";b=%s;m=%"PRIx64";t=%"PRIx64";x=%"PRIx64,
983 sid, le64toh(o->entry.seqnum),
984 bid, le64toh(o->entry.monotonic),
985 le64toh(o->entry.realtime),
986 le64toh(o->entry.xor_hash)) < 0)
987 return -ENOMEM;
988
989 return 0;
990 }
991
992 _public_ int sd_journal_seek_cursor(sd_journal *j, const char *cursor) {
993 char *w, *state;
994 size_t l;
995 unsigned long long seqnum, monotonic, realtime, xor_hash;
996 bool
997 seqnum_id_set = false,
998 seqnum_set = false,
999 boot_id_set = false,
1000 monotonic_set = false,
1001 realtime_set = false,
1002 xor_hash_set = false;
1003 sd_id128_t seqnum_id, boot_id;
1004
1005 if (!j)
1006 return -EINVAL;
1007 if (isempty(cursor))
1008 return -EINVAL;
1009
1010 FOREACH_WORD_SEPARATOR(w, l, cursor, ";", state) {
1011 char *item;
1012 int k = 0;
1013
1014 if (l < 2 || w[1] != '=')
1015 return -EINVAL;
1016
1017 item = strndup(w, l);
1018 if (!item)
1019 return -ENOMEM;
1020
1021 switch (w[0]) {
1022
1023 case 's':
1024 seqnum_id_set = true;
1025 k = sd_id128_from_string(item+2, &seqnum_id);
1026 break;
1027
1028 case 'i':
1029 seqnum_set = true;
1030 if (sscanf(item+2, "%llx", &seqnum) != 1)
1031 k = -EINVAL;
1032 break;
1033
1034 case 'b':
1035 boot_id_set = true;
1036 k = sd_id128_from_string(item+2, &boot_id);
1037 break;
1038
1039 case 'm':
1040 monotonic_set = true;
1041 if (sscanf(item+2, "%llx", &monotonic) != 1)
1042 k = -EINVAL;
1043 break;
1044
1045 case 't':
1046 realtime_set = true;
1047 if (sscanf(item+2, "%llx", &realtime) != 1)
1048 k = -EINVAL;
1049 break;
1050
1051 case 'x':
1052 xor_hash_set = true;
1053 if (sscanf(item+2, "%llx", &xor_hash) != 1)
1054 k = -EINVAL;
1055 break;
1056 }
1057
1058 free(item);
1059
1060 if (k < 0)
1061 return k;
1062 }
1063
1064 if ((!seqnum_set || !seqnum_id_set) &&
1065 (!monotonic_set || !boot_id_set) &&
1066 !realtime_set)
1067 return -EINVAL;
1068
1069 reset_location(j);
1070
1071 j->current_location.type = LOCATION_SEEK;
1072
1073 if (realtime_set) {
1074 j->current_location.realtime = (uint64_t) realtime;
1075 j->current_location.realtime_set = true;
1076 }
1077
1078 if (seqnum_set && seqnum_id_set) {
1079 j->current_location.seqnum = (uint64_t) seqnum;
1080 j->current_location.seqnum_id = seqnum_id;
1081 j->current_location.seqnum_set = true;
1082 }
1083
1084 if (monotonic_set && boot_id_set) {
1085 j->current_location.monotonic = (uint64_t) monotonic;
1086 j->current_location.boot_id = boot_id;
1087 j->current_location.monotonic_set = true;
1088 }
1089
1090 if (xor_hash_set) {
1091 j->current_location.xor_hash = (uint64_t) xor_hash;
1092 j->current_location.xor_hash_set = true;
1093 }
1094
1095 return 0;
1096 }
1097
1098 _public_ int sd_journal_test_cursor(sd_journal *j, const char *cursor) {
1099 int r;
1100 char *w, *state;
1101 size_t l;
1102 Object *o;
1103
1104 if (!j)
1105 return -EINVAL;
1106 if (isempty(cursor))
1107 return -EINVAL;
1108
1109 if (!j->current_file || j->current_file->current_offset <= 0)
1110 return -EADDRNOTAVAIL;
1111
1112 r = journal_file_move_to_object(j->current_file, OBJECT_ENTRY, j->current_file->current_offset, &o);
1113 if (r < 0)
1114 return r;
1115
1116 FOREACH_WORD_SEPARATOR(w, l, cursor, ";", state) {
1117 _cleanup_free_ char *item = NULL;
1118 sd_id128_t id;
1119 unsigned long long ll;
1120 int k = 0;
1121
1122 if (l < 2 || w[1] != '=')
1123 return -EINVAL;
1124
1125 item = strndup(w, l);
1126 if (!item)
1127 return -ENOMEM;
1128
1129 switch (w[0]) {
1130
1131 case 's':
1132 k = sd_id128_from_string(item+2, &id);
1133 if (k < 0)
1134 return k;
1135 if (!sd_id128_equal(id, j->current_file->header->seqnum_id))
1136 return 0;
1137 break;
1138
1139 case 'i':
1140 if (sscanf(item+2, "%llx", &ll) != 1)
1141 return -EINVAL;
1142 if (ll != le64toh(o->entry.seqnum))
1143 return 0;
1144 break;
1145
1146 case 'b':
1147 k = sd_id128_from_string(item+2, &id);
1148 if (k < 0)
1149 return k;
1150 if (!sd_id128_equal(id, o->entry.boot_id))
1151 return 0;
1152 break;
1153
1154 case 'm':
1155 if (sscanf(item+2, "%llx", &ll) != 1)
1156 return -EINVAL;
1157 if (ll != le64toh(o->entry.monotonic))
1158 return 0;
1159 break;
1160
1161 case 't':
1162 if (sscanf(item+2, "%llx", &ll) != 1)
1163 return -EINVAL;
1164 if (ll != le64toh(o->entry.realtime))
1165 return 0;
1166 break;
1167
1168 case 'x':
1169 if (sscanf(item+2, "%llx", &ll) != 1)
1170 return -EINVAL;
1171 if (ll != le64toh(o->entry.xor_hash))
1172 return 0;
1173 break;
1174 }
1175 }
1176
1177 return 1;
1178 }
1179
1180
1181 _public_ int sd_journal_seek_monotonic_usec(sd_journal *j, sd_id128_t boot_id, uint64_t usec) {
1182 if (!j)
1183 return -EINVAL;
1184
1185 reset_location(j);
1186 j->current_location.type = LOCATION_SEEK;
1187 j->current_location.boot_id = boot_id;
1188 j->current_location.monotonic = usec;
1189 j->current_location.monotonic_set = true;
1190
1191 return 0;
1192 }
1193
1194 _public_ int sd_journal_seek_realtime_usec(sd_journal *j, uint64_t usec) {
1195 if (!j)
1196 return -EINVAL;
1197
1198 reset_location(j);
1199 j->current_location.type = LOCATION_SEEK;
1200 j->current_location.realtime = usec;
1201 j->current_location.realtime_set = true;
1202
1203 return 0;
1204 }
1205
1206 _public_ int sd_journal_seek_head(sd_journal *j) {
1207 if (!j)
1208 return -EINVAL;
1209
1210 reset_location(j);
1211 j->current_location.type = LOCATION_HEAD;
1212
1213 return 0;
1214 }
1215
1216 _public_ int sd_journal_seek_tail(sd_journal *j) {
1217 if (!j)
1218 return -EINVAL;
1219
1220 reset_location(j);
1221 j->current_location.type = LOCATION_TAIL;
1222
1223 return 0;
1224 }
1225
1226 static void check_network(sd_journal *j, int fd) {
1227 struct statfs sfs;
1228
1229 assert(j);
1230
1231 if (j->on_network)
1232 return;
1233
1234 if (fstatfs(fd, &sfs) < 0)
1235 return;
1236
1237 j->on_network =
1238 F_TYPE_CMP(sfs.f_type, CIFS_MAGIC_NUMBER) ||
1239 F_TYPE_CMP(sfs.f_type, CODA_SUPER_MAGIC) ||
1240 F_TYPE_CMP(sfs.f_type, NCP_SUPER_MAGIC) ||
1241 F_TYPE_CMP(sfs.f_type, NFS_SUPER_MAGIC) ||
1242 F_TYPE_CMP(sfs.f_type, SMB_SUPER_MAGIC);
1243 }
1244
1245 static bool file_has_type_prefix(const char *prefix, const char *filename) {
1246 const char *full, *tilded, *atted;
1247
1248 full = strappend(prefix, ".journal");
1249 tilded = strappenda(full, "~");
1250 atted = strappenda(prefix, "@");
1251
1252 return streq(filename, full) ||
1253 streq(filename, tilded) ||
1254 startswith(filename, atted);
1255 }
1256
1257 static bool file_type_wanted(int flags, const char *filename) {
1258 if (!endswith(filename, ".journal") && !endswith(filename, ".journal~"))
1259 return false;
1260
1261 /* no flags set → every type is OK */
1262 if (!(flags & (SD_JOURNAL_SYSTEM | SD_JOURNAL_CURRENT_USER)))
1263 return true;
1264
1265 if (flags & SD_JOURNAL_SYSTEM && file_has_type_prefix("system", filename))
1266 return true;
1267
1268 if (flags & SD_JOURNAL_CURRENT_USER) {
1269 char prefix[5 + DECIMAL_STR_MAX(uid_t) + 1];
1270
1271 assert_se(snprintf(prefix, sizeof(prefix), "user-%lu", (unsigned long) getuid())
1272 < (int) sizeof(prefix));
1273
1274 if (file_has_type_prefix(prefix, filename))
1275 return true;
1276 }
1277
1278 return false;
1279 }
1280
1281 static int add_any_file(sd_journal *j, const char *path) {
1282 JournalFile *f;
1283 int r;
1284
1285 assert(j);
1286 assert(path);
1287
1288 if (hashmap_get(j->files, path))
1289 return 0;
1290
1291 if (hashmap_size(j->files) >= JOURNAL_FILES_MAX) {
1292 log_warning("Too many open journal files, not adding %s.", path);
1293 return set_put_error(j, -ETOOMANYREFS);
1294 }
1295
1296 r = journal_file_open(path, O_RDONLY, 0, false, false, NULL, j->mmap, NULL, &f);
1297 if (r < 0)
1298 return r;
1299
1300 /* journal_file_dump(f); */
1301
1302 r = hashmap_put(j->files, f->path, f);
1303 if (r < 0) {
1304 journal_file_close(f);
1305 return r;
1306 }
1307
1308 log_debug("File %s added.", f->path);
1309
1310 check_network(j, f->fd);
1311
1312 j->current_invalidate_counter ++;
1313
1314 return 0;
1315 }
1316
1317 static int add_file(sd_journal *j, const char *prefix, const char *filename) {
1318 _cleanup_free_ char *path = NULL;
1319 int r;
1320
1321 assert(j);
1322 assert(prefix);
1323 assert(filename);
1324
1325 if (j->no_new_files ||
1326 !file_type_wanted(j->flags, filename))
1327 return 0;
1328
1329 path = strjoin(prefix, "/", filename, NULL);
1330 if (!path)
1331 return -ENOMEM;
1332
1333 r = add_any_file(j, path);
1334 if (r == -ENOENT)
1335 return 0;
1336 return 0;
1337 }
1338
1339 static int remove_file(sd_journal *j, const char *prefix, const char *filename) {
1340 char *path;
1341 JournalFile *f;
1342
1343 assert(j);
1344 assert(prefix);
1345 assert(filename);
1346
1347 path = strjoin(prefix, "/", filename, NULL);
1348 if (!path)
1349 return -ENOMEM;
1350
1351 f = hashmap_get(j->files, path);
1352 free(path);
1353 if (!f)
1354 return 0;
1355
1356 hashmap_remove(j->files, f->path);
1357
1358 log_debug("File %s removed.", f->path);
1359
1360 if (j->current_file == f) {
1361 j->current_file = NULL;
1362 j->current_field = 0;
1363 }
1364
1365 if (j->unique_file == f) {
1366 j->unique_file = NULL;
1367 j->unique_offset = 0;
1368 }
1369
1370 journal_file_close(f);
1371
1372 j->current_invalidate_counter ++;
1373
1374 return 0;
1375 }
1376
1377 static int add_directory(sd_journal *j, const char *prefix, const char *dirname) {
1378 _cleanup_free_ char *path = NULL;
1379 int r;
1380 _cleanup_closedir_ DIR *d = NULL;
1381 sd_id128_t id, mid;
1382 Directory *m;
1383
1384 assert(j);
1385 assert(prefix);
1386 assert(dirname);
1387
1388 log_debug("Considering %s/%s.", prefix, dirname);
1389
1390 if ((j->flags & SD_JOURNAL_LOCAL_ONLY) &&
1391 (sd_id128_from_string(dirname, &id) < 0 ||
1392 sd_id128_get_machine(&mid) < 0 ||
1393 !(sd_id128_equal(id, mid) || path_startswith(prefix, "/run"))))
1394 return 0;
1395
1396 path = strjoin(prefix, "/", dirname, NULL);
1397 if (!path)
1398 return -ENOMEM;
1399
1400 d = opendir(path);
1401 if (!d) {
1402 log_debug("Failed to open %s: %m", path);
1403 if (errno == ENOENT)
1404 return 0;
1405 return -errno;
1406 }
1407
1408 m = hashmap_get(j->directories_by_path, path);
1409 if (!m) {
1410 m = new0(Directory, 1);
1411 if (!m)
1412 return -ENOMEM;
1413
1414 m->is_root = false;
1415 m->path = path;
1416
1417 if (hashmap_put(j->directories_by_path, m->path, m) < 0) {
1418 free(m);
1419 return -ENOMEM;
1420 }
1421
1422 path = NULL; /* avoid freeing in cleanup */
1423 j->current_invalidate_counter ++;
1424
1425 log_debug("Directory %s added.", m->path);
1426
1427 } else if (m->is_root)
1428 return 0;
1429
1430 if (m->wd <= 0 && j->inotify_fd >= 0) {
1431
1432 m->wd = inotify_add_watch(j->inotify_fd, m->path,
1433 IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB|IN_DELETE|
1434 IN_DELETE_SELF|IN_MOVE_SELF|IN_UNMOUNT|IN_MOVED_FROM|
1435 IN_ONLYDIR);
1436
1437 if (m->wd > 0 && hashmap_put(j->directories_by_wd, INT_TO_PTR(m->wd), m) < 0)
1438 inotify_rm_watch(j->inotify_fd, m->wd);
1439 }
1440
1441 for (;;) {
1442 struct dirent *de;
1443 union dirent_storage buf;
1444
1445 r = readdir_r(d, &buf.de, &de);
1446 if (r != 0 || !de)
1447 break;
1448
1449 if (dirent_is_file_with_suffix(de, ".journal") ||
1450 dirent_is_file_with_suffix(de, ".journal~")) {
1451 r = add_file(j, m->path, de->d_name);
1452 if (r < 0) {
1453 log_debug("Failed to add file %s/%s: %s",
1454 m->path, de->d_name, strerror(-r));
1455 r = set_put_error(j, r);
1456 if (r < 0)
1457 return r;
1458 }
1459 }
1460 }
1461
1462 check_network(j, dirfd(d));
1463
1464 return 0;
1465 }
1466
1467 static int add_root_directory(sd_journal *j, const char *p) {
1468 _cleanup_closedir_ DIR *d = NULL;
1469 Directory *m;
1470 int r;
1471
1472 assert(j);
1473 assert(p);
1474
1475 if ((j->flags & SD_JOURNAL_RUNTIME_ONLY) &&
1476 !path_startswith(p, "/run"))
1477 return -EINVAL;
1478
1479 d = opendir(p);
1480 if (!d)
1481 return -errno;
1482
1483 m = hashmap_get(j->directories_by_path, p);
1484 if (!m) {
1485 m = new0(Directory, 1);
1486 if (!m)
1487 return -ENOMEM;
1488
1489 m->is_root = true;
1490 m->path = strdup(p);
1491 if (!m->path) {
1492 free(m);
1493 return -ENOMEM;
1494 }
1495
1496 if (hashmap_put(j->directories_by_path, m->path, m) < 0) {
1497 free(m->path);
1498 free(m);
1499 return -ENOMEM;
1500 }
1501
1502 j->current_invalidate_counter ++;
1503
1504 log_debug("Root directory %s added.", m->path);
1505
1506 } else if (!m->is_root)
1507 return 0;
1508
1509 if (m->wd <= 0 && j->inotify_fd >= 0) {
1510
1511 m->wd = inotify_add_watch(j->inotify_fd, m->path,
1512 IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB|IN_DELETE|
1513 IN_ONLYDIR);
1514
1515 if (m->wd > 0 && hashmap_put(j->directories_by_wd, INT_TO_PTR(m->wd), m) < 0)
1516 inotify_rm_watch(j->inotify_fd, m->wd);
1517 }
1518
1519 if (j->no_new_files)
1520 return 0;
1521
1522 for (;;) {
1523 struct dirent *de;
1524 union dirent_storage buf;
1525 sd_id128_t id;
1526
1527 r = readdir_r(d, &buf.de, &de);
1528 if (r != 0 || !de)
1529 break;
1530
1531 if (dirent_is_file_with_suffix(de, ".journal") ||
1532 dirent_is_file_with_suffix(de, ".journal~")) {
1533 r = add_file(j, m->path, de->d_name);
1534 if (r < 0) {
1535 log_debug("Failed to add file %s/%s: %s",
1536 m->path, de->d_name, strerror(-r));
1537 r = set_put_error(j, r);
1538 if (r < 0)
1539 return r;
1540 }
1541 } else if ((de->d_type == DT_DIR || de->d_type == DT_LNK || de->d_type == DT_UNKNOWN) &&
1542 sd_id128_from_string(de->d_name, &id) >= 0) {
1543
1544 r = add_directory(j, m->path, de->d_name);
1545 if (r < 0)
1546 log_debug("Failed to add directory %s/%s: %s", m->path, de->d_name, strerror(-r));
1547 }
1548 }
1549
1550 check_network(j, dirfd(d));
1551
1552 return 0;
1553 }
1554
1555 static int remove_directory(sd_journal *j, Directory *d) {
1556 assert(j);
1557
1558 if (d->wd > 0) {
1559 hashmap_remove(j->directories_by_wd, INT_TO_PTR(d->wd));
1560
1561 if (j->inotify_fd >= 0)
1562 inotify_rm_watch(j->inotify_fd, d->wd);
1563 }
1564
1565 hashmap_remove(j->directories_by_path, d->path);
1566
1567 if (d->is_root)
1568 log_debug("Root directory %s removed.", d->path);
1569 else
1570 log_debug("Directory %s removed.", d->path);
1571
1572 free(d->path);
1573 free(d);
1574
1575 return 0;
1576 }
1577
1578 static int add_search_paths(sd_journal *j) {
1579 int r;
1580 const char search_paths[] =
1581 "/run/log/journal\0"
1582 "/var/log/journal\0";
1583 const char *p;
1584
1585 assert(j);
1586
1587 /* We ignore most errors here, since the idea is to only open
1588 * what's actually accessible, and ignore the rest. */
1589
1590 NULSTR_FOREACH(p, search_paths) {
1591 r = add_root_directory(j, p);
1592 if (r < 0 && r != -ENOENT) {
1593 r = set_put_error(j, r);
1594 if (r < 0)
1595 return r;
1596 }
1597 }
1598
1599 return 0;
1600 }
1601
1602 static int add_current_paths(sd_journal *j) {
1603 Iterator i;
1604 JournalFile *f;
1605
1606 assert(j);
1607 assert(j->no_new_files);
1608
1609 /* Simply adds all directories for files we have open as
1610 * "root" directories. We don't expect errors here, so we
1611 * treat them as fatal. */
1612
1613 HASHMAP_FOREACH(f, j->files, i) {
1614 int r;
1615 _cleanup_free_ char *dir;
1616
1617 dir = dirname_malloc(f->path);
1618 if (!dir)
1619 return -ENOMEM;
1620
1621 r = add_root_directory(j, dir);
1622 if (r < 0) {
1623 set_put_error(j, r);
1624 return r;
1625 }
1626 }
1627
1628 return 0;
1629 }
1630
1631
1632 static int allocate_inotify(sd_journal *j) {
1633 assert(j);
1634
1635 if (j->inotify_fd < 0) {
1636 j->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
1637 if (j->inotify_fd < 0)
1638 return -errno;
1639 }
1640
1641 if (!j->directories_by_wd) {
1642 j->directories_by_wd = hashmap_new(trivial_hash_func, trivial_compare_func);
1643 if (!j->directories_by_wd)
1644 return -ENOMEM;
1645 }
1646
1647 return 0;
1648 }
1649
1650 static sd_journal *journal_new(int flags, const char *path) {
1651 sd_journal *j;
1652
1653 j = new0(sd_journal, 1);
1654 if (!j)
1655 return NULL;
1656
1657 j->inotify_fd = -1;
1658 j->flags = flags;
1659 j->data_threshold = DEFAULT_DATA_THRESHOLD;
1660
1661 if (path) {
1662 j->path = strdup(path);
1663 if (!j->path)
1664 goto fail;
1665 }
1666
1667 j->files = hashmap_new(string_hash_func, string_compare_func);
1668 j->directories_by_path = hashmap_new(string_hash_func, string_compare_func);
1669 j->mmap = mmap_cache_new();
1670 if (!j->files || !j->directories_by_path || !j->mmap)
1671 goto fail;
1672
1673 return j;
1674
1675 fail:
1676 sd_journal_close(j);
1677 return NULL;
1678 }
1679
1680 _public_ int sd_journal_open(sd_journal **ret, int flags) {
1681 sd_journal *j;
1682 int r;
1683
1684 if (!ret)
1685 return -EINVAL;
1686
1687 if (flags & ~(SD_JOURNAL_LOCAL_ONLY|
1688 SD_JOURNAL_RUNTIME_ONLY|
1689 SD_JOURNAL_SYSTEM|
1690 SD_JOURNAL_CURRENT_USER))
1691 return -EINVAL;
1692
1693 j = journal_new(flags, NULL);
1694 if (!j)
1695 return -ENOMEM;
1696
1697 r = add_search_paths(j);
1698 if (r < 0)
1699 goto fail;
1700
1701 *ret = j;
1702 return 0;
1703
1704 fail:
1705 sd_journal_close(j);
1706
1707 return r;
1708 }
1709
1710 _public_ int sd_journal_open_directory(sd_journal **ret, const char *path, int flags) {
1711 sd_journal *j;
1712 int r;
1713
1714 if (!ret)
1715 return -EINVAL;
1716
1717 if (!path)
1718 return -EINVAL;
1719
1720 if (flags != 0)
1721 return -EINVAL;
1722
1723 j = journal_new(flags, path);
1724 if (!j)
1725 return -ENOMEM;
1726
1727 r = add_root_directory(j, path);
1728 if (r < 0) {
1729 set_put_error(j, r);
1730 goto fail;
1731 }
1732
1733 *ret = j;
1734 return 0;
1735
1736 fail:
1737 sd_journal_close(j);
1738
1739 return r;
1740 }
1741
1742 _public_ int sd_journal_open_files(sd_journal **ret, const char **paths, int flags) {
1743 sd_journal *j;
1744 const char **path;
1745 int r;
1746
1747 if (!ret)
1748 return -EINVAL;
1749
1750 if (flags != 0)
1751 return -EINVAL;
1752
1753 j = journal_new(flags, NULL);
1754 if (!j)
1755 return -ENOMEM;
1756
1757 STRV_FOREACH(path, paths) {
1758 r = add_any_file(j, *path);
1759 if (r < 0) {
1760 log_error("Failed to open %s: %s", *path, strerror(-r));
1761 goto fail;
1762 }
1763 }
1764
1765 j->no_new_files = true;
1766
1767 *ret = j;
1768 return 0;
1769
1770 fail:
1771 sd_journal_close(j);
1772
1773 return r;
1774 }
1775
1776 _public_ void sd_journal_close(sd_journal *j) {
1777 Directory *d;
1778 JournalFile *f;
1779
1780 if (!j)
1781 return;
1782
1783 sd_journal_flush_matches(j);
1784
1785 while ((f = hashmap_steal_first(j->files)))
1786 journal_file_close(f);
1787
1788 hashmap_free(j->files);
1789
1790 while ((d = hashmap_first(j->directories_by_path)))
1791 remove_directory(j, d);
1792
1793 while ((d = hashmap_first(j->directories_by_wd)))
1794 remove_directory(j, d);
1795
1796 hashmap_free(j->directories_by_path);
1797 hashmap_free(j->directories_by_wd);
1798
1799 if (j->inotify_fd >= 0)
1800 close_nointr_nofail(j->inotify_fd);
1801
1802 if (j->mmap)
1803 mmap_cache_unref(j->mmap);
1804
1805 free(j->path);
1806 free(j->unique_field);
1807 set_free(j->errors);
1808 free(j);
1809 }
1810
1811 _public_ int sd_journal_get_realtime_usec(sd_journal *j, uint64_t *ret) {
1812 Object *o;
1813 JournalFile *f;
1814 int r;
1815
1816 if (!j)
1817 return -EINVAL;
1818 if (!ret)
1819 return -EINVAL;
1820
1821 f = j->current_file;
1822 if (!f)
1823 return -EADDRNOTAVAIL;
1824
1825 if (f->current_offset <= 0)
1826 return -EADDRNOTAVAIL;
1827
1828 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1829 if (r < 0)
1830 return r;
1831
1832 *ret = le64toh(o->entry.realtime);
1833 return 0;
1834 }
1835
1836 _public_ int sd_journal_get_monotonic_usec(sd_journal *j, uint64_t *ret, sd_id128_t *ret_boot_id) {
1837 Object *o;
1838 JournalFile *f;
1839 int r;
1840 sd_id128_t id;
1841
1842 if (!j)
1843 return -EINVAL;
1844
1845 f = j->current_file;
1846 if (!f)
1847 return -EADDRNOTAVAIL;
1848
1849 if (f->current_offset <= 0)
1850 return -EADDRNOTAVAIL;
1851
1852 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1853 if (r < 0)
1854 return r;
1855
1856 if (ret_boot_id)
1857 *ret_boot_id = o->entry.boot_id;
1858 else {
1859 r = sd_id128_get_boot(&id);
1860 if (r < 0)
1861 return r;
1862
1863 if (!sd_id128_equal(id, o->entry.boot_id))
1864 return -ESTALE;
1865 }
1866
1867 if (ret)
1868 *ret = le64toh(o->entry.monotonic);
1869
1870 return 0;
1871 }
1872
1873 static bool field_is_valid(const char *field) {
1874 const char *p;
1875
1876 assert(field);
1877
1878 if (isempty(field))
1879 return false;
1880
1881 if (startswith(field, "__"))
1882 return false;
1883
1884 for (p = field; *p; p++) {
1885
1886 if (*p == '_')
1887 continue;
1888
1889 if (*p >= 'A' && *p <= 'Z')
1890 continue;
1891
1892 if (*p >= '0' && *p <= '9')
1893 continue;
1894
1895 return false;
1896 }
1897
1898 return true;
1899 }
1900
1901 _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **data, size_t *size) {
1902 JournalFile *f;
1903 uint64_t i, n;
1904 size_t field_length;
1905 int r;
1906 Object *o;
1907
1908 if (!j)
1909 return -EINVAL;
1910 if (!field)
1911 return -EINVAL;
1912 if (!data)
1913 return -EINVAL;
1914 if (!size)
1915 return -EINVAL;
1916
1917 if (!field_is_valid(field))
1918 return -EINVAL;
1919
1920 f = j->current_file;
1921 if (!f)
1922 return -EADDRNOTAVAIL;
1923
1924 if (f->current_offset <= 0)
1925 return -EADDRNOTAVAIL;
1926
1927 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1928 if (r < 0)
1929 return r;
1930
1931 field_length = strlen(field);
1932
1933 n = journal_file_entry_n_items(o);
1934 for (i = 0; i < n; i++) {
1935 uint64_t p, l;
1936 le64_t le_hash;
1937 size_t t;
1938
1939 p = le64toh(o->entry.items[i].object_offset);
1940 le_hash = o->entry.items[i].hash;
1941 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
1942 if (r < 0)
1943 return r;
1944
1945 if (le_hash != o->data.hash)
1946 return -EBADMSG;
1947
1948 l = le64toh(o->object.size) - offsetof(Object, data.payload);
1949
1950 if (o->object.flags & OBJECT_COMPRESSED) {
1951
1952 #ifdef HAVE_XZ
1953 if (uncompress_startswith(o->data.payload, l,
1954 &f->compress_buffer, &f->compress_buffer_size,
1955 field, field_length, '=')) {
1956
1957 uint64_t rsize;
1958
1959 if (!uncompress_blob(o->data.payload, l,
1960 &f->compress_buffer, &f->compress_buffer_size, &rsize,
1961 j->data_threshold))
1962 return -EBADMSG;
1963
1964 *data = f->compress_buffer;
1965 *size = (size_t) rsize;
1966
1967 return 0;
1968 }
1969 #else
1970 return -EPROTONOSUPPORT;
1971 #endif
1972
1973 } else if (l >= field_length+1 &&
1974 memcmp(o->data.payload, field, field_length) == 0 &&
1975 o->data.payload[field_length] == '=') {
1976
1977 t = (size_t) l;
1978
1979 if ((uint64_t) t != l)
1980 return -E2BIG;
1981
1982 *data = o->data.payload;
1983 *size = t;
1984
1985 return 0;
1986 }
1987
1988 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1989 if (r < 0)
1990 return r;
1991 }
1992
1993 return -ENOENT;
1994 }
1995
1996 static int return_data(sd_journal *j, JournalFile *f, Object *o, const void **data, size_t *size) {
1997 size_t t;
1998 uint64_t l;
1999
2000 l = le64toh(o->object.size) - offsetof(Object, data.payload);
2001 t = (size_t) l;
2002
2003 /* We can't read objects larger than 4G on a 32bit machine */
2004 if ((uint64_t) t != l)
2005 return -E2BIG;
2006
2007 if (o->object.flags & OBJECT_COMPRESSED) {
2008 #ifdef HAVE_XZ
2009 uint64_t rsize;
2010
2011 if (!uncompress_blob(o->data.payload, l, &f->compress_buffer, &f->compress_buffer_size, &rsize, j->data_threshold))
2012 return -EBADMSG;
2013
2014 *data = f->compress_buffer;
2015 *size = (size_t) rsize;
2016 #else
2017 return -EPROTONOSUPPORT;
2018 #endif
2019 } else {
2020 *data = o->data.payload;
2021 *size = t;
2022 }
2023
2024 return 0;
2025 }
2026
2027 _public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t *size) {
2028 JournalFile *f;
2029 uint64_t p, n;
2030 le64_t le_hash;
2031 int r;
2032 Object *o;
2033
2034 if (!j)
2035 return -EINVAL;
2036 if (!data)
2037 return -EINVAL;
2038 if (!size)
2039 return -EINVAL;
2040
2041 f = j->current_file;
2042 if (!f)
2043 return -EADDRNOTAVAIL;
2044
2045 if (f->current_offset <= 0)
2046 return -EADDRNOTAVAIL;
2047
2048 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
2049 if (r < 0)
2050 return r;
2051
2052 n = journal_file_entry_n_items(o);
2053 if (j->current_field >= n)
2054 return 0;
2055
2056 p = le64toh(o->entry.items[j->current_field].object_offset);
2057 le_hash = o->entry.items[j->current_field].hash;
2058 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
2059 if (r < 0)
2060 return r;
2061
2062 if (le_hash != o->data.hash)
2063 return -EBADMSG;
2064
2065 r = return_data(j, f, o, data, size);
2066 if (r < 0)
2067 return r;
2068
2069 j->current_field ++;
2070
2071 return 1;
2072 }
2073
2074 _public_ void sd_journal_restart_data(sd_journal *j) {
2075 if (!j)
2076 return;
2077
2078 j->current_field = 0;
2079 }
2080
2081 _public_ int sd_journal_get_fd(sd_journal *j) {
2082 int r;
2083
2084 if (!j)
2085 return -EINVAL;
2086
2087 if (j->inotify_fd >= 0)
2088 return j->inotify_fd;
2089
2090 r = allocate_inotify(j);
2091 if (r < 0)
2092 return r;
2093
2094 /* Iterate through all dirs again, to add them to the
2095 * inotify */
2096 if (j->no_new_files)
2097 r = add_current_paths(j);
2098 else if (j->path)
2099 r = add_root_directory(j, j->path);
2100 else
2101 r = add_search_paths(j);
2102 if (r < 0)
2103 return r;
2104
2105 return j->inotify_fd;
2106 }
2107
2108 _public_ int sd_journal_get_events(sd_journal *j) {
2109 int fd;
2110
2111 if (!j)
2112 return -EINVAL;
2113
2114 fd = sd_journal_get_fd(j);
2115 if (fd < 0)
2116 return fd;
2117
2118 return POLLIN;
2119 }
2120
2121 _public_ int sd_journal_get_timeout(sd_journal *j, uint64_t *timeout_usec) {
2122 int fd;
2123
2124 if (!j)
2125 return -EINVAL;
2126 if (!timeout_usec)
2127 return -EINVAL;
2128
2129 fd = sd_journal_get_fd(j);
2130 if (fd < 0)
2131 return fd;
2132
2133 if (!j->on_network) {
2134 *timeout_usec = (uint64_t) -1;
2135 return 0;
2136 }
2137
2138 /* If we are on the network we need to regularly check for
2139 * changes manually */
2140
2141 *timeout_usec = j->last_process_usec + JOURNAL_FILES_RECHECK_USEC;
2142 return 1;
2143 }
2144
2145 static void process_inotify_event(sd_journal *j, struct inotify_event *e) {
2146 Directory *d;
2147 int r;
2148
2149 assert(j);
2150 assert(e);
2151
2152 /* Is this a subdirectory we watch? */
2153 d = hashmap_get(j->directories_by_wd, INT_TO_PTR(e->wd));
2154 if (d) {
2155 sd_id128_t id;
2156
2157 if (!(e->mask & IN_ISDIR) && e->len > 0 &&
2158 (endswith(e->name, ".journal") ||
2159 endswith(e->name, ".journal~"))) {
2160
2161 /* Event for a journal file */
2162
2163 if (e->mask & (IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB)) {
2164 r = add_file(j, d->path, e->name);
2165 if (r < 0) {
2166 log_debug("Failed to add file %s/%s: %s",
2167 d->path, e->name, strerror(-r));
2168 set_put_error(j, r);
2169 }
2170
2171 } else if (e->mask & (IN_DELETE|IN_MOVED_FROM|IN_UNMOUNT)) {
2172
2173 r = remove_file(j, d->path, e->name);
2174 if (r < 0)
2175 log_debug("Failed to remove file %s/%s: %s", d->path, e->name, strerror(-r));
2176 }
2177
2178 } else if (!d->is_root && e->len == 0) {
2179
2180 /* Event for a subdirectory */
2181
2182 if (e->mask & (IN_DELETE_SELF|IN_MOVE_SELF|IN_UNMOUNT)) {
2183 r = remove_directory(j, d);
2184 if (r < 0)
2185 log_debug("Failed to remove directory %s: %s", d->path, strerror(-r));
2186 }
2187
2188
2189 } else if (d->is_root && (e->mask & IN_ISDIR) && e->len > 0 && sd_id128_from_string(e->name, &id) >= 0) {
2190
2191 /* Event for root directory */
2192
2193 if (e->mask & (IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB)) {
2194 r = add_directory(j, d->path, e->name);
2195 if (r < 0)
2196 log_debug("Failed to add directory %s/%s: %s", d->path, e->name, strerror(-r));
2197 }
2198 }
2199
2200 return;
2201 }
2202
2203 if (e->mask & IN_IGNORED)
2204 return;
2205
2206 log_warning("Unknown inotify event.");
2207 }
2208
2209 static int determine_change(sd_journal *j) {
2210 bool b;
2211
2212 assert(j);
2213
2214 b = j->current_invalidate_counter != j->last_invalidate_counter;
2215 j->last_invalidate_counter = j->current_invalidate_counter;
2216
2217 return b ? SD_JOURNAL_INVALIDATE : SD_JOURNAL_APPEND;
2218 }
2219
2220 _public_ int sd_journal_process(sd_journal *j) {
2221 uint8_t buffer[sizeof(struct inotify_event) + FILENAME_MAX] _alignas_(struct inotify_event);
2222 bool got_something = false;
2223
2224 if (!j)
2225 return -EINVAL;
2226
2227 j->last_process_usec = now(CLOCK_MONOTONIC);
2228
2229 for (;;) {
2230 struct inotify_event *e;
2231 ssize_t l;
2232
2233 l = read(j->inotify_fd, buffer, sizeof(buffer));
2234 if (l < 0) {
2235 if (errno == EAGAIN || errno == EINTR)
2236 return got_something ? determine_change(j) : SD_JOURNAL_NOP;
2237
2238 return -errno;
2239 }
2240
2241 got_something = true;
2242
2243 e = (struct inotify_event*) buffer;
2244 while (l > 0) {
2245 size_t step;
2246
2247 process_inotify_event(j, e);
2248
2249 step = sizeof(struct inotify_event) + e->len;
2250 assert(step <= (size_t) l);
2251
2252 e = (struct inotify_event*) ((uint8_t*) e + step);
2253 l -= step;
2254 }
2255 }
2256
2257 return determine_change(j);
2258 }
2259
2260 _public_ int sd_journal_wait(sd_journal *j, uint64_t timeout_usec) {
2261 int r;
2262 uint64_t t;
2263
2264 assert(j);
2265
2266 if (j->inotify_fd < 0) {
2267
2268 /* This is the first invocation, hence create the
2269 * inotify watch */
2270 r = sd_journal_get_fd(j);
2271 if (r < 0)
2272 return r;
2273
2274 /* The journal might have changed since the context
2275 * object was created and we weren't watching before,
2276 * hence don't wait for anything, and return
2277 * immediately. */
2278 return determine_change(j);
2279 }
2280
2281 r = sd_journal_get_timeout(j, &t);
2282 if (r < 0)
2283 return r;
2284
2285 if (t != (uint64_t) -1) {
2286 usec_t n;
2287
2288 n = now(CLOCK_MONOTONIC);
2289 t = t > n ? t - n : 0;
2290
2291 if (timeout_usec == (uint64_t) -1 || timeout_usec > t)
2292 timeout_usec = t;
2293 }
2294
2295 do {
2296 r = fd_wait_for_event(j->inotify_fd, POLLIN, timeout_usec);
2297 } while (r == -EINTR);
2298
2299 if (r < 0)
2300 return r;
2301
2302 return sd_journal_process(j);
2303 }
2304
2305 _public_ int sd_journal_get_cutoff_realtime_usec(sd_journal *j, uint64_t *from, uint64_t *to) {
2306 Iterator i;
2307 JournalFile *f;
2308 bool first = true;
2309 int r;
2310
2311 if (!j)
2312 return -EINVAL;
2313 if (!from && !to)
2314 return -EINVAL;
2315 if (from == to)
2316 return -EINVAL;
2317
2318 HASHMAP_FOREACH(f, j->files, i) {
2319 usec_t fr, t;
2320
2321 r = journal_file_get_cutoff_realtime_usec(f, &fr, &t);
2322 if (r == -ENOENT)
2323 continue;
2324 if (r < 0)
2325 return r;
2326 if (r == 0)
2327 continue;
2328
2329 if (first) {
2330 if (from)
2331 *from = fr;
2332 if (to)
2333 *to = t;
2334 first = false;
2335 } else {
2336 if (from)
2337 *from = MIN(fr, *from);
2338 if (to)
2339 *to = MAX(t, *to);
2340 }
2341 }
2342
2343 return first ? 0 : 1;
2344 }
2345
2346 _public_ int sd_journal_get_cutoff_monotonic_usec(sd_journal *j, sd_id128_t boot_id, uint64_t *from, uint64_t *to) {
2347 Iterator i;
2348 JournalFile *f;
2349 bool first = true;
2350 int r;
2351
2352 if (!j)
2353 return -EINVAL;
2354 if (!from && !to)
2355 return -EINVAL;
2356 if (from == to)
2357 return -EINVAL;
2358
2359 HASHMAP_FOREACH(f, j->files, i) {
2360 usec_t fr, t;
2361
2362 r = journal_file_get_cutoff_monotonic_usec(f, boot_id, &fr, &t);
2363 if (r == -ENOENT)
2364 continue;
2365 if (r < 0)
2366 return r;
2367 if (r == 0)
2368 continue;
2369
2370 if (first) {
2371 if (from)
2372 *from = fr;
2373 if (to)
2374 *to = t;
2375 first = false;
2376 } else {
2377 if (from)
2378 *from = MIN(fr, *from);
2379 if (to)
2380 *to = MAX(t, *to);
2381 }
2382 }
2383
2384 return first ? 0 : 1;
2385 }
2386
2387 void journal_print_header(sd_journal *j) {
2388 Iterator i;
2389 JournalFile *f;
2390 bool newline = false;
2391
2392 assert(j);
2393
2394 HASHMAP_FOREACH(f, j->files, i) {
2395 if (newline)
2396 putchar('\n');
2397 else
2398 newline = true;
2399
2400 journal_file_print_header(f);
2401 }
2402 }
2403
2404 _public_ int sd_journal_get_usage(sd_journal *j, uint64_t *bytes) {
2405 Iterator i;
2406 JournalFile *f;
2407 uint64_t sum = 0;
2408
2409 if (!j)
2410 return -EINVAL;
2411 if (!bytes)
2412 return -EINVAL;
2413
2414 HASHMAP_FOREACH(f, j->files, i) {
2415 struct stat st;
2416
2417 if (fstat(f->fd, &st) < 0)
2418 return -errno;
2419
2420 sum += (uint64_t) st.st_blocks * 512ULL;
2421 }
2422
2423 *bytes = sum;
2424 return 0;
2425 }
2426
2427 _public_ int sd_journal_query_unique(sd_journal *j, const char *field) {
2428 char *f;
2429
2430 if (!j)
2431 return -EINVAL;
2432 if (isempty(field))
2433 return -EINVAL;
2434 if (!field_is_valid(field))
2435 return -EINVAL;
2436
2437 f = strdup(field);
2438 if (!f)
2439 return -ENOMEM;
2440
2441 free(j->unique_field);
2442 j->unique_field = f;
2443 j->unique_file = NULL;
2444 j->unique_offset = 0;
2445
2446 return 0;
2447 }
2448
2449 _public_ int sd_journal_enumerate_unique(sd_journal *j, const void **data, size_t *l) {
2450 Object *o;
2451 size_t k;
2452 int r;
2453
2454 if (!j)
2455 return -EINVAL;
2456 if (!data)
2457 return -EINVAL;
2458 if (!l)
2459 return -EINVAL;
2460 if (!j->unique_field)
2461 return -EINVAL;
2462
2463 k = strlen(j->unique_field);
2464
2465 if (!j->unique_file) {
2466 j->unique_file = hashmap_first(j->files);
2467 if (!j->unique_file)
2468 return 0;
2469 j->unique_offset = 0;
2470 }
2471
2472 for (;;) {
2473 JournalFile *of;
2474 Iterator i;
2475 const void *odata;
2476 size_t ol;
2477 bool found;
2478
2479 /* Proceed to next data object in the field's linked list */
2480 if (j->unique_offset == 0) {
2481 r = journal_file_find_field_object(j->unique_file, j->unique_field, k, &o, NULL);
2482 if (r < 0)
2483 return r;
2484
2485 j->unique_offset = r > 0 ? le64toh(o->field.head_data_offset) : 0;
2486 } else {
2487 r = journal_file_move_to_object(j->unique_file, OBJECT_DATA, j->unique_offset, &o);
2488 if (r < 0)
2489 return r;
2490
2491 j->unique_offset = le64toh(o->data.next_field_offset);
2492 }
2493
2494 /* We reached the end of the list? Then start again, with the next file */
2495 if (j->unique_offset == 0) {
2496 JournalFile *n;
2497
2498 n = hashmap_next(j->files, j->unique_file->path);
2499 if (!n)
2500 return 0;
2501
2502 j->unique_file = n;
2503 continue;
2504 }
2505
2506 /* We do not use the type context here, but 0 instead,
2507 * so that we can look at this data object at the same
2508 * time as one on another file */
2509 r = journal_file_move_to_object(j->unique_file, 0, j->unique_offset, &o);
2510 if (r < 0)
2511 return r;
2512
2513 /* Let's do the type check by hand, since we used 0 context above. */
2514 if (o->object.type != OBJECT_DATA)
2515 return -EBADMSG;
2516
2517 r = return_data(j, j->unique_file, o, &odata, &ol);
2518 if (r < 0)
2519 return r;
2520
2521 /* OK, now let's see if we already returned this data
2522 * object by checking if it exists in the earlier
2523 * traversed files. */
2524 found = false;
2525 HASHMAP_FOREACH(of, j->files, i) {
2526 Object *oo;
2527 uint64_t op;
2528
2529 if (of == j->unique_file)
2530 break;
2531
2532 /* Skip this file it didn't have any fields
2533 * indexed */
2534 if (JOURNAL_HEADER_CONTAINS(of->header, n_fields) &&
2535 le64toh(of->header->n_fields) <= 0)
2536 continue;
2537
2538 r = journal_file_find_data_object_with_hash(of, odata, ol, le64toh(o->data.hash), &oo, &op);
2539 if (r < 0)
2540 return r;
2541
2542 if (r > 0)
2543 found = true;
2544 }
2545
2546 if (found)
2547 continue;
2548
2549 r = return_data(j, j->unique_file, o, data, l);
2550 if (r < 0)
2551 return r;
2552
2553 return 1;
2554 }
2555 }
2556
2557 _public_ void sd_journal_restart_unique(sd_journal *j) {
2558 if (!j)
2559 return;
2560
2561 j->unique_file = NULL;
2562 j->unique_offset = 0;
2563 }
2564
2565 _public_ int sd_journal_reliable_fd(sd_journal *j) {
2566 if (!j)
2567 return -EINVAL;
2568
2569 return !j->on_network;
2570 }
2571
2572 static char *lookup_field(const char *field, void *userdata) {
2573 sd_journal *j = userdata;
2574 const void *data;
2575 size_t size, d;
2576 int r;
2577
2578 assert(field);
2579 assert(j);
2580
2581 r = sd_journal_get_data(j, field, &data, &size);
2582 if (r < 0 ||
2583 size > REPLACE_VAR_MAX)
2584 return strdup(field);
2585
2586 d = strlen(field) + 1;
2587
2588 return strndup((const char*) data + d, size - d);
2589 }
2590
2591 _public_ int sd_journal_get_catalog(sd_journal *j, char **ret) {
2592 const void *data;
2593 size_t size;
2594 sd_id128_t id;
2595 _cleanup_free_ char *text = NULL, *cid = NULL;
2596 char *t;
2597 int r;
2598
2599 if (!j)
2600 return -EINVAL;
2601 if (!ret)
2602 return -EINVAL;
2603
2604 r = sd_journal_get_data(j, "MESSAGE_ID", &data, &size);
2605 if (r < 0)
2606 return r;
2607
2608 cid = strndup((const char*) data + 11, size - 11);
2609 if (!cid)
2610 return -ENOMEM;
2611
2612 r = sd_id128_from_string(cid, &id);
2613 if (r < 0)
2614 return r;
2615
2616 r = catalog_get(CATALOG_DATABASE, id, &text);
2617 if (r < 0)
2618 return r;
2619
2620 t = replace_var(text, lookup_field, j);
2621 if (!t)
2622 return -ENOMEM;
2623
2624 *ret = t;
2625 return 0;
2626 }
2627
2628 _public_ int sd_journal_get_catalog_for_message_id(sd_id128_t id, char **ret) {
2629 if (!ret)
2630 return -EINVAL;
2631
2632 return catalog_get(CATALOG_DATABASE, id, ret);
2633 }
2634
2635 _public_ int sd_journal_set_data_threshold(sd_journal *j, size_t sz) {
2636 if (!j)
2637 return -EINVAL;
2638
2639 j->data_threshold = sz;
2640 return 0;
2641 }
2642
2643 _public_ int sd_journal_get_data_threshold(sd_journal *j, size_t *sz) {
2644 if (!j)
2645 return -EINVAL;
2646 if (!sz)
2647 return -EINVAL;
2648
2649 *sz = j->data_threshold;
2650 return 0;
2651 }
Unnamed repository; edit this file 'description' to name the repository.