From 4bc17b038971160f94321c7be9cd924b256d9ef8 Mon Sep 17 00:00:00 2001 From: Michal Sekletar Date: Tue, 15 Mar 2022 19:02:05 +0100 Subject: [PATCH] core: shorten long unit names that are based on paths and append path hash at the end Fixes #18077 (cherry picked from commit 1d0727e76fd5e9a07cc9991ec9a10ea1d78a99c7) Resolves: #2083493 --- src/basic/string-util.h | 23 ++++++----- src/basic/unit-name.c | 86 ++++++++++++++++++++++++++++++++++++++- src/basic/unit-name.h | 3 ++ src/core/mount.c | 3 ++ src/test/test-unit-name.c | 26 ++++++++++-- 5 files changed, 125 insertions(+), 16 deletions(-) diff --git a/src/basic/string-util.h b/src/basic/string-util.h index a1d88fbb95..ffb69e69cc 100644 --- a/src/basic/string-util.h +++ b/src/basic/string-util.h @@ -10,17 +10,18 @@ #include "string-util-fundamental.h" /* What is interpreted as whitespace? */ -#define WHITESPACE " \t\n\r" -#define NEWLINE "\n\r" -#define QUOTES "\"\'" -#define COMMENTS "#;" -#define GLOB_CHARS "*?[" -#define DIGITS "0123456789" -#define LOWERCASE_LETTERS "abcdefghijklmnopqrstuvwxyz" -#define UPPERCASE_LETTERS "ABCDEFGHIJKLMNOPQRSTUVWXYZ" -#define LETTERS LOWERCASE_LETTERS UPPERCASE_LETTERS -#define ALPHANUMERICAL LETTERS DIGITS -#define HEXDIGITS DIGITS "abcdefABCDEF" +#define WHITESPACE " \t\n\r" +#define NEWLINE "\n\r" +#define QUOTES "\"\'" +#define COMMENTS "#;" +#define GLOB_CHARS "*?[" +#define DIGITS "0123456789" +#define LOWERCASE_LETTERS "abcdefghijklmnopqrstuvwxyz" +#define UPPERCASE_LETTERS "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +#define LETTERS LOWERCASE_LETTERS UPPERCASE_LETTERS +#define ALPHANUMERICAL LETTERS DIGITS +#define HEXDIGITS DIGITS "abcdefABCDEF" +#define LOWERCASE_HEXDIGITS DIGITS "abcdef" static inline char* strstr_ptr(const char *haystack, const char *needle) { if (!haystack || !needle) diff --git a/src/basic/unit-name.c b/src/basic/unit-name.c index 671e30a53f..6cba8ba140 100644 --- a/src/basic/unit-name.c +++ b/src/basic/unit-name.c @@ -5,12 +5,17 @@ #include #include +#include "sd-id128.h" + #include "alloc-util.h" #include "glob-util.h" #include "hexdecoct.h" #include "memory-util.h" #include "path-util.h" +#include "random-util.h" +#include "sparse-endian.h" #include "special.h" +#include "stdio-util.h" #include "string-util.h" #include "strv.h" #include "unit-name.h" @@ -31,6 +36,9 @@ VALID_CHARS_WITH_AT \ "[]!-*?" +#define LONG_UNIT_NAME_HASH_KEY SD_ID128_MAKE(ec,f2,37,fb,58,32,4a,32,84,9f,06,9b,0d,21,eb,9a) +#define UNIT_NAME_HASH_LENGTH_CHARS 16 + bool unit_name_is_valid(const char *n, UnitNameFlags flags) { const char *e, *i, *at; @@ -507,6 +515,68 @@ int unit_name_template(const char *f, char **ret) { return 0; } +bool unit_name_is_hashed(const char *name) { + char *s; + + if (!unit_name_is_valid(name, UNIT_NAME_PLAIN)) + return false; + + assert_se(s = strrchr(name, '.')); + + if (s - name < UNIT_NAME_HASH_LENGTH_CHARS + 1) + return false; + + s -= UNIT_NAME_HASH_LENGTH_CHARS; + if (s[-1] != '_') + return false; + + for (size_t i = 0; i < UNIT_NAME_HASH_LENGTH_CHARS; i++) + if (!strchr(LOWERCASE_HEXDIGITS, s[i])) + return false; + + return true; +} + +int unit_name_hash_long(const char *name, char **ret) { + _cleanup_free_ char *n = NULL, *hash = NULL; + char *suffix; + le64_t h; + size_t len; + + if (strlen(name) < UNIT_NAME_MAX) + return -EMSGSIZE; + + suffix = strrchr(name, '.'); + if (!suffix) + return -EINVAL; + + if (unit_type_from_string(suffix+1) < 0) + return -EINVAL; + + h = htole64(siphash24_string(name, LONG_UNIT_NAME_HASH_KEY.bytes)); + + hash = hexmem(&h, sizeof(h)); + if (!hash) + return -ENOMEM; + + assert_se(strlen(hash) == UNIT_NAME_HASH_LENGTH_CHARS); + + len = UNIT_NAME_MAX - 1 - strlen(suffix+1) - UNIT_NAME_HASH_LENGTH_CHARS - 2; + assert(len > 0 && len < UNIT_NAME_MAX); + + n = strndup(name, len); + if (!n) + return -ENOMEM; + + if (!strextend(&n, "_", hash, suffix)) + return -ENOMEM; + assert_se(unit_name_is_valid(n, UNIT_NAME_PLAIN)); + + *ret = TAKE_PTR(n); + + return 0; +} + int unit_name_from_path(const char *path, const char *suffix, char **ret) { _cleanup_free_ char *p = NULL, *s = NULL; int r; @@ -526,8 +596,17 @@ int unit_name_from_path(const char *path, const char *suffix, char **ret) { if (!s) return -ENOMEM; - if (strlen(s) >= UNIT_NAME_MAX) /* Return a slightly more descriptive error for this specific condition */ - return -ENAMETOOLONG; + if (strlen(s) >= UNIT_NAME_MAX) { + _cleanup_free_ char *n = NULL; + + log_debug("Unit name \"%s\" too long, falling back to hashed unit name.", s); + + r = unit_name_hash_long(s, &n); + if (r < 0) + return r; + + free_and_replace(s, n); + } /* Refuse if this for some other reason didn't result in a valid name */ if (!unit_name_is_valid(s, UNIT_NAME_PLAIN)) @@ -581,6 +660,9 @@ int unit_name_to_path(const char *name, char **ret) { if (r < 0) return r; + if (unit_name_is_hashed(name)) + return -ENAMETOOLONG; + return unit_name_path_unescape(prefix, ret); } diff --git a/src/basic/unit-name.h b/src/basic/unit-name.h index b62b3e034e..eaa701e9f6 100644 --- a/src/basic/unit-name.h +++ b/src/basic/unit-name.h @@ -44,6 +44,9 @@ int unit_name_replace_instance(const char *f, const char *i, char **ret); int unit_name_template(const char *f, char **ret); +int unit_name_hash_long(const char *name, char **ret); +bool unit_name_is_hashed(const char *name); + int unit_name_from_path(const char *path, const char *suffix, char **ret); int unit_name_from_path_instance(const char *prefix, const char *path, const char *suffix, char **ret); int unit_name_to_path(const char *name, char **ret); diff --git a/src/core/mount.c b/src/core/mount.c index 4d407ca4e5..d63884e47e 100644 --- a/src/core/mount.c +++ b/src/core/mount.c @@ -622,6 +622,9 @@ static int mount_add_extras(Mount *m) { if (!m->where) { r = unit_name_to_path(u->id, &m->where); + if (r == -ENAMETOOLONG) + log_unit_error_errno(u, r, "Failed to derive mount point path from unit name, because unit name is hashed. " + "Set \"Where=\" in the unit file explicitly."); if (r < 0) return r; } diff --git a/src/test/test-unit-name.c b/src/test/test-unit-name.c index 8cd0e0b4a1..b6137333aa 100644 --- a/src/test/test-unit-name.c +++ b/src/test/test-unit-name.c @@ -106,6 +106,7 @@ TEST(unit_name_replace_instance) { static void test_unit_name_from_path_one(const char *path, const char *suffix, const char *expected, int ret) { _cleanup_free_ char *t = NULL; + int r; assert_se(unit_name_from_path(path, suffix, &t) == ret); puts(strna(t)); @@ -113,12 +114,31 @@ static void test_unit_name_from_path_one(const char *path, const char *suffix, c if (t) { _cleanup_free_ char *k = NULL; - assert_se(unit_name_to_path(t, &k) == 0); + + /* We don't support converting hashed unit names back to paths */ + r = unit_name_to_path(t, &k); + if (r == -ENAMETOOLONG) + return; + assert(r == 0); + puts(strna(k)); assert_se(path_equal(k, empty_to_root(path))); } } +TEST(unit_name_is_hashed) { + assert_se(!unit_name_is_hashed("")); + assert_se(!unit_name_is_hashed("foo@bar.service")); + assert_se(!unit_name_is_hashed("foo@.service")); + assert_se(unit_name_is_hashed("waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_7736d9ed33c2ec55.mount")); + assert_se(!unit_name_is_hashed("waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_7736D9ED33C2EC55.mount")); + assert_se(!unit_name_is_hashed("waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!7736d9ed33c2ec55.mount")); + assert_se(!unit_name_is_hashed("waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_7736d9gd33c2ec55.mount")); + assert_se(!unit_name_is_hashed("waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_.mount")); + assert_se(!unit_name_is_hashed("waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_2103e1466b87f7f7@waldo.mount")); + assert_se(!unit_name_is_hashed("waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_2103e1466b87f7f7@.mount")); +} + TEST(unit_name_from_path) { test_unit_name_from_path_one("/waldo", ".mount", "waldo.mount", 0); test_unit_name_from_path_one("/waldo/quuix", ".mount", "waldo-quuix.mount", 0); @@ -128,7 +148,8 @@ TEST(unit_name_from_path) { test_unit_name_from_path_one("///", ".mount", "-.mount", 0); test_unit_name_from_path_one("/foo/../bar", ".mount", NULL, -EINVAL); test_unit_name_from_path_one("/foo/./bar", ".mount", "foo-bar.mount", 0); - test_unit_name_from_path_one("/waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", ".mount", NULL, -ENAMETOOLONG); + test_unit_name_from_path_one("/waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", ".mount", + "waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_7736d9ed33c2ec55.mount", 0); } static void test_unit_name_from_path_instance_one(const char *pattern, const char *path, const char *suffix, const char *expected, int ret) { @@ -156,7 +177,6 @@ TEST(unit_name_from_path_instance) { test_unit_name_from_path_instance_one("waldo", "..", ".mount", NULL, -EINVAL); test_unit_name_from_path_instance_one("waldo", "/foo", ".waldi", NULL, -EINVAL); test_unit_name_from_path_instance_one("wa--ldo", "/--", ".mount", "wa--ldo@\\x2d\\x2d.mount", 0); - test_unit_name_from_path_instance_one("waldoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "/waldo", ".mount", NULL, -ENAMETOOLONG); } static void test_unit_name_to_path_one(const char *unit, const char *path, int ret) {