HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/test/test-condition.c

87,384 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);