HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/test/test-condition.c
Git blob: 59b96976d046d2018630dc4459f9c568aefcade2
Lines 1–1000 of 1,819
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <gnu/libc-version.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/utsname.h>
#include <unistd.h>
#include "sd-id128.h"
#include "alloc-util.h"
#include "apparmor-util.h"
#include "architecture.h"
#include "battery-util.h"
#include "cgroup-util.h"
#include "condition.h"
#include "confidential-virt.h"
#include "cpu-set-util.h"
#include "efivars.h"
#include "env-util.h"
#include "errno-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "hostname-setup.h"
#include "id128-util.h"
#include "ima-util.h"
#include "libaudit-util.h"
#include "limits-util.h"
#include "log.h"
#include "nulstr-util.h"
#include "os-util.h"
#include "path-util.h"
#include "psi-util.h"
#include "rm-rf.h"
#include "selinux-util.h"
#include "smack-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"
#include "tmpfile-util.h"
#include "tomoyo-util.h"
#include "uid-classification.h"
#include "user-util.h"
#include "virt.h"
TEST(condition_test_list) {
Condition *condition, *sibling;
Architecture arch, other_arch;
ASSERT_OK(arch = uname_architecture());
ASSERT_OK_POSITIVE(condition_test_list(NULL, environ, NULL, NULL, NULL));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", false, false)));
ASSERT_ERROR(condition_test_list(condition, environ, NULL, NULL, NULL), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", true, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_ARCHITECTURE, architecture_to_string(arch), true, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_OK_POSITIVE(condition_test_list(condition, environ, NULL, NULL, NULL));
condition_free_list(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_ARCHITECTURE, architecture_to_string(arch), true, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", true, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_OK_POSITIVE(condition_test_list(condition, environ, NULL, NULL, NULL));
condition_free_list(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", true, false)));
ASSERT_ERROR(condition_test_list(condition, environ, NULL, NULL, NULL), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", true, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_OK_ZERO(condition_test_list(condition, environ, NULL, NULL, NULL));
condition_free_list(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", true, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_PATH_EXISTS, "/bin/sh", false, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_ERROR(condition_test_list(condition, environ, NULL, NULL, NULL), EINVAL);
condition_free_list(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", false, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_OK_ZERO(condition_test_list(condition, environ, NULL, NULL, NULL));
condition_free_list(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", false, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_OK_ZERO(condition_test_list(condition, environ, NULL, NULL, NULL));
condition_free_list(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/bin/sh", false, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_ARCHITECTURE, architecture_to_string(arch), false, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_OK_POSITIVE(condition_test_list(condition, environ, NULL, NULL, NULL));
condition_free_list(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", false, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_ARCHITECTURE, architecture_to_string(arch), true, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_ERROR(condition_test_list(condition, environ, NULL, NULL, NULL), EINVAL);
condition_free_list(condition);
other_arch = arch == ARCHITECTURE_X86_64 ? ARCHITECTURE_X86 : ARCHITECTURE_X86_64;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", false, false)));
ASSERT_NOT_NULL((sibling = condition_new(CONDITION_ARCHITECTURE, architecture_to_string(other_arch), true, false)));
LIST_APPEND(conditions, condition, sibling);
ASSERT_OK_ZERO(condition_test_list(condition, environ, NULL, NULL, NULL));
condition_free_list(condition);
}
TEST(condition_test_path) {
Condition *condition;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/bin/sh", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/bin/s?", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, true)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_DIRECTORY, "/bin", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_DIRECTORY_NOT_EMPTY, "/bin", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FILE_NOT_EMPTY, "/bin/sh", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/bin/sh", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/etc/passwd", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/proc", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/bin", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_READ_WRITE, "/tmp", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_ENCRYPTED, "/sys", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
if (access("/run/dbus/system_bus_socket", F_OK) >= 0) {
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_SOCKET, "/run/dbus/system_bus_socket", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
}
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_SOCKET, "/sys", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_PATH_IS_SYMBOLIC_LINK, "/dev/stdout", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_control_group_hierarchy) {
Condition *condition;
ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "v1", false, false));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL(condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "v2", false, false));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_control_group_controller) {
Condition *condition;
CGroupMask system_mask;
_cleanup_free_ char *controller_name = NULL;
if (cg_is_available() <= 0)
return (void) log_tests_skipped("cgroupfs v2 is not mounted");
/* Invalid controllers are ignored */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "thisisnotarealcontroller", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, "thisisnotarealcontroller", false, true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_OK(cg_mask_supported(&system_mask));
/* Individual valid controllers one by one */
for (CGroupController controller = 0; controller < _CGROUP_CONTROLLER_MAX; controller++) {
const char *local_controller_name = cgroup_controller_to_string(controller);
log_info("chosen controller is '%s'", local_controller_name);
if (system_mask & CGROUP_CONTROLLER_TO_MASK(controller)) {
log_info("this controller is available");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
} else {
log_info("this controller is unavailable");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, local_controller_name, false, true)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
}
}
/* Multiple valid controllers at the same time */
ASSERT_OK(cg_mask_to_string(system_mask, &controller_name));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, strempty(controller_name), false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CONTROL_GROUP_CONTROLLER, strempty(controller_name), false, true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_ac_power) {
Condition *condition;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_AC_POWER, "true", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), on_ac_power());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_AC_POWER, "false", false, false)));
ASSERT_OK_NE(condition_test(condition, environ), on_ac_power());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_AC_POWER, "false", false, true)));
ASSERT_OK_EQ(condition_test(condition, environ), on_ac_power());
condition_free(condition);
}
TEST(condition_test_host) {
_cleanup_free_ char *hostname = NULL;
Condition *condition;
sd_id128_t id;
int r;
r = sd_id128_get_machine(&id);
if (ERRNO_IS_NEG_MACHINE_ID_UNSET(r))
return (void) log_tests_skipped("/etc/machine-id missing");
ASSERT_OK(r);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_HOST, SD_ID128_TO_STRING(id), false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_HOST, "garbage value jjjjjjjjjjjjjj", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_HOST, SD_ID128_TO_STRING(id), false, true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((hostname = gethostname_malloc()));
/* if hostname looks like an id128 then skip testing it */
if (id128_is_valid(hostname))
return (void) log_notice("hostname is an id128, skipping test");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_HOST, hostname, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_fraction) {
Condition *condition;
int r;
/* The 0%/100% boundaries are deterministic and short-circuit before the machine ID is even
* read, so these run everywhere. */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FRACTION, "0%", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FRACTION, "100%", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* A tag does not change the boundary behaviour. */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FRACTION, "sometag 0%", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FRACTION, "sometag 100%", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* Negation flips the boundaries. */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FRACTION, "100%", /* trigger= */ false, /* negate= */ true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FRACTION, "0%", /* trigger= */ false, /* negate= */ true)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* Malformed values must propagate an error rather than silently passing or failing. */
FOREACH_STRING(bad,
"", /* empty */
"abc", /* not a number */
"30", /* missing percent sign */
"30 %", /* percent token is just '%' */
"150%", /* out of range */
"tag 30% extra", /* trailing garbage */
"a b 30%") { /* unquoted multi-word tag → trailing garbage */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FRACTION, bad, /* trigger= */ false, /* negate= */ false)));
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
}
sd_id128_t id;
r = sd_id128_get_machine(&id);
if (ERRNO_IS_NEG_MACHINE_ID_UNSET(r))
return (void) log_tests_skipped("/etc/machine-id missing");
ASSERT_OK(r);
/* Distribution check: for a fixed machine ID, varying the tag spreads results uniformly, so
* about PERCENT of the tags match. This is the statistical dual of the production scenario,
* where the tag is fixed and the machine ID varies across a fleet, and it also pins down the
* direction of the comparison (a higher percentage matches more, not fewer). The result is
* deterministic for a given machine ID, and the slack is many standard deviations wide, so
* this does not flake. */
static const unsigned percentages[] = { 1, 20, 50, 80 };
FOREACH_ELEMENT(pct, percentages) {
const unsigned n = 10000, slack = 3 * n / 100; /* ±3 percentage points */
unsigned match = 0;
for (unsigned i = 0; i < n; i++) {
char param[64];
xsprintf(param, "tag-%u %u%%", i, *pct);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FRACTION, param, /* trigger= */ false, /* negate= */ false)));
r = ASSERT_OK(condition_test(condition, environ));
match += r > 0;
condition_free(condition);
}
unsigned expected = *pct * n / 100;
ASSERT_TRUE(match + slack >= expected);
ASSERT_TRUE(expected + slack >= match);
}
}
TEST(condition_test_architecture) {
Condition *condition;
const char *sa;
Architecture a;
ASSERT_OK(a = uname_architecture());
ASSERT_NOT_NULL((sa = architecture_to_string(a)));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_ARCHITECTURE, sa, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_ARCHITECTURE, "garbage value", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_ARCHITECTURE, sa, false, true)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_firmware) {
Condition *condition;
/* Empty parameter */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* uefi parameter */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "uefi", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), is_efi_boot());
condition_free(condition);
}
TEST(condition_test_firmware_device_tree) {
Condition *condition;
bool is_device_tree_system;
/* device-tree parameter */
is_device_tree_system = access("/sys/firmware/devicetree/", F_OK) == 0;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "device-tree", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), is_device_tree_system);
condition_free(condition);
/* device-tree-compatible parameter */
if (!is_device_tree_system) {
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "device-tree-compatible()", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
} else {
_cleanup_free_ char *dtcompat = NULL;
_cleanup_strv_free_ char **dtcompatlist = NULL;
size_t dtcompat_size;
int r;
r = read_full_virtual_file("/proc/device-tree/compatible", &dtcompat, &dtcompat_size);
if (r < 0) {
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "device-tree-compatible()", false, false)));
if (r == -ENOENT)
ASSERT_OK_ZERO(condition_test(condition, environ));
else
ASSERT_FAIL(condition_test(condition, environ));
condition_free(condition);
return;
}
dtcompatlist = strv_parse_nulstr(dtcompat, dtcompat_size);
STRV_FOREACH(c, dtcompatlist) {
_cleanup_free_ char *expression = NULL;
ASSERT_NOT_NULL((expression = strjoin("device-tree-compatible(", *c, ")")));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
}
}
}
TEST(condition_test_firmware_smbios) {
Condition *condition;
_cleanup_free_ char *bios_vendor = NULL, *bios_version = NULL;
const char *expression;
/* smbios-field parameter */
/* Test some malformed smbios-field arguments */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field()", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed)", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed=)", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(malformed=)", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(not_existing=nothing garbage)", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
/* Test not existing SMBIOS field */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, "smbios-field(not_existing=nothing)", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Test with bios_vendor, if available */
if (read_virtual_file("/sys/class/dmi/id/bios_vendor", SIZE_MAX, &bios_vendor, NULL) <= 0)
return;
/* remove trailing newline */
strstrip(bios_vendor);
/* Check if the bios_vendor contains any spaces we should quote */
const char *quote = strchr(bios_vendor, ' ') ? "\"" : "";
/* Test equality / inequality using fnmatch() */
expression = strjoina("smbios-field(bios_vendor $= ", quote, bios_vendor, quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_vendor$=", quote, bios_vendor, quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_vendor !$= ", quote, bios_vendor, quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_vendor!$=", quote, bios_vendor, quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_vendor $= ", quote, bios_vendor, "*", quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* Test version comparison with bios_version, if available */
if (read_virtual_file("/sys/class/dmi/id/bios_version", SIZE_MAX, &bios_version, NULL) <= 0)
return;
/* remove trailing newline */
strstrip(bios_version);
/* Check if the bios_version contains any spaces we should quote */
quote = strchr(bios_version, ' ') ? "\"" : "";
expression = strjoina("smbios-field(bios_version = ", quote, bios_version, quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_version != ", quote, bios_version, quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_version <= ", quote, bios_version, quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_version >= ", quote, bios_version, quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_version < ", quote, bios_version, ".1", quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
expression = strjoina("smbios-field(bios_version > ", quote, bios_version, ".1", quote, ")");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_FIRMWARE, expression, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_kernel_command_line) {
Condition *condition;
int r;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "thisreallyshouldntbeonthekernelcommandline", false, false)));
r = condition_test(condition, environ);
if (ERRNO_IS_PRIVILEGE(r))
return;
ASSERT_OK_ZERO(r);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "andthis=neither", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_kernel_version) {
Condition *condition;
struct utsname u;
const char *v;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "*thisreallyshouldntbeinthekernelversion*", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "*", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* An artificially empty condition. It evaluates to true, but normally
* such condition cannot be created, because the condition list is reset instead. */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_OK_ERRNO(uname(&u));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, u.release, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
strshorten(u.release, 4);
strcpy(strchr(u.release, 0), "*");
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, u.release, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* 0.1.2 would be a very very very old kernel */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "> 0.1.2", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, ">0.1.2", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "'>0.1.2' '<9.0.0'", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "> 0.1.2 < 9.0.0", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, ">", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, ">= 0.1.2", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "< 0.1.2", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "<= 0.1.2", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "= 0.1.2", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* 4711.8.15 is a very very very future kernel */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "< 4711.8.15", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "<= 4711.8.15", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "= 4711.8.15", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "> 4711.8.15", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, " >= 4711.8.15", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_OK_ERRNO(uname(&u));
v = strjoina(">=", u.release);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
v = strjoina("= ", u.release);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
v = strjoina("<=", u.release);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
v = strjoina("> ", u.release);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
v = strjoina("< ", u.release);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_version) {
Condition *condition;
const char *v;
char ver[8];
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd *thisreallyshouldntbeinthesystemdversion*", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd *", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* An artificially empty condition. It evaluates to true, but normally
* such condition cannot be created, because the condition list is reset instead. */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
/* 42 would be a very very very old systemd release */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd > 42", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd>42", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd '>42' '<9000'", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd > 42 < 9000", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd>", false, false)));
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd >= 42", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd < 42", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd <= 42", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd = 42", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* 9000 is a very very very future systemd release */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd < 9000", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd <= 9000", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd = 9000", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd > 9000", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "systemd >= 9000", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
xsprintf(ver, "%d", PROJECT_VERSION);
v = strjoina("systemd>=", ver);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
v = strjoina("systemd = ", ver);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
v = strjoina("systemd<=", ver);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
v = strjoina("systemd > ", ver);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
v = strjoina("systemd < ", ver);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* Test glibc version */
bool has = !isempty(gnu_get_libc_version());
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "glibc > 1", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), has);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "glibc < 2", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), !has);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "glibc < 9999", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "glibc > 9999", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
v = strjoina("glibc = ", gnu_get_libc_version());
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
if (has)
ASSERT_OK_POSITIVE(condition_test(condition, environ));
else
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
v = strjoina("glibc != ", gnu_get_libc_version());
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, v, false, false)));
if (has)
ASSERT_OK_ZERO(condition_test(condition, environ));
else
ASSERT_ERROR(condition_test(condition, environ), EINVAL);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "glibc $= ?*", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), has);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_VERSION, "glibc !$= ?*", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), !has);
condition_free(condition);
}
TEST(condition_test_credential) {
_cleanup_(rm_rf_physical_and_freep) char *n1 = NULL, *n2 = NULL;
_cleanup_free_ char *d1 = NULL, *d2 = NULL, *j = NULL;
Condition *condition;
ASSERT_OK(free_and_strdup(&d1, getenv("CREDENTIALS_DIRECTORY")));
ASSERT_OK(free_and_strdup(&d2, getenv("ENCRYPTED_CREDENTIALS_DIRECTORY")));
ASSERT_OK_ERRNO(unsetenv("CREDENTIALS_DIRECTORY"));
ASSERT_OK_ERRNO(unsetenv("ENCRYPTED_CREDENTIALS_DIRECTORY"));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "definitelymissing", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
/* invalid */
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "..", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_OK(mkdtemp_malloc(NULL, &n1));
ASSERT_OK(mkdtemp_malloc(NULL, &n2));
ASSERT_OK_ERRNO(setenv("CREDENTIALS_DIRECTORY", n1, /* overwrite= */ true));
ASSERT_OK_ERRNO(setenv("ENCRYPTED_CREDENTIALS_DIRECTORY", n2, /* overwrite= */ true));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "stillmissing", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((j = path_join(n1, "existing")));
ASSERT_OK(touch(j));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "existing", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
free(j);
ASSERT_NOT_NULL((j = path_join(n2, "existing-encrypted")));
ASSERT_OK(touch(j));
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CREDENTIAL, "existing-encrypted", /* trigger= */ false, /* negate= */ false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_OK(set_unset_env("CREDENTIALS_DIRECTORY", d1, /* overwrite= */ true));
ASSERT_OK(set_unset_env("ENCRYPTED_CREDENTIALS_DIRECTORY", d2, /* overwrite= */ true));
}
TEST(condition_test_cpufeature) {
Condition *condition;
switch (uname_architecture()) {
case ARCHITECTURE_X86:
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "fpu", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "x86.fpu", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "bogus.fpu", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
break;
case ARCHITECTURE_X86_64:
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "fpu", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "x86-64.fpu", false, false)));
ASSERT_OK_POSITIVE(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "bogus.fpu", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
break;
case ARCHITECTURE_ARM64: {
int expected = native_architecture() == ARCHITECTURE_ARM64;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "fp", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), expected);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "asimd", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), expected);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "arm64.asimd", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), expected);
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "bogus.asimd", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
break;
}
default:
;
}
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "bogus.featurethatshouldnotexist", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "somecpufeaturethatreallydoesntmakesense", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_CPU_FEATURE, "a", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
}
TEST(condition_test_security) {
Condition *condition;
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "garbage oifdsjfoidsjoj", false, false)));
ASSERT_OK_ZERO(condition_test(condition, environ));
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "selinux", false, true)));
ASSERT_OK_NE(condition_test(condition, environ), mac_selinux_use());
condition_free(condition);
ASSERT_NOT_NULL((condition = condition_new(CONDITION_SECURITY, "apparmor", false, false)));
ASSERT_OK_EQ(condition_test(condition, environ), mac_apparmor_use());