HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/test/test-condition.c
Git blob: 59b96976d046d2018630dc4459f9c568aefcade2
Lines 1001–1819 of 1,819
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "tomoyo", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), mac_tomoyo_use());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "ima", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), use_ima());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "smack", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), mac_smack_use());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "audit", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), use_audit());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "uefi-secureboot", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), is_efi_secure_boot());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "cvm", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ),
(detect_confidential_virtualization() != CONFIDENTIAL_VIRTUALIZATION_NONE));
condition_free(condition);
}
TEST(print_securities) {
log_info("------ enabled security technologies ------");
log_info("SELinux: %s", yes_no(mac_selinux_use()));
log_info("AppArmor: %s", yes_no(mac_apparmor_use()));
log_info("Tomoyo: %s", yes_no(mac_tomoyo_use()));
log_info("IMA: %s", yes_no(use_ima()));
log_info("SMACK: %s", yes_no(mac_smack_use()));
log_info("Audit: %s", yes_no(use_audit()));
log_info("UEFI secure boot: %s", yes_no(is_efi_secure_boot()));
log_info("Confidential VM: %s", yes_no
(detect_confidential_virtualization() != CONFIDENTIAL_VIRTUALIZATION_NONE));
log_info("-------------------------------------------");
}
TEST(condition_test_virtualization) {
Condition *condition;
int r;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, "garbage oifdsjfoidsjoj", false, false)));
r = condition_test(condition, environ);
if (ERRNO_IS_PRIVILEGE(r))
return;
log_info("ConditionVirtualization=garbage → %i", r);
ASSERT_OK_ZERO(r);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, "container", false, false)));
r = condition_test(condition, environ);
log_info("ConditionVirtualization=container → %i", r);
ASSERT_OK_EQ(r, !!detect_container());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, "vm", false, false)));
r = condition_test(condition, environ);
log_info("ConditionVirtualization=vm → %i", r);
ASSERT_OK_EQ(r, (detect_vm() && !detect_container()));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, "private-users", false, false)));
r = condition_test(condition, environ);
log_info("ConditionVirtualization=private-users → %i", r);
ASSERT_OK_EQ(r, !!running_in_userns());
condition_free(condition);
NULSTR_FOREACH(virt,
"kvm\0"
"amazon\0"
"qemu\0"
"bochs\0"
"xen\0"
"uml\0"
"vmware\0"
"oracle\0"
"microsoft\0"
"zvm\0"
"parallels\0"
"bhyve\0"
"vm_other\0") {
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VIRTUALIZATION, virt, false, false)));
r = condition_test(condition, environ);
log_info("ConditionVirtualization=%s → %i", virt, r);
ASSERT_OK(r);
condition_free(condition);
}
}
TEST(condition_test_user) {
Condition *condition;
char* uid;
char* username;
int r;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, "garbage oifdsjfoidsjoj", false, false)));
r = condition_test(condition, environ);
log_info("ConditionUser=garbage → %i", r);
ASSERT_OK_ZERO(r);
condition_free(condition);
ASSERT_OK_POSITIVE(asprintf(&uid, "%"PRIu32, UINT32_C(0xFFFF)));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, uid, false, false)));
r = condition_test(condition, environ);
log_info("ConditionUser=%s → %i", uid, r);
ASSERT_OK_ZERO(r);
condition_free(condition);
free(uid);
ASSERT_OK_POSITIVE(asprintf(&uid, "%u", (unsigned)getuid()));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, uid, false, false)));
r = condition_test(condition, environ);
log_info("ConditionUser=%s → %i", uid, r);
ASSERT_OK_POSITIVE(r);
condition_free(condition);
free(uid);
ASSERT_OK_POSITIVE(asprintf(&uid, "%u", (unsigned)getuid()+1));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, uid, false, false)));
r = condition_test(condition, environ);
log_info("ConditionUser=%s → %i", uid, r);
ASSERT_OK_ZERO(r);
condition_free(condition);
free(uid);
ASSERT_NOT_NULL((username = getusername_malloc()));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, username, false, false)));
r = condition_test(condition, environ);
log_info("ConditionUser=%s → %i", username, r);
ASSERT_OK_POSITIVE(r);
condition_free(condition);
free(username);
username = (char*)(geteuid() == 0 ? NOBODY_USER_NAME : "root");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, username, false, false)));
r = condition_test(condition, environ);
log_info("ConditionUser=%s → %i", username, r);
ASSERT_OK_ZERO(r);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_USER, "@system", false, false)));
r = condition_test(condition, environ);
log_info("ConditionUser=@system → %i", r);
if (uid_is_system(getuid()) || uid_is_system(geteuid()))
ASSERT_OK_POSITIVE(r);
else
ASSERT_OK_ZERO(r);
condition_free(condition);
}
TEST(condition_test_group) {
Condition *condition;
char gid[DECIMAL_STR_MAX(uint32_t)];
gid_t *gids, max_gid;
int ngroups, r, i;
int ngroups_max;
xsprintf(gid, "%u", UINT32_C(0xFFFF));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, gid, false, false)));
r = condition_test(condition, environ);
log_info("ConditionGroup=%s → %i", gid, r);
ASSERT_OK_ZERO(r);
condition_free(condition);
xsprintf(gid, "%u", getgid());
ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, gid, false, false)));
r = condition_test(condition, environ);
log_info("ConditionGroup=%s → %i", gid, r);
ASSERT_OK_POSITIVE(r);
condition_free(condition);
ngroups_max = ASSERT_OK(sysconf_ngroups_max());
ASSERT_GT(ngroups_max, 0);
gids = newa(gid_t, ngroups_max);
ngroups = ASSERT_OK_ERRNO(getgroups(ngroups_max, gids));
max_gid = getgid();
for (i = 0; i < ngroups; i++) {
_cleanup_free_ char *name = NULL;
xsprintf(gid, "%u", gids[i]);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, gid, false, false)));
r = condition_test(condition, environ);
log_info("ConditionGroup=%s → %i", gid, r);
ASSERT_OK_POSITIVE(r);
condition_free(condition);
max_gid = gids[i] > max_gid ? gids[i] : max_gid;
ASSERT_NOT_NULL((name = gid_to_name(gids[i])));
if (STR_IN_SET(name, "sbuild", "buildd"))
return; /* Debian package build in chroot, groupnames won't match, skip */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, name, false, false)));
r = condition_test(condition, environ);
log_info("ConditionGroup=%s → %i", name, r);
ASSERT_OK_POSITIVE(r);
condition_free(condition);
max_gid = gids[i] > max_gid ? gids[i] : max_gid;
}
xsprintf(gid, "%u", max_gid + 1);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, gid, false, false)));
r = condition_test(condition, environ);
log_info("ConditionGroup=%s → %i", gid, r);
ASSERT_OK_ZERO(r);
condition_free(condition);
/* In an unprivileged user namespace with the current user mapped to root, all the auxiliary groups
* of the user will be mapped to the nobody group, which means the user in the user namespace is in
* both the root and the nobody group, meaning the next test can't work, so let's skip it in that
* case. */
if (in_group(NOBODY_GROUP_NAME) && in_group("root"))
return (void) log_tests_skipped("user is in both root and nobody group");
const char *groupname = getegid() == 0 ? NOBODY_GROUP_NAME : "root";
ASSERT_NOT_NULL((condition = condition_new(CONDITION_GROUP, groupname, false, false)));
r = condition_test(condition, environ);
log_info("ConditionGroup=%s → %i", groupname, r);
ASSERT_OK_ZERO(r);
condition_free(condition);
}
static void test_condition_test_cpus_one(const char *s, bool result) {
Condition *condition;
log_debug("%s=%s", condition_type_to_string(CONDITION_CPUS), s);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPUS, s, false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), result);
condition_free(condition);
}
TEST(condition_test_cpus) {
_cleanup_free_ char *t = NULL;
int cpus;
cpus = ASSERT_OK(cpus_in_affinity_mask());
test_condition_test_cpus_one("> 0", true);
test_condition_test_cpus_one(">= 0", true);
test_condition_test_cpus_one("!= 0", true);
test_condition_test_cpus_one("<= 0", false);
test_condition_test_cpus_one("< 0", false);
test_condition_test_cpus_one("= 0", false);
test_condition_test_cpus_one("> 100000", false);
test_condition_test_cpus_one("= 100000", false);
test_condition_test_cpus_one(">= 100000", false);
test_condition_test_cpus_one("< 100000", true);
test_condition_test_cpus_one("!= 100000", true);
test_condition_test_cpus_one("<= 100000", true);
ASSERT_OK(asprintf(&t, "= %i", cpus));
test_condition_test_cpus_one(t, true);
t = mfree(t);
ASSERT_OK(asprintf(&t, "<= %i", cpus));
test_condition_test_cpus_one(t, true);
t = mfree(t);
ASSERT_OK(asprintf(&t, ">= %i", cpus));
test_condition_test_cpus_one(t, true);
t = mfree(t);
ASSERT_OK(asprintf(&t, "!= %i", cpus));
test_condition_test_cpus_one(t, false);
t = mfree(t);
ASSERT_OK(asprintf(&t, "< %i", cpus));
test_condition_test_cpus_one(t, false);
t = mfree(t);
ASSERT_OK(asprintf(&t, "> %i", cpus));
test_condition_test_cpus_one(t, false);
t = mfree(t);
}
static void test_condition_test_memory_one(const char *s, bool result) {
Condition *condition;
log_debug("%s=%s", condition_type_to_string(CONDITION_MEMORY), s);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY, s, false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), result);
condition_free(condition);
}
TEST(condition_test_memory) {
_cleanup_free_ char *t = NULL;
uint64_t memory;
memory = physical_memory();
test_condition_test_memory_one("> 0", true);
test_condition_test_memory_one(">= 0", true);
test_condition_test_memory_one("!= 0", true);
test_condition_test_memory_one("<= 0", false);
test_condition_test_memory_one("< 0", false);
test_condition_test_memory_one("= 0", false);
test_condition_test_memory_one("> 18446744073709547520", false);
test_condition_test_memory_one("= 18446744073709547520", false);
test_condition_test_memory_one(">= 18446744073709547520", false);
test_condition_test_memory_one("< 18446744073709547520", true);
test_condition_test_memory_one("!= 18446744073709547520", true);
test_condition_test_memory_one("<= 18446744073709547520", true);
test_condition_test_memory_one("> 100T", false);
test_condition_test_memory_one("= 100T", false);
test_condition_test_memory_one(">= 100T", false);
test_condition_test_memory_one("< 100T", true);
test_condition_test_memory_one("!= 100T", true);
test_condition_test_memory_one("<= 100T", true);
test_condition_test_memory_one("> 100 T", false);
test_condition_test_memory_one("= 100 T", false);
test_condition_test_memory_one(">= 100 T", false);
test_condition_test_memory_one("< 100 T", true);
test_condition_test_memory_one("!= 100 T", true);
test_condition_test_memory_one("<= 100 T", true);
test_condition_test_memory_one("> 100 T 1 G", false);
test_condition_test_memory_one("= 100 T 1 G", false);
test_condition_test_memory_one(">= 100 T 1 G", false);
test_condition_test_memory_one("< 100 T 1 G", true);
test_condition_test_memory_one("!= 100 T 1 G", true);
test_condition_test_memory_one("<= 100 T 1 G", true);
ASSERT_OK(asprintf(&t, "= %" PRIu64, memory));
test_condition_test_memory_one(t, true);
t = mfree(t);
ASSERT_OK(asprintf(&t, "<= %" PRIu64, memory));
test_condition_test_memory_one(t, true);
t = mfree(t);
ASSERT_OK(asprintf(&t, ">= %" PRIu64, memory));
test_condition_test_memory_one(t, true);
t = mfree(t);
ASSERT_OK(asprintf(&t, "!= %" PRIu64, memory));
test_condition_test_memory_one(t, false);
t = mfree(t);
ASSERT_OK(asprintf(&t, "< %" PRIu64, memory));
test_condition_test_memory_one(t, false);
t = mfree(t);
ASSERT_OK(asprintf(&t, "> %" PRIu64, memory));
test_condition_test_memory_one(t, false);
t = mfree(t);
}
static void test_condition_test_environment_one(const char *s, bool result) {
Condition *condition;
log_debug("%s=%s", condition_type_to_string(CONDITION_ENVIRONMENT), s);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_ENVIRONMENT, s, false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), result);
condition_free(condition);
}
TEST(condition_test_environment) {
ASSERT_OK_ERRNO(setenv("EXISTINGENVVAR", "foo", false));
test_condition_test_environment_one("MISSINGENVVAR", false);
test_condition_test_environment_one("MISSINGENVVAR=foo", false);
test_condition_test_environment_one("MISSINGENVVAR=", false);
test_condition_test_environment_one("EXISTINGENVVAR", true);
test_condition_test_environment_one("EXISTINGENVVAR=foo", true);
test_condition_test_environment_one("EXISTINGENVVAR=bar", false);
test_condition_test_environment_one("EXISTINGENVVAR=", false);
}
TEST(condition_test_os_release) {
_cleanup_strv_free_ char **os_release_pairs = NULL;
_cleanup_free_ char *version_id = NULL;
const char *key_value_pair;
Condition *condition;
/* Should not happen, but it's a test so we don't know the environment. */
if (load_os_release_pairs(NULL, &os_release_pairs) < 0)
return;
if (strv_length(os_release_pairs) < 2)
return;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "_THISHOPEFULLYWONTEXIST=01234 56789", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG FORMAT", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG!<>=FORMAT", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG FORMAT=", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG =FORMAT", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONG = FORMAT", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRONGFORMAT= ", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "WRO NG=FORMAT", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* Test shell style globs */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "ID_LIKE$=*THISHOPEFULLYWONTEXIST*", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "ID_THISHOPEFULLYWONTEXIST$=*rhel*", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "ID_LIKE!$=*THISHOPEFULLYWONTEXIST*", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, "ID_THISHOPEFULLYWONTEXIST!$=*rhel*", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* load_os_release_pairs() removes quotes, we have to add them back,
* otherwise we get a string: "PRETTY_NAME=Debian GNU/Linux 10 (buster)"
* which is wrong, as the value is not quoted anymore. */
const char *quote = strchr(os_release_pairs[1], ' ') ? "\"" : "";
key_value_pair = strjoina(os_release_pairs[0], "=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina(os_release_pairs[0], "!=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Test fnmatch() operators */
key_value_pair = strjoina(os_release_pairs[0], "$=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina(os_release_pairs[0], "!$=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Some distros (eg: Arch) do not set VERSION_ID */
if (parse_os_release(NULL, "VERSION_ID", &version_id) <= 0)
return;
key_value_pair = strjoina("VERSION_ID", "=", version_id);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", "!=", version_id);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", "<=", version_id);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", ">=", version_id);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", "<", version_id, ".1");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", ">", version_id, ".1");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", "=", version_id, " ", os_release_pairs[0], "=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", "!=", version_id, " ", os_release_pairs[0], "=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", "=", version_id, " ", os_release_pairs[0], "!=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", "!=", version_id, " ", os_release_pairs[0], "!=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
key_value_pair = strjoina("VERSION_ID", "<", version_id, ".1", " ", os_release_pairs[0], "=", quote, os_release_pairs[1], quote);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_OS_RELEASE, key_value_pair, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_machine_tag) {
Condition *condition;
/* etc_machine_info() caches the path on first use, so redirect it before anything reads it and
* rewrite the same file (truncating) for each scenario rather than switching paths. */
_cleanup_free_ char *saved = NULL;
ASSERT_OK(free_and_strdup(&saved, getenv("SYSTEMD_ETC_MACHINE_INFO")));
_cleanup_(rm_rf_physical_and_freep) char *d = NULL;
ASSERT_OK(mkdtemp_malloc(NULL, &d));
_cleanup_free_ char *f = path_join(d, "machine-info");
ASSERT_NOT_NULL(f);
ASSERT_OK_ERRNO(setenv("SYSTEMD_ETC_MACHINE_INFO", f, /* overwrite= */ true));
ASSERT_OK(write_string_file(f, "TAGS=\"webserver:frontend:berlin\"\n",
WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_TRUNCATE));
/* Exact match */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "webserver", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* Glob match */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "front*", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* No match */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "database", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Negation matches when the tag is absent, ... */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "database", /* trigger= */ false, /* negate= */ true)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* ... and does not match when the tag is present */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "webserver", /* trigger= */ false, /* negate= */ true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Invalid tags in the file are ignored (matching the Tags D-Bus property) */
ASSERT_OK(write_string_file(f, "TAGS=\"in valid:good\"\n",
WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_TRUNCATE));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "in valid", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "good", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* No tags configured at all → never matches */
ASSERT_OK(write_string_file(f, "PRETTY_HOSTNAME=\"x\"\n",
WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_TRUNCATE));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "webserver", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Key/value (parameterized) tags */
ASSERT_OK(write_string_file(f, "TAGS=\"role=webserver:env=prod:berlin\"\n",
WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_TRUNCATE));
/* Exact match of a key/value tag */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "role=webserver", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* Glob on the value */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "role=web*", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* Glob on the key */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "*=prod", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* A bare key does not match an assignment (the "=" is part of the tag) */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "role", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Right key, wrong value → no match */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "role=database", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* A plain (non-parameterized) tag still matches alongside key/value tags */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "berlin", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* Negation against a key/value tag */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "role=database", /* trigger= */ false, /* negate= */ true)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "role=webserver", /* trigger= */ false, /* negate= */ true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Conflicting values for the same key: graceful parsing keeps the first (lexicographically smallest)
* value and drops the rest, so only "env=prod" remains visible. */
ASSERT_OK(write_string_file(f, "TAGS=\"env=staging:env=prod\"\n",
WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_TRUNCATE));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "env=prod", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "env=staging", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Invalid key/value tags in the file are ignored, valid ones still match */
ASSERT_OK(write_string_file(f, "TAGS=\"bad-=x:role=good\"\n",
WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_TRUNCATE));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "bad-=x", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MACHINE_TAG, "role=good", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_OK(set_unset_env("SYSTEMD_ETC_MACHINE_INFO", saved, /* overwrite= */ true));
}
TEST(condition_test_psi) {
Condition *condition;
CGroupMask mask;
if (!is_pressure_supported())
return (void) log_notice("Pressure Stall Information (PSI) is not supported, skipping %s", __func__);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "sbarabau", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "10%sbarabau", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "10% sbarabau", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "-10", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "10%/10min", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "10min/10%", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "10% 5min", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "/5min", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_IO_PRESSURE, "10s / ", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "100%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "0%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "0.0%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "100%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "0%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "0.0%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "0.01%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "0.0%/10sec", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "100.0% / 1min", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_IO_PRESSURE, "50.0% / 1min", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
if (cg_is_available() <= 0)
return (void) log_tests_skipped("cgroupfs v2 is not mounted");
if (cg_mask_supported(&mask) < 0)
return (void) log_notice("Failed to get supported cgroup controllers, skipping %s", __func__);
if (!FLAGS_SET(mask, CGROUP_MASK_MEMORY))
return (void) log_notice("Requires the cgroup memory controller, skipping %s", __func__);
if (!FLAGS_SET(mask, CGROUP_MASK_CPU))
return (void) log_notice("Requires the cgroup CPU controller, skipping %s", __func__);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, " : / ", false, false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "hopefullythisisnotarealone.slice:100% / 10sec", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_PRESSURE, "-.slice:100.0% / 1min", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "-.slice:0.0%/5min", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_MEMORY_PRESSURE, "-.slice:100.0%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_IO_PRESSURE, "-.slice:0.0%", false, false)));
ASSERT_OK(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_kernel_module_loaded) {
Condition *condition;
int r;
condition = ASSERT_NOT_NULL(condition_new(CONDITION_KERNEL_MODULE_LOADED, "", /* trigger= */ false, /* negate= */ false));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
condition = ASSERT_NOT_NULL(condition_new(CONDITION_KERNEL_MODULE_LOADED, "..", /* trigger= */ false, /* negate= */ false));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
if (access("/sys/module/", F_OK) < 0)
return (void) log_tests_skipped("/sys/module not available, skipping.");
FOREACH_STRING(m, "random", "vfat", "fat", "cec", "binfmt_misc", "binfmt-misc") {
condition = ASSERT_NOT_NULL(condition_new(CONDITION_KERNEL_MODULE_LOADED, m, /* trigger= */ false, /* negate= */ false));
r = condition_test(condition, environ);
ASSERT_OK(r);
condition_free(condition);
log_notice("kmod %s is loaded: %s", m, yes_no(r));
}
condition = ASSERT_NOT_NULL(condition_new(CONDITION_KERNEL_MODULE_LOADED, "idefinitelydontexist", /* trigger= */ false, /* negate= */ false));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
}
DEFINE_TEST_MAIN(LOG_DEBUG);