#include <string.h>
#include <sys/mman.h>
#include <locale.h>
+#include <libgen.h>
#include "util.h"
#include "log.h"
#include "conf-files.h"
#include "mkdir.h"
#include "catalog.h"
+#include "siphash24.h"
-static const char * const conf_file_dirs[] = {
+const char * const catalog_file_dirs[] = {
"/usr/local/lib/systemd/catalog/",
"/usr/lib/systemd/catalog/",
NULL
le64_t offset;
} CatalogItem;
-static unsigned catalog_hash_func(const void *p) {
+static unsigned long catalog_hash_func(const void *p, const uint8_t hash_key[HASH_KEY_SIZE]) {
const CatalogItem *i = p;
+ uint64_t u;
+ size_t l, sz;
+ void *v;
- assert_cc(sizeof(unsigned) == sizeof(uint8_t)*4);
-
- return (((unsigned) i->id.bytes[0] << 24) |
- ((unsigned) i->id.bytes[1] << 16) |
- ((unsigned) i->id.bytes[2] << 8) |
- ((unsigned) i->id.bytes[3])) ^
- (((unsigned) i->id.bytes[4] << 24) |
- ((unsigned) i->id.bytes[5] << 16) |
- ((unsigned) i->id.bytes[6] << 8) |
- ((unsigned) i->id.bytes[7])) ^
- (((unsigned) i->id.bytes[8] << 24) |
- ((unsigned) i->id.bytes[9] << 16) |
- ((unsigned) i->id.bytes[10] << 8) |
- ((unsigned) i->id.bytes[11])) ^
- (((unsigned) i->id.bytes[12] << 24) |
- ((unsigned) i->id.bytes[13] << 16) |
- ((unsigned) i->id.bytes[14] << 8) |
- ((unsigned) i->id.bytes[15])) ^
- string_hash_func(i->language);
+ l = strlen(i->language);
+ sz = sizeof(i->id) + l;
+ v = alloca(sz);
+
+ memcpy(mempcpy(v, &i->id, sizeof(i->id)), i->language, l);
+
+ siphash24((uint8_t*) &u, v, sz, hash_key);
+
+ return (unsigned long) u;
}
static int catalog_compare_func(const void *a, const void *b) {
return strcmp(i->language, j->language);
}
+const struct hash_ops catalog_hash_ops = {
+ .hash = catalog_hash_func,
+ .compare = catalog_compare_func
+};
+
static int finish_item(
Hashmap *h,
struct strbuf *sb,
const char *payload) {
ssize_t offset;
- CatalogItem *i;
+ _cleanup_free_ CatalogItem *i = NULL;
int r;
assert(h);
return log_oom();
i->id = id;
- strscpy(i->language, sizeof(i->language), language);
+ if (language) {
+ assert(strlen(language) > 1 && strlen(language) < 32);
+ strcpy(i->language, language);
+ }
i->offset = htole64((uint64_t) offset);
r = hashmap_put(h, i, i);
- if (r == EEXIST) {
+ if (r == -EEXIST) {
log_warning("Duplicate entry for " SD_ID128_FORMAT_STR ".%s, ignoring.",
SD_ID128_FORMAT_VAL(id), language ? language : "C");
- free(i);
return 0;
+ } else if (r < 0)
+ return r;
+
+ i = NULL;
+ return 0;
+}
+
+int catalog_file_lang(const char* filename, char **lang) {
+ char *beg, *end, *_lang;
+
+ end = endswith(filename, ".catalog");
+ if (!end)
+ return 0;
+
+ beg = end - 1;
+ while (beg > filename && *beg != '.' && *beg != '/' && end - beg < 32)
+ beg --;
+
+ if (*beg != '.' || end <= beg + 1)
+ return 0;
+
+ _lang = strndup(beg + 1, end - beg - 1);
+ if (!_lang)
+ return -ENOMEM;
+
+ *lang = _lang;
+ return 1;
+}
+
+static int catalog_entry_lang(const char* filename, int line,
+ const char* t, const char* deflang, char **lang) {
+ size_t c;
+
+ c = strlen(t);
+ if (c == 0) {
+ log_error("[%s:%u] Language too short.", filename, line);
+ return -EINVAL;
}
+ if (c > 31) {
+ log_error("[%s:%u] language too long.", filename, line);
+ return -EINVAL;
+ }
+
+ if (deflang) {
+ if (streq(t, deflang)) {
+ log_warning("[%s:%u] language specified unnecessarily",
+ filename, line);
+ return 0;
+ } else
+ log_warning("[%s:%u] language differs from default for file",
+ filename, line);
+ }
+
+ *lang = strdup(t);
+ if (!*lang)
+ return -ENOMEM;
return 0;
}
-static int import_file(Hashmap *h, struct strbuf *sb, const char *path) {
+int catalog_import_file(Hashmap *h, struct strbuf *sb, const char *path) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *payload = NULL;
unsigned n = 0;
sd_id128_t id;
- char language[32];
+ _cleanup_free_ char *deflang = NULL, *lang = NULL;
bool got_id = false, empty_line = true;
int r;
return -errno;
}
+ r = catalog_file_lang(path, &deflang);
+ if (r < 0)
+ log_error("Failed to determine language for file %s: %m", path);
+ if (r == 1)
+ log_debug("File %s has language %s.", path, deflang);
+
for (;;) {
char line[LINE_MAX];
size_t a, b, c;
continue;
}
- if (strchr(COMMENTS, line[0]))
+ if (strchr(COMMENTS "\n", line[0]))
continue;
if (empty_line &&
if (sd_id128_from_string(line + 2 + 1, &jd) >= 0) {
if (got_id) {
- r = finish_item(h, sb, id, language, payload);
+ r = finish_item(h, sb, id, lang ?: deflang, payload);
if (r < 0)
return r;
+
+ free(lang);
+ lang = NULL;
}
if (with_language) {
t = strstrip(line + 2 + 1 + 32 + 1);
- c = strlen(t);
- if (c <= 0) {
- log_error("[%s:%u] Language too short.", path, n);
- return -EINVAL;
- }
- if (c > sizeof(language) - 1) {
- log_error("[%s:%u] language too long.", path, n);
- return -EINVAL;
- }
-
- strscpy(language, sizeof(language), t);
- } else
- language[0] = '\0';
+ r = catalog_entry_lang(path, n, t, deflang, &lang);
+ if (r < 0)
+ return r;
+ }
got_id = true;
empty_line = false;
}
if (got_id) {
- r = finish_item(h, sb, id, language, payload);
+ r = finish_item(h, sb, id, lang ?: deflang, payload);
if (r < 0)
return r;
}
return 0;
}
-#define CATALOG_DATABASE CATALOG_PATH "/database"
-
-int catalog_update(void) {
- _cleanup_strv_free_ char **files = NULL;
- _cleanup_fclose_ FILE *w = NULL;
- _cleanup_free_ char *p = NULL;
- char **f;
- Hashmap *h;
- struct strbuf *sb = NULL;
- _cleanup_free_ CatalogItem *items = NULL;
- CatalogItem *i;
+static long write_catalog(const char *database, Hashmap *h, struct strbuf *sb,
+ CatalogItem *items, size_t n) {
CatalogHeader header;
- size_t k;
- Iterator j;
- unsigned n;
+ _cleanup_fclose_ FILE *w = NULL;
int r;
+ _cleanup_free_ char *d, *p = NULL;
+ size_t k;
- h = hashmap_new(catalog_hash_func, catalog_compare_func);
- if (!h)
- return -ENOMEM;
-
- sb = strbuf_new();
- if (!sb) {
- r = log_oom();
- goto finish;
- }
-
- r = conf_files_list_strv(&files, ".catalog", NULL, (const char **) conf_file_dirs);
- if (r < 0) {
- log_error("Failed to get catalog files: %s", strerror(-r));
- goto finish;
- }
-
- STRV_FOREACH(f, files) {
- log_debug("reading file '%s'", *f);
- import_file(h, sb, *f);
- }
-
- if (hashmap_size(h) <= 0) {
- log_info("No items in catalog.");
- r = 0;
- goto finish;
- } else
- log_debug("Found %u items in catalog.", hashmap_size(h));
-
- strbuf_complete(sb);
-
- items = new(CatalogItem, hashmap_size(h));
- if (!items) {
- r = log_oom();
- goto finish;
- }
-
- n = 0;
- HASHMAP_FOREACH(i, h, j) {
- log_debug("Found " SD_ID128_FORMAT_STR ", language %s",
- SD_ID128_FORMAT_VAL(i->id),
- isempty(i->language) ? "C" : i->language);
- items[n++] = *i;
- }
-
- assert(n == hashmap_size(h));
- qsort(items, n, sizeof(CatalogItem), catalog_compare_func);
+ d = dirname_malloc(database);
+ if (!d)
+ return log_oom();
- r = mkdir_p(CATALOG_PATH, 0775);
+ r = mkdir_p(d, 0775);
if (r < 0) {
- log_error("Recursive mkdir %s: %s", CATALOG_PATH, strerror(-r));
- goto finish;
+ log_error("Recursive mkdir %s: %s", d, strerror(-r));
+ return r;
}
- r = fopen_temporary(CATALOG_DATABASE, &w, &p);
+ r = fopen_temporary(database, &w, &p);
if (r < 0) {
log_error("Failed to open database for writing: %s: %s",
- CATALOG_DATABASE, strerror(-r));
- goto finish;
+ database, strerror(-r));
+ return r;
}
zero(header);
header.catalog_item_size = htole64(sizeof(CatalogItem));
header.n_items = htole64(hashmap_size(h));
+ r = -EIO;
+
k = fwrite(&header, 1, sizeof(header), w);
if (k != sizeof(header)) {
log_error("%s: failed to write header.", p);
- goto finish;
+ goto error;
}
k = fwrite(items, 1, n * sizeof(CatalogItem), w);
if (k != n * sizeof(CatalogItem)) {
log_error("%s: failed to write database.", p);
- goto finish;
+ goto error;
}
k = fwrite(sb->buf, 1, sb->len, w);
if (k != sb->len) {
log_error("%s: failed to write strings.", p);
- goto finish;
+ goto error;
}
fflush(w);
if (ferror(w)) {
log_error("%s: failed to write database.", p);
- goto finish;
+ goto error;
}
fchmod(fileno(w), 0644);
- if (rename(p, CATALOG_DATABASE) < 0) {
- log_error("rename (%s -> %s) failed: %m", p, CATALOG_DATABASE);
+ if (rename(p, database) < 0) {
+ log_error("rename (%s -> %s) failed: %m", p, database);
r = -errno;
+ goto error;
+ }
+
+ return ftell(w);
+
+error:
+ unlink(p);
+ return r;
+}
+
+int catalog_update(const char* database, const char* root, const char* const* dirs) {
+ _cleanup_strv_free_ char **files = NULL;
+ char **f;
+ struct strbuf *sb = NULL;
+ _cleanup_hashmap_free_free_ Hashmap *h = NULL;
+ _cleanup_free_ CatalogItem *items = NULL;
+ CatalogItem *i;
+ Iterator j;
+ unsigned n;
+ long r;
+
+ h = hashmap_new(&catalog_hash_ops);
+ sb = strbuf_new();
+
+ if (!h || !sb) {
+ r = log_oom();
goto finish;
}
- log_debug("%s: wrote %u items, with %zu bytes of strings, %ld total size.",
- CATALOG_DATABASE, n, sb->len, ftell(w));
+ r = conf_files_list_strv(&files, ".catalog", root, dirs);
+ if (r < 0) {
+ log_error("Failed to get catalog files: %s", strerror(-r));
+ goto finish;
+ }
- free(p);
- p = NULL;
+ STRV_FOREACH(f, files) {
+ log_debug("Reading file '%s'", *f);
+ r = catalog_import_file(h, sb, *f);
+ if (r < 0) {
+ log_error("Failed to import file '%s': %s.",
+ *f, strerror(-r));
+ goto finish;
+ }
+ }
- r = 0;
+ if (hashmap_size(h) <= 0) {
+ log_info("No items in catalog.");
+ goto finish;
+ } else
+ log_debug("Found %u items in catalog.", hashmap_size(h));
-finish:
- hashmap_free_free(h);
+ strbuf_complete(sb);
+ items = new(CatalogItem, hashmap_size(h));
+ if (!items) {
+ r = log_oom();
+ goto finish;
+ }
+
+ n = 0;
+ HASHMAP_FOREACH(i, h, j) {
+ log_debug("Found " SD_ID128_FORMAT_STR ", language %s",
+ SD_ID128_FORMAT_VAL(i->id),
+ isempty(i->language) ? "C" : i->language);
+ items[n++] = *i;
+ }
+
+ assert(n == hashmap_size(h));
+ qsort_safe(items, n, sizeof(CatalogItem), catalog_compare_func);
+
+ r = write_catalog(database, h, sb, items, n);
+ if (r < 0)
+ log_error("Failed to write %s: %s", database, strerror(-r));
+ else
+ log_debug("%s: wrote %u items, with %zu bytes of strings, %ld total size.",
+ database, n, sb->len, r);
+
+finish:
if (sb)
strbuf_cleanup(sb);
- if (p)
- unlink(p);
-
- return r;
+ return r < 0 ? r : 0;
}
-static int open_mmap(int *_fd, struct stat *_st, void **_p) {
+static int open_mmap(const char *database, int *_fd, struct stat *_st, void **_p) {
const CatalogHeader *h;
int fd;
void *p;
assert(_st);
assert(_p);
- fd = open(CATALOG_DATABASE, O_RDONLY|O_CLOEXEC);
+ fd = open(database, O_RDONLY|O_CLOEXEC);
if (fd < 0)
return -errno;
if (fstat(fd, &st) < 0) {
- close_nointr_nofail(fd);
+ safe_close(fd);
return -errno;
}
if (st.st_size < (off_t) sizeof(CatalogHeader)) {
- close_nointr_nofail(fd);
+ safe_close(fd);
return -EINVAL;
}
p = mmap(NULL, PAGE_ALIGN(st.st_size), PROT_READ, MAP_SHARED, fd, 0);
if (p == MAP_FAILED) {
- close_nointr_nofail(fd);
+ safe_close(fd);
return -errno;
}
h->incompatible_flags != 0 ||
le64toh(h->n_items) <= 0 ||
st.st_size < (off_t) (le64toh(h->header_size) + le64toh(h->catalog_item_size) * le64toh(h->n_items))) {
- close_nointr_nofail(fd);
+ safe_close(fd);
munmap(p, st.st_size);
return -EBADMSG;
}
le64toh(f->offset);
}
-int catalog_get(sd_id128_t id, char **_text) {
+int catalog_get(const char* database, sd_id128_t id, char **_text) {
_cleanup_close_ int fd = -1;
void *p = NULL;
struct stat st;
assert(_text);
- r = open_mmap(&fd, &st, &p);
+ r = open_mmap(database, &fd, &st, &p);
if (r < 0)
return r;
}
-int catalog_list(FILE *f, bool oneline) {
+int catalog_list(FILE *f, const char *database, bool oneline) {
_cleanup_close_ int fd = -1;
void *p = NULL;
struct stat st;
sd_id128_t last_id;
bool last_id_set = false;
- r = open_mmap(&fd, &st, &p);
+ r = open_mmap(database, &fd, &st, &p);
if (r < 0)
return r;
return 0;
}
-int catalog_list_items(FILE *f, bool oneline, char **items) {
+int catalog_list_items(FILE *f, const char *database, bool oneline, char **items) {
char **item;
int r = 0;
STRV_FOREACH(item, items) {
sd_id128_t id;
int k;
- char _cleanup_free_ *msg = NULL;
+ _cleanup_free_ char *msg = NULL;
k = sd_id128_from_string(*item, &id);
if (k < 0) {
continue;
}
- k = catalog_get(id, &msg);
+ k = catalog_get(database, id, &msg);
if (k < 0) {
log_full(k == -ENOENT ? LOG_NOTICE : LOG_ERR,
"Failed to retrieve catalog entry for '%s': %s",