1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
14 #include "alloc-util.h"
16 #include "conf-files.h"
22 #include "memory-util.h"
24 #include "path-util.h"
25 #include "siphash24.h"
26 #include "sort-util.h"
27 #include "sparse-endian.h"
29 #include "string-util.h"
31 #include "tmpfile-util.h"
33 const char * const catalog_file_dirs
[] = {
34 "/usr/local/lib/systemd/catalog/",
35 "/usr/lib/systemd/catalog/",
39 #define CATALOG_SIGNATURE { 'R', 'H', 'H', 'H', 'K', 'S', 'L', 'P' }
41 typedef struct CatalogHeader
{
42 uint8_t signature
[8]; /* "RHHHKSLP" */
43 le32_t compatible_flags
;
44 le32_t incompatible_flags
;
47 le64_t catalog_item_size
;
50 typedef struct CatalogItem
{
52 char language
[32]; /* One byte is used for termination, so the maximum allowed
53 * length of the string is actually 31 bytes. */
57 static void catalog_hash_func(const CatalogItem
*i
, struct siphash
*state
) {
58 siphash24_compress_typesafe(i
->id
, state
);
59 siphash24_compress_string(i
->language
, state
);
62 static int catalog_compare_func(const CatalogItem
*a
, const CatalogItem
*b
) {
66 for (k
= 0; k
< ELEMENTSOF(b
->id
.bytes
); k
++) {
67 r
= CMP(a
->id
.bytes
[k
], b
->id
.bytes
[k
]);
72 return strcmp(a
->language
, b
->language
);
75 DEFINE_HASH_OPS(catalog_hash_ops
, CatalogItem
, catalog_hash_func
, catalog_compare_func
);
77 static bool next_header(const char **s
) {
94 static const char *skip_header(const char *s
) {
95 while (next_header(&s
))
100 static char *combine_entries(const char *one
, const char *two
) {
105 /* Find split point of headers to body */
106 b1
= skip_header(one
);
107 b2
= skip_header(two
);
111 dest
= new(char, l1
+ l2
+ 1);
119 /* Headers from @one */
121 p
= mempcpy(p
, one
, n
);
123 /* Headers from @two, these will only be found if not present above */
125 p
= mempcpy(p
, two
, n
);
130 p
= mempcpy(p
, b1
, n
);
134 p
= mempcpy(p
, b2
, n
);
137 assert(p
- dest
<= (ptrdiff_t)(l1
+ l2
));
142 static int finish_item(
145 const char *language
,
146 char *payload
, size_t payload_size
) {
148 _cleanup_free_ CatalogItem
*i
= NULL
;
149 _cleanup_free_
char *combined
= NULL
;
155 assert(payload_size
> 0);
157 i
= new0(CatalogItem
, 1);
163 assert(strlen(language
) > 1 && strlen(language
) < 32);
164 strcpy(i
->language
, language
);
167 prev
= ordered_hashmap_get(h
, i
);
169 /* Already have such an item, combine them */
170 combined
= combine_entries(payload
, prev
);
174 r
= ordered_hashmap_update(h
, i
, combined
);
176 return log_error_errno(r
, "Failed to update catalog item: %m");
182 combined
= memdup(payload
, payload_size
+ 1);
186 r
= ordered_hashmap_put(h
, i
, combined
);
188 return log_error_errno(r
, "Failed to insert catalog item: %m");
197 int catalog_file_lang(const char* filename
, char **lang
) {
198 char *beg
, *end
, *_lang
;
200 end
= endswith(filename
, ".catalog");
205 while (beg
> filename
&& !IN_SET(*beg
, '.', '/') && end
- beg
< 32)
208 if (*beg
!= '.' || end
<= beg
+ 1)
211 _lang
= strndup(beg
+ 1, end
- beg
- 1);
219 static int catalog_entry_lang(
220 const char* filename
,
226 size_t c
= strlen(t
);
228 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
229 "[%s:%u] Language too short.", filename
, line
);
231 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
232 "[%s:%u] language too long.", filename
, line
);
235 if (streq(t
, deflang
)) {
236 log_warning("[%s:%u] language specified unnecessarily", filename
, line
);
240 log_warning("[%s:%u] language differs from default for file", filename
, line
);
243 return strdup_to(ret
, t
);
246 int catalog_import_file(OrderedHashmap
*h
, const char *path
) {
247 _cleanup_fclose_
FILE *f
= NULL
;
248 _cleanup_free_
char *payload
= NULL
;
249 size_t payload_size
= 0;
252 _cleanup_free_
char *deflang
= NULL
, *lang
= NULL
;
253 bool got_id
= false, empty_line
= true;
259 f
= fopen(path
, "re");
261 return log_error_errno(errno
, "Failed to open file %s: %m", path
);
263 r
= catalog_file_lang(path
, &deflang
);
265 log_error_errno(r
, "Failed to determine language for file %s: %m", path
);
267 log_debug("File %s has language %s.", path
, deflang
);
270 _cleanup_free_
char *line
= NULL
;
273 r
= read_line(f
, LONG_LINE_MAX
, &line
);
275 return log_error_errno(r
, "Failed to read file %s: %m", path
);
286 if (strchr(COMMENTS
, line
[0]))
290 strlen(line
) >= 2+1+32 &&
294 IN_SET(line
[2+1+32], ' ', '\0')) {
301 with_language
= line
[2+1+32] != '\0';
304 if (sd_id128_from_string(line
+ 2 + 1, &jd
) >= 0) {
307 if (payload_size
== 0)
308 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
309 "[%s:%u] No payload text.",
313 r
= finish_item(h
, id
, lang
?: deflang
, payload
, payload_size
);
324 t
= strstrip(line
+ 2 + 1 + 32 + 1);
325 r
= catalog_entry_lang(path
, n
, t
, deflang
, &lang
);
340 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
341 "[%s:%u] Got payload before ID.",
344 line_len
= strlen(line
);
345 if (!GREEDY_REALLOC(payload
, payload_size
+ (empty_line
? 1 : 0) + line_len
+ 1 + 1))
349 payload
[payload_size
++] = '\n';
350 memcpy(payload
+ payload_size
, line
, line_len
);
351 payload_size
+= line_len
;
352 payload
[payload_size
++] = '\n';
353 payload
[payload_size
] = '\0';
359 if (payload_size
== 0)
360 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
),
361 "[%s:%u] No payload text.",
364 r
= finish_item(h
, id
, lang
?: deflang
, payload
, payload_size
);
372 static int64_t write_catalog(
373 const char *database
,
378 _cleanup_(unlink_and_freep
) char *p
= NULL
;
379 _cleanup_fclose_
FILE *w
= NULL
;
382 r
= mkdir_parents(database
, 0755);
384 return log_error_errno(r
, "Failed to create parent directories of %s: %m", database
);
386 r
= fopen_temporary(database
, &w
, &p
);
388 return log_error_errno(r
, "Failed to open database for writing: %s: %m", database
);
390 CatalogHeader header
= {
391 .signature
= CATALOG_SIGNATURE
,
392 .header_size
= htole64(CONST_ALIGN_TO(sizeof(CatalogHeader
), 8)),
393 .catalog_item_size
= htole64(sizeof(CatalogItem
)),
394 .n_items
= htole64(n
),
397 if (fwrite(&header
, sizeof(header
), 1, w
) != 1)
398 return log_error_errno(SYNTHETIC_ERRNO(EIO
), "%s: failed to write header.", p
);
400 if (fwrite(items
, sizeof(CatalogItem
), n
, w
) != n
)
401 return log_error_errno(SYNTHETIC_ERRNO(EIO
), "%s: failed to write database.", p
);
403 if (fwrite(sb
->buf
, sb
->len
, 1, w
) != 1)
404 return log_error_errno(SYNTHETIC_ERRNO(EIO
), "%s: failed to write strings.", p
);
406 r
= fflush_and_check(w
);
408 return log_error_errno(r
, "%s: failed to write database: %m", p
);
410 (void) fchmod(fileno(w
), 0644);
412 if (rename(p
, database
) < 0)
413 return log_error_errno(errno
, "rename (%s -> %s) failed: %m", p
, database
);
415 p
= mfree(p
); /* free without unlinking */
419 int catalog_update(const char* database
, const char* root
, const char* const* dirs
) {
420 _cleanup_strv_free_
char **files
= NULL
;
421 _cleanup_(strbuf_freep
) struct strbuf
*sb
= NULL
;
422 _cleanup_ordered_hashmap_free_free_free_ OrderedHashmap
*h
= NULL
;
423 _cleanup_free_ CatalogItem
*items
= NULL
;
431 h
= ordered_hashmap_new(&catalog_hash_ops
);
436 r
= conf_files_list_strv(&files
, ".catalog", root
, 0, dirs
);
438 return log_error_errno(r
, "Failed to get catalog files: %m");
440 STRV_FOREACH(f
, files
) {
441 log_debug("Reading file '%s'", *f
);
442 r
= catalog_import_file(h
, *f
);
444 return log_error_errno(r
, "Failed to import file '%s': %m", *f
);
447 if (ordered_hashmap_isempty(h
)) {
448 log_info("No items in catalog.");
452 log_debug("Found %u items in catalog.", ordered_hashmap_size(h
));
454 items
= new(CatalogItem
, ordered_hashmap_size(h
));
459 ORDERED_HASHMAP_FOREACH_KEY(payload
, i
, h
) {
460 log_trace("Found " SD_ID128_FORMAT_STR
", language %s",
461 SD_ID128_FORMAT_VAL(i
->id
),
462 isempty(i
->language
) ? "C" : i
->language
);
464 offset
= strbuf_add_string(sb
, payload
);
468 i
->offset
= htole64((uint64_t) offset
);
472 assert(n
== ordered_hashmap_size(h
));
473 typesafe_qsort(items
, n
, catalog_compare_func
);
477 sz
= write_catalog(database
, sb
, items
, n
);
479 return log_error_errno(sz
, "Failed to write %s: %m", database
);
481 log_debug("%s: wrote %u items, with %zu bytes of strings, %"PRIi64
" total size.",
482 database
, n
, sb
->len
, sz
);
486 static int open_mmap(const char *database
, int *_fd
, struct stat
*_st
, void **_p
) {
487 _cleanup_close_
int fd
= -EBADF
;
488 const CatalogHeader
*h
;
496 fd
= open(database
, O_RDONLY
|O_CLOEXEC
);
500 if (fstat(fd
, &st
) < 0)
503 if (st
.st_size
< (off_t
) sizeof(CatalogHeader
) || file_offset_beyond_memory_size(st
.st_size
))
506 p
= mmap(NULL
, st
.st_size
, PROT_READ
, MAP_SHARED
, fd
, 0);
511 if (memcmp(h
->signature
, (const uint8_t[]) CATALOG_SIGNATURE
, sizeof(h
->signature
)) != 0 ||
512 le64toh(h
->header_size
) < sizeof(CatalogHeader
) ||
513 le64toh(h
->catalog_item_size
) < sizeof(CatalogItem
) ||
514 h
->incompatible_flags
!= 0 ||
515 le64toh(h
->n_items
) <= 0 ||
516 st
.st_size
< (off_t
) (le64toh(h
->header_size
) + le64toh(h
->catalog_item_size
) * le64toh(h
->n_items
))) {
517 munmap(p
, st
.st_size
);
528 static const char *find_id(void *p
, sd_id128_t id
) {
529 CatalogItem
*f
= NULL
, key
= { .id
= id
};
530 const CatalogHeader
*h
= p
;
533 loc
= setlocale(LC_MESSAGES
, NULL
);
534 if (!isempty(loc
) && !STR_IN_SET(loc
, "C", "POSIX")) {
537 len
= strcspn(loc
, ".@");
538 if (len
> sizeof(key
.language
) - 1)
539 log_debug("LC_MESSAGES value too long, ignoring: \"%.*s\"", (int) len
, loc
);
541 strncpy(key
.language
, loc
, len
);
542 key
.language
[len
] = '\0';
545 (const uint8_t*) p
+ le64toh(h
->header_size
),
547 le64toh(h
->catalog_item_size
),
548 (comparison_fn_t
) catalog_compare_func
);
552 e
= strchr(key
.language
, '_');
556 (const uint8_t*) p
+ le64toh(h
->header_size
),
558 le64toh(h
->catalog_item_size
),
559 (comparison_fn_t
) catalog_compare_func
);
568 (const uint8_t*) p
+ le64toh(h
->header_size
),
570 le64toh(h
->catalog_item_size
),
571 (comparison_fn_t
) catalog_compare_func
);
577 return (const char*) p
+
578 le64toh(h
->header_size
) +
579 le64toh(h
->n_items
) * le64toh(h
->catalog_item_size
) +
583 int catalog_get(const char* database
, sd_id128_t id
, char **ret_text
) {
584 _cleanup_close_
int fd
= -EBADF
;
592 r
= open_mmap(database
, &fd
, &st
, &p
);
602 r
= strdup_to(ret_text
, s
);
604 (void) munmap(p
, st
.st_size
);
609 static char *find_header(const char *s
, const char *header
) {
614 v
= startswith(s
, header
);
616 v
+= strspn(v
, WHITESPACE
);
617 return strndup(v
, strcspn(v
, NEWLINE
));
620 if (!next_header(&s
))
625 static void dump_catalog_entry(FILE *f
, sd_id128_t id
, const char *s
, bool oneline
) {
627 _cleanup_free_
char *subject
= NULL
, *defined_by
= NULL
;
629 subject
= find_header(s
, "Subject:");
630 defined_by
= find_header(s
, "Defined-By:");
632 fprintf(f
, SD_ID128_FORMAT_STR
" %s: %s\n",
633 SD_ID128_FORMAT_VAL(id
),
634 strna(defined_by
), strna(subject
));
636 fprintf(f
, "-- " SD_ID128_FORMAT_STR
"\n%s\n",
637 SD_ID128_FORMAT_VAL(id
), s
);
640 int catalog_list(FILE *f
, const char *database
, bool oneline
) {
641 _cleanup_close_
int fd
= -EBADF
;
644 const CatalogHeader
*h
;
645 const CatalogItem
*items
;
649 bool last_id_set
= false;
651 r
= open_mmap(database
, &fd
, &st
, &p
);
656 items
= (const CatalogItem
*) ((const uint8_t*) p
+ le64toh(h
->header_size
));
658 for (n
= 0; n
< le64toh(h
->n_items
); n
++) {
661 if (last_id_set
&& sd_id128_equal(last_id
, items
[n
].id
))
664 assert_se(s
= find_id(p
, items
[n
].id
));
666 dump_catalog_entry(f
, items
[n
].id
, s
, oneline
);
669 last_id
= items
[n
].id
;
672 munmap(p
, st
.st_size
);
677 int catalog_list_items(FILE *f
, const char *database
, bool oneline
, char **items
) {
680 STRV_FOREACH(item
, items
) {
683 _cleanup_free_
char *msg
= NULL
;
685 k
= sd_id128_from_string(*item
, &id
);
687 log_error_errno(k
, "Failed to parse id128 '%s': %m", *item
);
693 k
= catalog_get(database
, id
, &msg
);
695 log_full_errno(k
== -ENOENT
? LOG_NOTICE
: LOG_ERR
, k
,
696 "Failed to retrieve catalog entry for '%s': %m", *item
);
702 dump_catalog_entry(f
, id
, msg
, oneline
);