diff options
Diffstat (limited to 'tools/testing/selftests/kdbus')
27 files changed, 0 insertions, 10506 deletions
diff --git a/tools/testing/selftests/kdbus/.gitignore b/tools/testing/selftests/kdbus/.gitignore deleted file mode 100644 index d3ef42f6a..000000000 --- a/tools/testing/selftests/kdbus/.gitignore +++ /dev/null @@ -1 +0,0 @@ -kdbus-test diff --git a/tools/testing/selftests/kdbus/Makefile b/tools/testing/selftests/kdbus/Makefile deleted file mode 100644 index 8f36cb566..000000000 --- a/tools/testing/selftests/kdbus/Makefile +++ /dev/null @@ -1,49 +0,0 @@ -CFLAGS += -I../../../../usr/include/ -CFLAGS += -I../../../../samples/kdbus/ -CFLAGS += -I../../../../include/uapi/ -CFLAGS += -std=gnu99 -CFLAGS += -DKBUILD_MODNAME=\"kdbus\" -D_GNU_SOURCE -LDLIBS = -pthread -lcap -lm - -OBJS= \ - kdbus-enum.o \ - kdbus-util.o \ - kdbus-test.o \ - kdbus-test.o \ - test-activator.o \ - test-benchmark.o \ - test-bus.o \ - test-chat.o \ - test-connection.o \ - test-daemon.o \ - test-endpoint.o \ - test-fd.o \ - test-free.o \ - test-match.o \ - test-message.o \ - test-metadata-ns.o \ - test-monitor.o \ - test-names.o \ - test-policy.o \ - test-policy-ns.o \ - test-policy-priv.o \ - test-sync.o \ - test-timeout.o - -all: kdbus-test - -include ../lib.mk - -%.o: %.c kdbus-enum.h kdbus-test.h kdbus-util.h - $(CC) $(CFLAGS) -c $< -o $@ - -kdbus-test: $(OBJS) - $(CC) $(CFLAGS) $^ $(LDLIBS) -o $@ - -TEST_PROGS := kdbus-test - -run_tests: - ./kdbus-test --tap - -clean: - rm -f *.o kdbus-test diff --git a/tools/testing/selftests/kdbus/kdbus-enum.c b/tools/testing/selftests/kdbus/kdbus-enum.c deleted file mode 100644 index 4f1e57978..000000000 --- a/tools/testing/selftests/kdbus/kdbus-enum.c +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (C) 2013-2015 Kay Sievers - * - * kdbus is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation; either version 2.1 of the License, or (at - * your option) any later version. - */ - -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> - -#include "kdbus-util.h" -#include "kdbus-enum.h" - -struct kdbus_enum_table { - long long id; - const char *name; -}; - -#define TABLE(what) static struct kdbus_enum_table kdbus_table_##what[] -#define ENUM(_id) { .id = _id, .name = STRINGIFY(_id) } -#define LOOKUP(what) \ - const char *enum_##what(long long id) \ - { \ - for (size_t i = 0; i < ELEMENTSOF(kdbus_table_##what); i++) \ - if (id == kdbus_table_##what[i].id) \ - return kdbus_table_##what[i].name; \ - return "UNKNOWN"; \ - } - -TABLE(CMD) = { - ENUM(KDBUS_CMD_BUS_MAKE), - ENUM(KDBUS_CMD_ENDPOINT_MAKE), - ENUM(KDBUS_CMD_HELLO), - ENUM(KDBUS_CMD_SEND), - ENUM(KDBUS_CMD_RECV), - ENUM(KDBUS_CMD_LIST), - ENUM(KDBUS_CMD_NAME_RELEASE), - ENUM(KDBUS_CMD_CONN_INFO), - ENUM(KDBUS_CMD_MATCH_ADD), - ENUM(KDBUS_CMD_MATCH_REMOVE), -}; -LOOKUP(CMD); - -TABLE(MSG) = { - ENUM(_KDBUS_ITEM_NULL), - ENUM(KDBUS_ITEM_PAYLOAD_VEC), - ENUM(KDBUS_ITEM_PAYLOAD_OFF), - ENUM(KDBUS_ITEM_PAYLOAD_MEMFD), - ENUM(KDBUS_ITEM_FDS), - ENUM(KDBUS_ITEM_BLOOM_PARAMETER), - ENUM(KDBUS_ITEM_BLOOM_FILTER), - ENUM(KDBUS_ITEM_DST_NAME), - ENUM(KDBUS_ITEM_MAKE_NAME), - ENUM(KDBUS_ITEM_ATTACH_FLAGS_SEND), - ENUM(KDBUS_ITEM_ATTACH_FLAGS_RECV), - ENUM(KDBUS_ITEM_ID), - ENUM(KDBUS_ITEM_NAME), - ENUM(KDBUS_ITEM_TIMESTAMP), - ENUM(KDBUS_ITEM_CREDS), - ENUM(KDBUS_ITEM_PIDS), - ENUM(KDBUS_ITEM_AUXGROUPS), - ENUM(KDBUS_ITEM_OWNED_NAME), - ENUM(KDBUS_ITEM_TID_COMM), - ENUM(KDBUS_ITEM_PID_COMM), - ENUM(KDBUS_ITEM_EXE), - ENUM(KDBUS_ITEM_CMDLINE), - ENUM(KDBUS_ITEM_CGROUP), - ENUM(KDBUS_ITEM_CAPS), - ENUM(KDBUS_ITEM_SECLABEL), - ENUM(KDBUS_ITEM_AUDIT), - ENUM(KDBUS_ITEM_CONN_DESCRIPTION), - ENUM(KDBUS_ITEM_NAME_ADD), - ENUM(KDBUS_ITEM_NAME_REMOVE), - ENUM(KDBUS_ITEM_NAME_CHANGE), - ENUM(KDBUS_ITEM_ID_ADD), - ENUM(KDBUS_ITEM_ID_REMOVE), - ENUM(KDBUS_ITEM_REPLY_TIMEOUT), - ENUM(KDBUS_ITEM_REPLY_DEAD), -}; -LOOKUP(MSG); - -TABLE(PAYLOAD) = { - ENUM(KDBUS_PAYLOAD_KERNEL), - ENUM(KDBUS_PAYLOAD_DBUS), -}; -LOOKUP(PAYLOAD); diff --git a/tools/testing/selftests/kdbus/kdbus-enum.h b/tools/testing/selftests/kdbus/kdbus-enum.h deleted file mode 100644 index ed28cca26..000000000 --- a/tools/testing/selftests/kdbus/kdbus-enum.h +++ /dev/null @@ -1,15 +0,0 @@ -/* - * Copyright (C) 2013-2015 Kay Sievers - * - * kdbus is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation; either version 2.1 of the License, or (at - * your option) any later version. - */ - -#pragma once - -const char *enum_CMD(long long id); -const char *enum_MSG(long long id); -const char *enum_MATCH(long long id); -const char *enum_PAYLOAD(long long id); diff --git a/tools/testing/selftests/kdbus/kdbus-test.c b/tools/testing/selftests/kdbus/kdbus-test.c deleted file mode 100644 index db5738157..000000000 --- a/tools/testing/selftests/kdbus/kdbus-test.c +++ /dev/null @@ -1,905 +0,0 @@ -#include <errno.h> -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <time.h> -#include <unistd.h> -#include <stdint.h> -#include <assert.h> -#include <getopt.h> -#include <stdbool.h> -#include <signal.h> -#include <sys/mount.h> -#include <sys/prctl.h> -#include <sys/wait.h> -#include <sys/syscall.h> -#include <sys/eventfd.h> -#include <linux/sched.h> - -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -enum { - TEST_CREATE_BUS = 1 << 0, - TEST_CREATE_CONN = 1 << 1, -}; - -struct kdbus_test { - const char *name; - const char *desc; - int (*func)(struct kdbus_test_env *env); - unsigned int flags; -}; - -struct kdbus_test_args { - bool mntns; - bool pidns; - bool userns; - char *uid_map; - char *gid_map; - int loop; - int wait; - int fork; - int tap_output; - char *module; - char *root; - char *test; - char *busname; -}; - -static const struct kdbus_test tests[] = { - { - .name = "bus-make", - .desc = "bus make functions", - .func = kdbus_test_bus_make, - .flags = 0, - }, - { - .name = "hello", - .desc = "the HELLO command", - .func = kdbus_test_hello, - .flags = TEST_CREATE_BUS, - }, - { - .name = "byebye", - .desc = "the BYEBYE command", - .func = kdbus_test_byebye, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "chat", - .desc = "a chat pattern", - .func = kdbus_test_chat, - .flags = TEST_CREATE_BUS, - }, - { - .name = "daemon", - .desc = "a simple daemon", - .func = kdbus_test_daemon, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "fd-passing", - .desc = "file descriptor passing", - .func = kdbus_test_fd_passing, - .flags = TEST_CREATE_BUS, - }, - { - .name = "endpoint", - .desc = "custom endpoint", - .func = kdbus_test_custom_endpoint, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "monitor", - .desc = "monitor functionality", - .func = kdbus_test_monitor, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "name-basics", - .desc = "basic name registry functions", - .func = kdbus_test_name_basic, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "name-conflict", - .desc = "name registry conflict details", - .func = kdbus_test_name_conflict, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "name-queue", - .desc = "queuing of names", - .func = kdbus_test_name_queue, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "name-takeover", - .desc = "takeover of names", - .func = kdbus_test_name_takeover, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "message-basic", - .desc = "basic message handling", - .func = kdbus_test_message_basic, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "message-prio", - .desc = "handling of messages with priority", - .func = kdbus_test_message_prio, - .flags = TEST_CREATE_BUS, - }, - { - .name = "message-quota", - .desc = "message quotas are enforced", - .func = kdbus_test_message_quota, - .flags = TEST_CREATE_BUS, - }, - { - .name = "memory-access", - .desc = "memory access", - .func = kdbus_test_memory_access, - .flags = TEST_CREATE_BUS, - }, - { - .name = "timeout", - .desc = "timeout", - .func = kdbus_test_timeout, - .flags = TEST_CREATE_BUS, - }, - { - .name = "sync-byebye", - .desc = "synchronous replies vs. BYEBYE", - .func = kdbus_test_sync_byebye, - .flags = TEST_CREATE_BUS, - }, - { - .name = "sync-reply", - .desc = "synchronous replies", - .func = kdbus_test_sync_reply, - .flags = TEST_CREATE_BUS, - }, - { - .name = "message-free", - .desc = "freeing of memory", - .func = kdbus_test_free, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "connection-info", - .desc = "retrieving connection information", - .func = kdbus_test_conn_info, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "connection-update", - .desc = "updating connection information", - .func = kdbus_test_conn_update, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "writable-pool", - .desc = "verifying pools are never writable", - .func = kdbus_test_writable_pool, - .flags = TEST_CREATE_BUS, - }, - { - .name = "policy", - .desc = "policy", - .func = kdbus_test_policy, - .flags = TEST_CREATE_BUS, - }, - { - .name = "policy-priv", - .desc = "unprivileged bus access", - .func = kdbus_test_policy_priv, - .flags = TEST_CREATE_BUS, - }, - { - .name = "policy-ns", - .desc = "policy in user namespaces", - .func = kdbus_test_policy_ns, - .flags = TEST_CREATE_BUS, - }, - { - .name = "metadata-ns", - .desc = "metadata in different namespaces", - .func = kdbus_test_metadata_ns, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "match-id-add", - .desc = "adding of matches by id", - .func = kdbus_test_match_id_add, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "match-id-remove", - .desc = "removing of matches by id", - .func = kdbus_test_match_id_remove, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "match-replace", - .desc = "replace of matches with the same cookie", - .func = kdbus_test_match_replace, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "match-name-add", - .desc = "adding of matches by name", - .func = kdbus_test_match_name_add, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "match-name-remove", - .desc = "removing of matches by name", - .func = kdbus_test_match_name_remove, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "match-name-change", - .desc = "matching for name changes", - .func = kdbus_test_match_name_change, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "match-bloom", - .desc = "matching with bloom filters", - .func = kdbus_test_match_bloom, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "activator", - .desc = "activator connections", - .func = kdbus_test_activator, - .flags = TEST_CREATE_BUS | TEST_CREATE_CONN, - }, - { - .name = "benchmark", - .desc = "benchmark", - .func = kdbus_test_benchmark, - .flags = TEST_CREATE_BUS, - }, - { - .name = "benchmark-nomemfds", - .desc = "benchmark without using memfds", - .func = kdbus_test_benchmark_nomemfds, - .flags = TEST_CREATE_BUS, - }, - { - .name = "benchmark-uds", - .desc = "benchmark comparison to UDS", - .func = kdbus_test_benchmark_uds, - .flags = TEST_CREATE_BUS, - }, -}; - -#define N_TESTS ((int) (sizeof(tests) / sizeof(tests[0]))) - -static int test_prepare_env(const struct kdbus_test *t, - const struct kdbus_test_args *args, - struct kdbus_test_env *env) -{ - if (t->flags & TEST_CREATE_BUS) { - char *s; - char *n = NULL; - int ret; - - asprintf(&s, "%s/control", args->root); - - env->control_fd = open(s, O_RDWR); - free(s); - ASSERT_RETURN(env->control_fd >= 0); - - if (!args->busname) { - n = unique_name("test-bus"); - ASSERT_RETURN(n); - } - - ret = kdbus_create_bus(env->control_fd, - args->busname ?: n, - _KDBUS_ATTACH_ALL, &s); - free(n); - ASSERT_RETURN(ret == 0); - - asprintf(&env->buspath, "%s/%s/bus", args->root, s); - free(s); - } - - if (t->flags & TEST_CREATE_CONN) { - env->conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(env->conn); - } - - env->root = args->root; - env->module = args->module; - - return 0; -} - -void test_unprepare_env(const struct kdbus_test *t, struct kdbus_test_env *env) -{ - if (env->conn) { - kdbus_conn_free(env->conn); - env->conn = NULL; - } - - if (env->control_fd >= 0) { - close(env->control_fd); - env->control_fd = -1; - } - - if (env->buspath) { - free(env->buspath); - env->buspath = NULL; - } -} - -static int test_run(const struct kdbus_test *t, - const struct kdbus_test_args *kdbus_args, - int wait) -{ - int ret; - struct kdbus_test_env env = {}; - - ret = test_prepare_env(t, kdbus_args, &env); - if (ret != TEST_OK) - return ret; - - if (wait > 0) { - printf("Sleeping %d seconds before running test ...\n", wait); - sleep(wait); - } - - ret = t->func(&env); - test_unprepare_env(t, &env); - return ret; -} - -static int test_run_forked(const struct kdbus_test *t, - const struct kdbus_test_args *kdbus_args, - int wait) -{ - int ret; - pid_t pid; - - pid = fork(); - if (pid < 0) { - return TEST_ERR; - } else if (pid == 0) { - ret = test_run(t, kdbus_args, wait); - _exit(ret); - } - - pid = waitpid(pid, &ret, 0); - if (pid <= 0) - return TEST_ERR; - else if (!WIFEXITED(ret)) - return TEST_ERR; - else - return WEXITSTATUS(ret); -} - -static void print_test_result(int ret) -{ - switch (ret) { - case TEST_OK: - printf("OK"); - break; - case TEST_SKIP: - printf("SKIPPED"); - break; - case TEST_ERR: - printf("ERROR"); - break; - } -} - -static int start_all_tests(struct kdbus_test_args *kdbus_args) -{ - int ret; - unsigned int fail_cnt = 0; - unsigned int skip_cnt = 0; - unsigned int ok_cnt = 0; - unsigned int i; - - if (kdbus_args->tap_output) { - printf("1..%d\n", N_TESTS); - fflush(stdout); - } - - kdbus_util_verbose = false; - - for (i = 0; i < N_TESTS; i++) { - const struct kdbus_test *t = tests + i; - - if (!kdbus_args->tap_output) { - unsigned int n; - - printf("Testing %s (%s) ", t->desc, t->name); - for (n = 0; n < 60 - strlen(t->desc) - strlen(t->name); n++) - printf("."); - printf(" "); - } - - ret = test_run_forked(t, kdbus_args, 0); - switch (ret) { - case TEST_OK: - ok_cnt++; - break; - case TEST_SKIP: - skip_cnt++; - break; - case TEST_ERR: - fail_cnt++; - break; - } - - if (kdbus_args->tap_output) { - printf("%sok %d - %s%s (%s)\n", - (ret == TEST_ERR) ? "not " : "", i + 1, - (ret == TEST_SKIP) ? "# SKIP " : "", - t->desc, t->name); - fflush(stdout); - } else { - print_test_result(ret); - printf("\n"); - } - } - - if (kdbus_args->tap_output) - printf("Failed %d/%d tests, %.2f%% okay\n", fail_cnt, N_TESTS, - 100.0 - (fail_cnt * 100.0) / ((float) N_TESTS)); - else - printf("\nSUMMARY: %u tests passed, %u skipped, %u failed\n", - ok_cnt, skip_cnt, fail_cnt); - - return fail_cnt > 0 ? TEST_ERR : TEST_OK; -} - -static int start_one_test(struct kdbus_test_args *kdbus_args) -{ - int i, ret; - bool test_found = false; - - for (i = 0; i < N_TESTS; i++) { - const struct kdbus_test *t = tests + i; - - if (strcmp(t->name, kdbus_args->test)) - continue; - - do { - test_found = true; - if (kdbus_args->fork) - ret = test_run_forked(t, kdbus_args, - kdbus_args->wait); - else - ret = test_run(t, kdbus_args, - kdbus_args->wait); - - printf("Testing %s: ", t->desc); - print_test_result(ret); - printf("\n"); - - if (ret != TEST_OK) - break; - } while (kdbus_args->loop); - - return ret; - } - - if (!test_found) { - printf("Unknown test-id '%s'\n", kdbus_args->test); - return TEST_ERR; - } - - return TEST_OK; -} - -static void usage(const char *argv0) -{ - unsigned int i, j; - - printf("Usage: %s [options]\n" - "Options:\n" - "\t-a, --tap Output test results in TAP format\n" - "\t-m, --module <module> Kdbus module name\n" - "\t-x, --loop Run in a loop\n" - "\t-f, --fork Fork before running a test\n" - "\t-h, --help Print this help\n" - "\t-r, --root <root> Toplevel of the kdbus hierarchy\n" - "\t-t, --test <test-id> Run one specific test only, in verbose mode\n" - "\t-b, --bus <busname> Instead of generating a random bus name, take <busname>.\n" - "\t-w, --wait <secs> Wait <secs> before actually starting test\n" - "\t --mntns New mount namespace\n" - "\t --pidns New PID namespace\n" - "\t --userns New user namespace\n" - "\t --uidmap uid_map UID map for user namespace\n" - "\t --gidmap gid_map GID map for user namespace\n" - "\n", argv0); - - printf("By default, all test are run once, and a summary is printed.\n" - "Available tests for --test:\n\n"); - - for (i = 0; i < N_TESTS; i++) { - const struct kdbus_test *t = tests + i; - - printf("\t%s", t->name); - - for (j = 0; j < 24 - strlen(t->name); j++) - printf(" "); - - printf("Test %s\n", t->desc); - } - - printf("\n"); - printf("Note that some tests may, if run specifically by --test, " - "behave differently, and not terminate by themselves.\n"); - - exit(EXIT_FAILURE); -} - -void print_kdbus_test_args(struct kdbus_test_args *args) -{ - if (args->userns || args->pidns || args->mntns) - printf("# Starting tests in new %s%s%s namespaces%s\n", - args->mntns ? "MOUNT " : "", - args->pidns ? "PID " : "", - args->userns ? "USER " : "", - args->mntns ? ", kdbusfs will be remounted" : ""); - else - printf("# Starting tests in the same namespaces\n"); -} - -void print_metadata_support(void) -{ - bool no_meta_audit, no_meta_cgroups, no_meta_seclabel; - - /* - * KDBUS_ATTACH_CGROUP, KDBUS_ATTACH_AUDIT and - * KDBUS_ATTACH_SECLABEL - */ - no_meta_audit = !config_auditsyscall_is_enabled(); - no_meta_cgroups = !config_cgroups_is_enabled(); - no_meta_seclabel = !config_security_is_enabled(); - - if (no_meta_audit | no_meta_cgroups | no_meta_seclabel) - printf("# Starting tests without %s%s%s metadata support\n", - no_meta_audit ? "AUDIT " : "", - no_meta_cgroups ? "CGROUP " : "", - no_meta_seclabel ? "SECLABEL " : ""); - else - printf("# Starting tests with full metadata support\n"); -} - -int run_tests(struct kdbus_test_args *kdbus_args) -{ - int ret; - static char control[4096]; - - snprintf(control, sizeof(control), "%s/control", kdbus_args->root); - - if (access(control, W_OK) < 0) { - printf("Unable to locate control node at '%s'.\n", - control); - return TEST_ERR; - } - - if (kdbus_args->test) { - ret = start_one_test(kdbus_args); - } else { - do { - ret = start_all_tests(kdbus_args); - if (ret != TEST_OK) - break; - } while (kdbus_args->loop); - } - - return ret; -} - -static void nop_handler(int sig) {} - -static int test_prepare_mounts(struct kdbus_test_args *kdbus_args) -{ - int ret; - char kdbusfs[64] = {'\0'}; - - snprintf(kdbusfs, sizeof(kdbusfs), "%sfs", kdbus_args->module); - - /* make current mount slave */ - ret = mount(NULL, "/", NULL, MS_SLAVE|MS_REC, NULL); - if (ret < 0) { - ret = -errno; - printf("error mount() root: %d (%m)\n", ret); - return ret; - } - - /* Remount procfs since we need it in our tests */ - if (kdbus_args->pidns) { - ret = mount("proc", "/proc", "proc", - MS_NOSUID|MS_NOEXEC|MS_NODEV, NULL); - if (ret < 0) { - ret = -errno; - printf("error mount() /proc : %d (%m)\n", ret); - return ret; - } - } - - /* Remount kdbusfs */ - ret = mount(kdbusfs, kdbus_args->root, kdbusfs, - MS_NOSUID|MS_NOEXEC|MS_NODEV, NULL); - if (ret < 0) { - ret = -errno; - printf("error mount() %s :%d (%m)\n", kdbusfs, ret); - return ret; - } - - return 0; -} - -int run_tests_in_namespaces(struct kdbus_test_args *kdbus_args) -{ - int ret; - int efd = -1; - int status; - pid_t pid, rpid; - struct sigaction oldsa; - struct sigaction sa = { - .sa_handler = nop_handler, - .sa_flags = SA_NOCLDSTOP, - }; - - efd = eventfd(0, EFD_CLOEXEC); - if (efd < 0) { - ret = -errno; - printf("eventfd() failed: %d (%m)\n", ret); - return TEST_ERR; - } - - ret = sigaction(SIGCHLD, &sa, &oldsa); - if (ret < 0) { - ret = -errno; - printf("sigaction() failed: %d (%m)\n", ret); - return TEST_ERR; - } - - /* setup namespaces */ - pid = syscall(__NR_clone, SIGCHLD| - (kdbus_args->userns ? CLONE_NEWUSER : 0) | - (kdbus_args->mntns ? CLONE_NEWNS : 0) | - (kdbus_args->pidns ? CLONE_NEWPID : 0), NULL); - if (pid < 0) { - printf("clone() failed: %d (%m)\n", -errno); - return TEST_ERR; - } - - if (pid == 0) { - eventfd_t event_status = 0; - - ret = prctl(PR_SET_PDEATHSIG, SIGKILL); - if (ret < 0) { - ret = -errno; - printf("error prctl(): %d (%m)\n", ret); - _exit(TEST_ERR); - } - - /* reset sighandlers of childs */ - ret = sigaction(SIGCHLD, &oldsa, NULL); - if (ret < 0) { - ret = -errno; - printf("sigaction() failed: %d (%m)\n", ret); - _exit(TEST_ERR); - } - - ret = eventfd_read(efd, &event_status); - if (ret < 0 || event_status != 1) { - printf("error eventfd_read()\n"); - _exit(TEST_ERR); - } - - if (kdbus_args->mntns) { - ret = test_prepare_mounts(kdbus_args); - if (ret < 0) { - printf("error preparing mounts\n"); - _exit(TEST_ERR); - } - } - - ret = run_tests(kdbus_args); - _exit(ret); - } - - /* Setup userns mapping */ - if (kdbus_args->userns) { - ret = userns_map_uid_gid(pid, kdbus_args->uid_map, - kdbus_args->gid_map); - if (ret < 0) { - printf("error mapping uid and gid in userns\n"); - eventfd_write(efd, 2); - return TEST_ERR; - } - } - - ret = eventfd_write(efd, 1); - if (ret < 0) { - ret = -errno; - printf("error eventfd_write(): %d (%m)\n", ret); - return TEST_ERR; - } - - rpid = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(rpid == pid, TEST_ERR); - - close(efd); - - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) - return TEST_ERR; - - return TEST_OK; -} - -int start_tests(struct kdbus_test_args *kdbus_args) -{ - int ret; - bool namespaces; - static char fspath[4096]; - - namespaces = (kdbus_args->mntns || kdbus_args->pidns || - kdbus_args->userns); - - /* for pidns we need mntns set */ - if (kdbus_args->pidns && !kdbus_args->mntns) { - printf("Failed: please set both pid and mnt namesapces\n"); - return TEST_ERR; - } - - if (kdbus_args->userns) { - if (!config_user_ns_is_enabled()) { - printf("User namespace not supported\n"); - return TEST_ERR; - } - - if (!kdbus_args->uid_map || !kdbus_args->gid_map) { - printf("Failed: please specify uid or gid mapping\n"); - return TEST_ERR; - } - } - - print_kdbus_test_args(kdbus_args); - print_metadata_support(); - - /* setup kdbus paths */ - if (!kdbus_args->module) - kdbus_args->module = "kdbus"; - - if (!kdbus_args->root) { - snprintf(fspath, sizeof(fspath), "/sys/fs/%s", - kdbus_args->module); - kdbus_args->root = fspath; - } - - /* Start tests */ - if (namespaces) - ret = run_tests_in_namespaces(kdbus_args); - else - ret = run_tests(kdbus_args); - - return ret; -} - -int main(int argc, char *argv[]) -{ - int t, ret = 0; - struct kdbus_test_args *kdbus_args; - enum { - ARG_MNTNS = 0x100, - ARG_PIDNS, - ARG_USERNS, - ARG_UIDMAP, - ARG_GIDMAP, - }; - - kdbus_args = malloc(sizeof(*kdbus_args)); - if (!kdbus_args) { - printf("unable to malloc() kdbus_args\n"); - return EXIT_FAILURE; - } - - memset(kdbus_args, 0, sizeof(*kdbus_args)); - - static const struct option options[] = { - { "loop", no_argument, NULL, 'x' }, - { "help", no_argument, NULL, 'h' }, - { "root", required_argument, NULL, 'r' }, - { "test", required_argument, NULL, 't' }, - { "bus", required_argument, NULL, 'b' }, - { "wait", required_argument, NULL, 'w' }, - { "fork", no_argument, NULL, 'f' }, - { "module", required_argument, NULL, 'm' }, - { "tap", no_argument, NULL, 'a' }, - { "mntns", no_argument, NULL, ARG_MNTNS }, - { "pidns", no_argument, NULL, ARG_PIDNS }, - { "userns", no_argument, NULL, ARG_USERNS }, - { "uidmap", required_argument, NULL, ARG_UIDMAP }, - { "gidmap", required_argument, NULL, ARG_GIDMAP }, - {} - }; - - srand(time(NULL)); - - while ((t = getopt_long(argc, argv, "hxfm:r:t:b:w:a", options, NULL)) >= 0) { - switch (t) { - case 'x': - kdbus_args->loop = 1; - break; - - case 'm': - kdbus_args->module = optarg; - break; - - case 'r': - kdbus_args->root = optarg; - break; - - case 't': - kdbus_args->test = optarg; - break; - - case 'b': - kdbus_args->busname = optarg; - break; - - case 'w': - kdbus_args->wait = strtol(optarg, NULL, 10); - break; - - case 'f': - kdbus_args->fork = 1; - break; - - case 'a': - kdbus_args->tap_output = 1; - break; - - case ARG_MNTNS: - kdbus_args->mntns = true; - break; - - case ARG_PIDNS: - kdbus_args->pidns = true; - break; - - case ARG_USERNS: - kdbus_args->userns = true; - break; - - case ARG_UIDMAP: - kdbus_args->uid_map = optarg; - break; - - case ARG_GIDMAP: - kdbus_args->gid_map = optarg; - break; - - default: - case 'h': - usage(argv[0]); - } - } - - ret = start_tests(kdbus_args); - if (ret == TEST_ERR) - return EXIT_FAILURE; - - free(kdbus_args); - - return 0; -} diff --git a/tools/testing/selftests/kdbus/kdbus-test.h b/tools/testing/selftests/kdbus/kdbus-test.h deleted file mode 100644 index ee937f9a8..000000000 --- a/tools/testing/selftests/kdbus/kdbus-test.h +++ /dev/null @@ -1,84 +0,0 @@ -#ifndef _TEST_KDBUS_H_ -#define _TEST_KDBUS_H_ - -struct kdbus_test_env { - char *buspath; - const char *root; - const char *module; - int control_fd; - struct kdbus_conn *conn; -}; - -enum { - TEST_OK, - TEST_SKIP, - TEST_ERR, -}; - -#define ASSERT_RETURN_VAL(cond, val) \ - if (!(cond)) { \ - fprintf(stderr, "Assertion '%s' failed in %s(), %s:%d\n", \ - #cond, __func__, __FILE__, __LINE__); \ - return val; \ - } - -#define ASSERT_EXIT_VAL(cond, val) \ - if (!(cond)) { \ - fprintf(stderr, "Assertion '%s' failed in %s(), %s:%d\n", \ - #cond, __func__, __FILE__, __LINE__); \ - _exit(val); \ - } - -#define ASSERT_BREAK(cond) \ - if (!(cond)) { \ - fprintf(stderr, "Assertion '%s' failed in %s(), %s:%d\n", \ - #cond, __func__, __FILE__, __LINE__); \ - break; \ - } - -#define ASSERT_RETURN(cond) \ - ASSERT_RETURN_VAL(cond, TEST_ERR) - -#define ASSERT_EXIT(cond) \ - ASSERT_EXIT_VAL(cond, EXIT_FAILURE) - -int kdbus_test_activator(struct kdbus_test_env *env); -int kdbus_test_benchmark(struct kdbus_test_env *env); -int kdbus_test_benchmark_nomemfds(struct kdbus_test_env *env); -int kdbus_test_benchmark_uds(struct kdbus_test_env *env); -int kdbus_test_bus_make(struct kdbus_test_env *env); -int kdbus_test_byebye(struct kdbus_test_env *env); -int kdbus_test_chat(struct kdbus_test_env *env); -int kdbus_test_conn_info(struct kdbus_test_env *env); -int kdbus_test_conn_update(struct kdbus_test_env *env); -int kdbus_test_daemon(struct kdbus_test_env *env); -int kdbus_test_custom_endpoint(struct kdbus_test_env *env); -int kdbus_test_fd_passing(struct kdbus_test_env *env); -int kdbus_test_free(struct kdbus_test_env *env); -int kdbus_test_hello(struct kdbus_test_env *env); -int kdbus_test_match_bloom(struct kdbus_test_env *env); -int kdbus_test_match_id_add(struct kdbus_test_env *env); -int kdbus_test_match_id_remove(struct kdbus_test_env *env); -int kdbus_test_match_replace(struct kdbus_test_env *env); -int kdbus_test_match_name_add(struct kdbus_test_env *env); -int kdbus_test_match_name_change(struct kdbus_test_env *env); -int kdbus_test_match_name_remove(struct kdbus_test_env *env); -int kdbus_test_message_basic(struct kdbus_test_env *env); -int kdbus_test_message_prio(struct kdbus_test_env *env); -int kdbus_test_message_quota(struct kdbus_test_env *env); -int kdbus_test_memory_access(struct kdbus_test_env *env); -int kdbus_test_metadata_ns(struct kdbus_test_env *env); -int kdbus_test_monitor(struct kdbus_test_env *env); -int kdbus_test_name_basic(struct kdbus_test_env *env); -int kdbus_test_name_conflict(struct kdbus_test_env *env); -int kdbus_test_name_queue(struct kdbus_test_env *env); -int kdbus_test_name_takeover(struct kdbus_test_env *env); -int kdbus_test_policy(struct kdbus_test_env *env); -int kdbus_test_policy_ns(struct kdbus_test_env *env); -int kdbus_test_policy_priv(struct kdbus_test_env *env); -int kdbus_test_sync_byebye(struct kdbus_test_env *env); -int kdbus_test_sync_reply(struct kdbus_test_env *env); -int kdbus_test_timeout(struct kdbus_test_env *env); -int kdbus_test_writable_pool(struct kdbus_test_env *env); - -#endif /* _TEST_KDBUS_H_ */ diff --git a/tools/testing/selftests/kdbus/kdbus-util.c b/tools/testing/selftests/kdbus/kdbus-util.c deleted file mode 100644 index 82fa89b1a..000000000 --- a/tools/testing/selftests/kdbus/kdbus-util.c +++ /dev/null @@ -1,1612 +0,0 @@ -/* - * Copyright (C) 2013-2015 Daniel Mack - * Copyright (C) 2013-2015 Kay Sievers - * Copyright (C) 2014-2015 Djalal Harouni - * - * kdbus is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation; either version 2.1 of the License, or (at - * your option) any later version. - */ - -#include <stdio.h> -#include <stdarg.h> -#include <string.h> -#include <time.h> -#include <inttypes.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <stdbool.h> -#include <errno.h> -#include <assert.h> -#include <poll.h> -#include <grp.h> -#include <sys/capability.h> -#include <sys/mman.h> -#include <sys/stat.h> -#include <sys/time.h> -#include <linux/unistd.h> -#include <linux/memfd.h> - -#ifndef __NR_memfd_create - #ifdef __x86_64__ - #define __NR_memfd_create 319 - #elif defined __arm__ - #define __NR_memfd_create 385 - #else - #define __NR_memfd_create 356 - #endif -#endif - -#include "kdbus-api.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -#ifndef F_ADD_SEALS -#define F_LINUX_SPECIFIC_BASE 1024 -#define F_ADD_SEALS (F_LINUX_SPECIFIC_BASE + 9) -#define F_GET_SEALS (F_LINUX_SPECIFIC_BASE + 10) - -#define F_SEAL_SEAL 0x0001 /* prevent further seals from being set */ -#define F_SEAL_SHRINK 0x0002 /* prevent file from shrinking */ -#define F_SEAL_GROW 0x0004 /* prevent file from growing */ -#define F_SEAL_WRITE 0x0008 /* prevent writes */ -#endif - -int kdbus_util_verbose = true; - -int kdbus_sysfs_get_parameter_mask(const char *path, uint64_t *mask) -{ - int ret; - FILE *file; - unsigned long long value; - - file = fopen(path, "r"); - if (!file) { - ret = -errno; - kdbus_printf("--- error fopen(): %d (%m)\n", ret); - return ret; - } - - ret = fscanf(file, "%llu", &value); - if (ret != 1) { - if (ferror(file)) - ret = -errno; - else - ret = -EIO; - - kdbus_printf("--- error fscanf(): %d\n", ret); - fclose(file); - return ret; - } - - *mask = (uint64_t)value; - - fclose(file); - - return 0; -} - -int kdbus_sysfs_set_parameter_mask(const char *path, uint64_t mask) -{ - int ret; - FILE *file; - - file = fopen(path, "w"); - if (!file) { - ret = -errno; - kdbus_printf("--- error open(): %d (%m)\n", ret); - return ret; - } - - ret = fprintf(file, "%llu", (unsigned long long)mask); - if (ret <= 0) { - ret = -EIO; - kdbus_printf("--- error fprintf(): %d\n", ret); - } - - fclose(file); - - return ret > 0 ? 0 : ret; -} - -int kdbus_create_bus(int control_fd, const char *name, - uint64_t owner_meta, char **path) -{ - struct { - struct kdbus_cmd cmd; - - /* bloom size item */ - struct { - uint64_t size; - uint64_t type; - struct kdbus_bloom_parameter bloom; - } bp; - - /* owner metadata items */ - struct { - uint64_t size; - uint64_t type; - uint64_t flags; - } attach; - - /* name item */ - struct { - uint64_t size; - uint64_t type; - char str[64]; - } name; - } bus_make; - int ret; - - memset(&bus_make, 0, sizeof(bus_make)); - bus_make.bp.size = sizeof(bus_make.bp); - bus_make.bp.type = KDBUS_ITEM_BLOOM_PARAMETER; - bus_make.bp.bloom.size = 64; - bus_make.bp.bloom.n_hash = 1; - - snprintf(bus_make.name.str, sizeof(bus_make.name.str), - "%u-%s", getuid(), name); - - bus_make.attach.type = KDBUS_ITEM_ATTACH_FLAGS_SEND; - bus_make.attach.size = sizeof(bus_make.attach); - bus_make.attach.flags = owner_meta; - - bus_make.name.type = KDBUS_ITEM_MAKE_NAME; - bus_make.name.size = KDBUS_ITEM_HEADER_SIZE + - strlen(bus_make.name.str) + 1; - - bus_make.cmd.flags = KDBUS_MAKE_ACCESS_WORLD; - bus_make.cmd.size = sizeof(bus_make.cmd) + - bus_make.bp.size + - bus_make.attach.size + - bus_make.name.size; - - kdbus_printf("Creating bus with name >%s< on control fd %d ...\n", - name, control_fd); - - ret = kdbus_cmd_bus_make(control_fd, &bus_make.cmd); - if (ret < 0) { - kdbus_printf("--- error when making bus: %d (%m)\n", ret); - return ret; - } - - if (ret == 0 && path) - *path = strdup(bus_make.name.str); - - return ret; -} - -struct kdbus_conn * -kdbus_hello(const char *path, uint64_t flags, - const struct kdbus_item *item, size_t item_size) -{ - struct kdbus_cmd_free cmd_free = {}; - int fd, ret; - struct { - struct kdbus_cmd_hello hello; - - struct { - uint64_t size; - uint64_t type; - char str[16]; - } conn_name; - - uint8_t extra_items[item_size]; - } h; - struct kdbus_conn *conn; - - memset(&h, 0, sizeof(h)); - - if (item_size > 0) - memcpy(h.extra_items, item, item_size); - - kdbus_printf("-- opening bus connection %s\n", path); - fd = open(path, O_RDWR|O_CLOEXEC); - if (fd < 0) { - kdbus_printf("--- error %d (%m)\n", fd); - return NULL; - } - - h.hello.flags = flags | KDBUS_HELLO_ACCEPT_FD; - h.hello.attach_flags_send = _KDBUS_ATTACH_ALL; - h.hello.attach_flags_recv = _KDBUS_ATTACH_ALL; - h.conn_name.type = KDBUS_ITEM_CONN_DESCRIPTION; - strcpy(h.conn_name.str, "this-is-my-name"); - h.conn_name.size = KDBUS_ITEM_HEADER_SIZE + strlen(h.conn_name.str) + 1; - - h.hello.size = sizeof(h); - h.hello.pool_size = POOL_SIZE; - - ret = kdbus_cmd_hello(fd, (struct kdbus_cmd_hello *) &h.hello); - if (ret < 0) { - kdbus_printf("--- error when saying hello: %d (%m)\n", ret); - return NULL; - } - kdbus_printf("-- Our peer ID for %s: %llu -- bus uuid: '%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x'\n", - path, (unsigned long long)h.hello.id, - h.hello.id128[0], h.hello.id128[1], h.hello.id128[2], - h.hello.id128[3], h.hello.id128[4], h.hello.id128[5], - h.hello.id128[6], h.hello.id128[7], h.hello.id128[8], - h.hello.id128[9], h.hello.id128[10], h.hello.id128[11], - h.hello.id128[12], h.hello.id128[13], h.hello.id128[14], - h.hello.id128[15]); - - cmd_free.size = sizeof(cmd_free); - cmd_free.offset = h.hello.offset; - kdbus_cmd_free(fd, &cmd_free); - - conn = malloc(sizeof(*conn)); - if (!conn) { - kdbus_printf("unable to malloc()!?\n"); - return NULL; - } - - conn->buf = mmap(NULL, POOL_SIZE, PROT_READ, MAP_SHARED, fd, 0); - if (conn->buf == MAP_FAILED) { - free(conn); - close(fd); - kdbus_printf("--- error mmap (%m)\n"); - return NULL; - } - - conn->fd = fd; - conn->id = h.hello.id; - return conn; -} - -struct kdbus_conn * -kdbus_hello_registrar(const char *path, const char *name, - const struct kdbus_policy_access *access, - size_t num_access, uint64_t flags) -{ - struct kdbus_item *item, *items; - size_t i, size; - - size = KDBUS_ITEM_SIZE(strlen(name) + 1) + - num_access * KDBUS_ITEM_SIZE(sizeof(*access)); - - items = alloca(size); - - item = items; - item->size = KDBUS_ITEM_HEADER_SIZE + strlen(name) + 1; - item->type = KDBUS_ITEM_NAME; - strcpy(item->str, name); - item = KDBUS_ITEM_NEXT(item); - - for (i = 0; i < num_access; i++) { - item->size = KDBUS_ITEM_HEADER_SIZE + - sizeof(struct kdbus_policy_access); - item->type = KDBUS_ITEM_POLICY_ACCESS; - - item->policy_access.type = access[i].type; - item->policy_access.access = access[i].access; - item->policy_access.id = access[i].id; - - item = KDBUS_ITEM_NEXT(item); - } - - return kdbus_hello(path, flags, items, size); -} - -struct kdbus_conn *kdbus_hello_activator(const char *path, const char *name, - const struct kdbus_policy_access *access, - size_t num_access) -{ - return kdbus_hello_registrar(path, name, access, num_access, - KDBUS_HELLO_ACTIVATOR); -} - -bool kdbus_item_in_message(struct kdbus_msg *msg, uint64_t type) -{ - const struct kdbus_item *item; - - KDBUS_ITEM_FOREACH(item, msg, items) - if (item->type == type) - return true; - - return false; -} - -int kdbus_bus_creator_info(struct kdbus_conn *conn, - uint64_t flags, - uint64_t *offset) -{ - struct kdbus_cmd_info *cmd; - size_t size = sizeof(*cmd); - int ret; - - cmd = alloca(size); - memset(cmd, 0, size); - cmd->size = size; - cmd->attach_flags = flags; - - ret = kdbus_cmd_bus_creator_info(conn->fd, cmd); - if (ret < 0) { - kdbus_printf("--- error when requesting info: %d (%m)\n", ret); - return ret; - } - - if (offset) - *offset = cmd->offset; - else - kdbus_free(conn, cmd->offset); - - return 0; -} - -int kdbus_conn_info(struct kdbus_conn *conn, uint64_t id, - const char *name, uint64_t flags, - uint64_t *offset) -{ - struct kdbus_cmd_info *cmd; - size_t size = sizeof(*cmd); - struct kdbus_info *info; - int ret; - - if (name) - size += KDBUS_ITEM_HEADER_SIZE + strlen(name) + 1; - - cmd = alloca(size); - memset(cmd, 0, size); - cmd->size = size; - cmd->attach_flags = flags; - - if (name) { - cmd->items[0].size = KDBUS_ITEM_HEADER_SIZE + strlen(name) + 1; - cmd->items[0].type = KDBUS_ITEM_NAME; - strcpy(cmd->items[0].str, name); - } else { - cmd->id = id; - } - - ret = kdbus_cmd_conn_info(conn->fd, cmd); - if (ret < 0) { - kdbus_printf("--- error when requesting info: %d (%m)\n", ret); - return ret; - } - - info = (struct kdbus_info *) (conn->buf + cmd->offset); - if (info->size != cmd->info_size) { - kdbus_printf("%s(): size mismatch: %d != %d\n", __func__, - (int) info->size, (int) cmd->info_size); - return -EIO; - } - - if (offset) - *offset = cmd->offset; - else - kdbus_free(conn, cmd->offset); - - return 0; -} - -void kdbus_conn_free(struct kdbus_conn *conn) -{ - if (!conn) - return; - - if (conn->buf) - munmap(conn->buf, POOL_SIZE); - - if (conn->fd >= 0) - close(conn->fd); - - free(conn); -} - -int sys_memfd_create(const char *name, __u64 size) -{ - int ret, fd; - - fd = syscall(__NR_memfd_create, name, MFD_ALLOW_SEALING); - if (fd < 0) - return fd; - - ret = ftruncate(fd, size); - if (ret < 0) { - close(fd); - return ret; - } - - return fd; -} - -int sys_memfd_seal_set(int fd) -{ - return fcntl(fd, F_ADD_SEALS, F_SEAL_SHRINK | - F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_SEAL); -} - -off_t sys_memfd_get_size(int fd, off_t *size) -{ - struct stat stat; - int ret; - - ret = fstat(fd, &stat); - if (ret < 0) { - kdbus_printf("stat() failed: %m\n"); - return ret; - } - - *size = stat.st_size; - return 0; -} - -static int __kdbus_msg_send(const struct kdbus_conn *conn, - const char *name, - uint64_t cookie, - uint64_t flags, - uint64_t timeout, - int64_t priority, - uint64_t dst_id, - uint64_t cmd_flags, - int cancel_fd) -{ - struct kdbus_cmd_send *cmd = NULL; - struct kdbus_msg *msg = NULL; - const char ref1[1024 * 128 + 3] = "0123456789_0"; - const char ref2[] = "0123456789_1"; - struct kdbus_item *item; - struct timespec now; - uint64_t size; - int memfd = -1; - int ret; - - size = sizeof(*msg) + 3 * KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec)); - - if (dst_id == KDBUS_DST_ID_BROADCAST) - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter)) + 64; - else { - memfd = sys_memfd_create("my-name-is-nice", 1024 * 1024); - if (memfd < 0) { - kdbus_printf("failed to create memfd: %m\n"); - return memfd; - } - - if (write(memfd, "kdbus memfd 1234567", 19) != 19) { - ret = -errno; - kdbus_printf("writing to memfd failed: %m\n"); - goto out; - } - - ret = sys_memfd_seal_set(memfd); - if (ret < 0) { - ret = -errno; - kdbus_printf("memfd sealing failed: %m\n"); - goto out; - } - - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_memfd)); - } - - if (name) - size += KDBUS_ITEM_SIZE(strlen(name) + 1); - - msg = malloc(size); - if (!msg) { - ret = -errno; - kdbus_printf("unable to malloc()!?\n"); - goto out; - } - - if (dst_id == KDBUS_DST_ID_BROADCAST) - flags |= KDBUS_MSG_SIGNAL; - - memset(msg, 0, size); - msg->flags = flags; - msg->priority = priority; - msg->size = size; - msg->src_id = conn->id; - msg->dst_id = name ? 0 : dst_id; - msg->cookie = cookie; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - - if (timeout) { - ret = clock_gettime(CLOCK_MONOTONIC_COARSE, &now); - if (ret < 0) - goto out; - - msg->timeout_ns = now.tv_sec * 1000000000ULL + - now.tv_nsec + timeout; - } - - item = msg->items; - - if (name) { - item->type = KDBUS_ITEM_DST_NAME; - item->size = KDBUS_ITEM_HEADER_SIZE + strlen(name) + 1; - strcpy(item->str, name); - item = KDBUS_ITEM_NEXT(item); - } - - item->type = KDBUS_ITEM_PAYLOAD_VEC; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); - item->vec.address = (uintptr_t)&ref1; - item->vec.size = sizeof(ref1); - item = KDBUS_ITEM_NEXT(item); - - /* data padding for ref1 */ - item->type = KDBUS_ITEM_PAYLOAD_VEC; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); - item->vec.address = (uintptr_t)NULL; - item->vec.size = KDBUS_ALIGN8(sizeof(ref1)) - sizeof(ref1); - item = KDBUS_ITEM_NEXT(item); - - item->type = KDBUS_ITEM_PAYLOAD_VEC; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); - item->vec.address = (uintptr_t)&ref2; - item->vec.size = sizeof(ref2); - item = KDBUS_ITEM_NEXT(item); - - if (dst_id == KDBUS_DST_ID_BROADCAST) { - item->type = KDBUS_ITEM_BLOOM_FILTER; - item->size = KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter)) + 64; - item->bloom_filter.generation = 0; - } else { - item->type = KDBUS_ITEM_PAYLOAD_MEMFD; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_memfd); - item->memfd.size = 16; - item->memfd.fd = memfd; - } - item = KDBUS_ITEM_NEXT(item); - - size = sizeof(*cmd); - if (cancel_fd != -1) - size += KDBUS_ITEM_SIZE(sizeof(cancel_fd)); - - cmd = malloc(size); - if (!cmd) { - ret = -errno; - kdbus_printf("unable to malloc()!?\n"); - goto out; - } - - cmd->size = size; - cmd->flags = cmd_flags; - cmd->msg_address = (uintptr_t)msg; - - item = cmd->items; - - if (cancel_fd != -1) { - item->type = KDBUS_ITEM_CANCEL_FD; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(cancel_fd); - item->fds[0] = cancel_fd; - item = KDBUS_ITEM_NEXT(item); - } - - ret = kdbus_cmd_send(conn->fd, cmd); - if (ret < 0) { - kdbus_printf("error sending message: %d (%m)\n", ret); - goto out; - } - - if (cmd_flags & KDBUS_SEND_SYNC_REPLY) { - struct kdbus_msg *reply; - - kdbus_printf("SYNC REPLY @offset %llu:\n", cmd->reply.offset); - reply = (struct kdbus_msg *)(conn->buf + cmd->reply.offset); - kdbus_msg_dump(conn, reply); - - kdbus_msg_free(reply); - - ret = kdbus_free(conn, cmd->reply.offset); - if (ret < 0) - goto out; - } - -out: - free(msg); - free(cmd); - - if (memfd >= 0) - close(memfd); - - return ret < 0 ? ret : 0; -} - -int kdbus_msg_send(const struct kdbus_conn *conn, const char *name, - uint64_t cookie, uint64_t flags, uint64_t timeout, - int64_t priority, uint64_t dst_id) -{ - return __kdbus_msg_send(conn, name, cookie, flags, timeout, priority, - dst_id, 0, -1); -} - -int kdbus_msg_send_sync(const struct kdbus_conn *conn, const char *name, - uint64_t cookie, uint64_t flags, uint64_t timeout, - int64_t priority, uint64_t dst_id, int cancel_fd) -{ - return __kdbus_msg_send(conn, name, cookie, flags, timeout, priority, - dst_id, KDBUS_SEND_SYNC_REPLY, cancel_fd); -} - -int kdbus_msg_send_reply(const struct kdbus_conn *conn, - uint64_t reply_cookie, - uint64_t dst_id) -{ - struct kdbus_cmd_send cmd = {}; - struct kdbus_msg *msg; - const char ref1[1024 * 128 + 3] = "0123456789_0"; - struct kdbus_item *item; - uint64_t size; - int ret; - - size = sizeof(struct kdbus_msg); - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec)); - - msg = malloc(size); - if (!msg) { - kdbus_printf("unable to malloc()!?\n"); - return -ENOMEM; - } - - memset(msg, 0, size); - msg->size = size; - msg->src_id = conn->id; - msg->dst_id = dst_id; - msg->cookie_reply = reply_cookie; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - - item = msg->items; - - item->type = KDBUS_ITEM_PAYLOAD_VEC; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); - item->vec.address = (uintptr_t)&ref1; - item->vec.size = sizeof(ref1); - item = KDBUS_ITEM_NEXT(item); - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg; - - ret = kdbus_cmd_send(conn->fd, &cmd); - if (ret < 0) - kdbus_printf("error sending message: %d (%m)\n", ret); - - free(msg); - - return ret; -} - -static char *msg_id(uint64_t id, char *buf) -{ - if (id == 0) - return "KERNEL"; - if (id == ~0ULL) - return "BROADCAST"; - sprintf(buf, "%llu", (unsigned long long)id); - return buf; -} - -int kdbus_msg_dump(const struct kdbus_conn *conn, const struct kdbus_msg *msg) -{ - const struct kdbus_item *item = msg->items; - char buf_src[32]; - char buf_dst[32]; - uint64_t timeout = 0; - uint64_t cookie_reply = 0; - int ret = 0; - - if (msg->flags & KDBUS_MSG_EXPECT_REPLY) - timeout = msg->timeout_ns; - else - cookie_reply = msg->cookie_reply; - - kdbus_printf("MESSAGE: %s (%llu bytes) flags=0x%08llx, %s → %s, " - "cookie=%llu, timeout=%llu cookie_reply=%llu priority=%lli\n", - enum_PAYLOAD(msg->payload_type), (unsigned long long)msg->size, - (unsigned long long)msg->flags, - msg_id(msg->src_id, buf_src), msg_id(msg->dst_id, buf_dst), - (unsigned long long)msg->cookie, (unsigned long long)timeout, - (unsigned long long)cookie_reply, (long long)msg->priority); - - KDBUS_ITEM_FOREACH(item, msg, items) { - if (item->size < KDBUS_ITEM_HEADER_SIZE) { - kdbus_printf(" +%s (%llu bytes) invalid data record\n", - enum_MSG(item->type), item->size); - ret = -EINVAL; - break; - } - - switch (item->type) { - case KDBUS_ITEM_PAYLOAD_OFF: { - char *s; - - if (item->vec.offset == ~0ULL) - s = "[\\0-bytes]"; - else - s = (char *)msg + item->vec.offset; - - kdbus_printf(" +%s (%llu bytes) off=%llu size=%llu '%s'\n", - enum_MSG(item->type), item->size, - (unsigned long long)item->vec.offset, - (unsigned long long)item->vec.size, s); - break; - } - - case KDBUS_ITEM_FDS: { - int i, n = (item->size - KDBUS_ITEM_HEADER_SIZE) / - sizeof(int); - - kdbus_printf(" +%s (%llu bytes, %d fds)\n", - enum_MSG(item->type), item->size, n); - - for (i = 0; i < n; i++) - kdbus_printf(" fd[%d] = %d\n", - i, item->fds[i]); - - break; - } - - case KDBUS_ITEM_PAYLOAD_MEMFD: { - char *buf; - off_t size; - - buf = mmap(NULL, item->memfd.size, PROT_READ, - MAP_PRIVATE, item->memfd.fd, 0); - if (buf == MAP_FAILED) { - kdbus_printf("mmap() fd=%i size=%llu failed: %m\n", - item->memfd.fd, item->memfd.size); - break; - } - - if (sys_memfd_get_size(item->memfd.fd, &size) < 0) { - kdbus_printf("KDBUS_CMD_MEMFD_SIZE_GET failed: %m\n"); - break; - } - - kdbus_printf(" +%s (%llu bytes) fd=%i size=%llu filesize=%llu '%s'\n", - enum_MSG(item->type), item->size, item->memfd.fd, - (unsigned long long)item->memfd.size, - (unsigned long long)size, buf); - munmap(buf, item->memfd.size); - break; - } - - case KDBUS_ITEM_CREDS: - kdbus_printf(" +%s (%llu bytes) uid=%lld, euid=%lld, suid=%lld, fsuid=%lld, " - "gid=%lld, egid=%lld, sgid=%lld, fsgid=%lld\n", - enum_MSG(item->type), item->size, - item->creds.uid, item->creds.euid, - item->creds.suid, item->creds.fsuid, - item->creds.gid, item->creds.egid, - item->creds.sgid, item->creds.fsgid); - break; - - case KDBUS_ITEM_PIDS: - kdbus_printf(" +%s (%llu bytes) pid=%lld, tid=%lld, ppid=%lld\n", - enum_MSG(item->type), item->size, - item->pids.pid, item->pids.tid, - item->pids.ppid); - break; - - case KDBUS_ITEM_AUXGROUPS: { - int i, n; - - kdbus_printf(" +%s (%llu bytes)\n", - enum_MSG(item->type), item->size); - n = (item->size - KDBUS_ITEM_HEADER_SIZE) / - sizeof(uint64_t); - - for (i = 0; i < n; i++) - kdbus_printf(" gid[%d] = %lld\n", - i, item->data64[i]); - break; - } - - case KDBUS_ITEM_NAME: - case KDBUS_ITEM_PID_COMM: - case KDBUS_ITEM_TID_COMM: - case KDBUS_ITEM_EXE: - case KDBUS_ITEM_CGROUP: - case KDBUS_ITEM_SECLABEL: - case KDBUS_ITEM_DST_NAME: - case KDBUS_ITEM_CONN_DESCRIPTION: - kdbus_printf(" +%s (%llu bytes) '%s' (%zu)\n", - enum_MSG(item->type), item->size, - item->str, strlen(item->str)); - break; - - case KDBUS_ITEM_OWNED_NAME: { - kdbus_printf(" +%s (%llu bytes) '%s' (%zu) flags=0x%08llx\n", - enum_MSG(item->type), item->size, - item->name.name, strlen(item->name.name), - item->name.flags); - break; - } - - case KDBUS_ITEM_CMDLINE: { - size_t size = item->size - KDBUS_ITEM_HEADER_SIZE; - const char *str = item->str; - int count = 0; - - kdbus_printf(" +%s (%llu bytes) ", - enum_MSG(item->type), item->size); - while (size) { - kdbus_printf("'%s' ", str); - size -= strlen(str) + 1; - str += strlen(str) + 1; - count++; - } - - kdbus_printf("(%d string%s)\n", - count, (count == 1) ? "" : "s"); - break; - } - - case KDBUS_ITEM_AUDIT: - kdbus_printf(" +%s (%llu bytes) loginuid=%u sessionid=%u\n", - enum_MSG(item->type), item->size, - item->audit.loginuid, item->audit.sessionid); - break; - - case KDBUS_ITEM_CAPS: { - const uint32_t *cap; - int n, i; - - kdbus_printf(" +%s (%llu bytes) len=%llu bytes, last_cap %d\n", - enum_MSG(item->type), item->size, - (unsigned long long)item->size - - KDBUS_ITEM_HEADER_SIZE, - (int) item->caps.last_cap); - - cap = item->caps.caps; - n = (item->size - offsetof(struct kdbus_item, caps.caps)) - / 4 / sizeof(uint32_t); - - kdbus_printf(" CapInh="); - for (i = 0; i < n; i++) - kdbus_printf("%08x", cap[(0 * n) + (n - i - 1)]); - - kdbus_printf(" CapPrm="); - for (i = 0; i < n; i++) - kdbus_printf("%08x", cap[(1 * n) + (n - i - 1)]); - - kdbus_printf(" CapEff="); - for (i = 0; i < n; i++) - kdbus_printf("%08x", cap[(2 * n) + (n - i - 1)]); - - kdbus_printf(" CapBnd="); - for (i = 0; i < n; i++) - kdbus_printf("%08x", cap[(3 * n) + (n - i - 1)]); - kdbus_printf("\n"); - break; - } - - case KDBUS_ITEM_TIMESTAMP: - kdbus_printf(" +%s (%llu bytes) seq=%llu realtime=%lluns monotonic=%lluns\n", - enum_MSG(item->type), item->size, - (unsigned long long)item->timestamp.seqnum, - (unsigned long long)item->timestamp.realtime_ns, - (unsigned long long)item->timestamp.monotonic_ns); - break; - - case KDBUS_ITEM_REPLY_TIMEOUT: - kdbus_printf(" +%s (%llu bytes) cookie=%llu\n", - enum_MSG(item->type), item->size, - msg->cookie_reply); - break; - - case KDBUS_ITEM_NAME_ADD: - case KDBUS_ITEM_NAME_REMOVE: - case KDBUS_ITEM_NAME_CHANGE: - kdbus_printf(" +%s (%llu bytes) '%s', old id=%lld, now id=%lld, old_flags=0x%llx new_flags=0x%llx\n", - enum_MSG(item->type), - (unsigned long long) item->size, - item->name_change.name, - item->name_change.old_id.id, - item->name_change.new_id.id, - item->name_change.old_id.flags, - item->name_change.new_id.flags); - break; - - case KDBUS_ITEM_ID_ADD: - case KDBUS_ITEM_ID_REMOVE: - kdbus_printf(" +%s (%llu bytes) id=%llu flags=%llu\n", - enum_MSG(item->type), - (unsigned long long) item->size, - (unsigned long long) item->id_change.id, - (unsigned long long) item->id_change.flags); - break; - - default: - kdbus_printf(" +%s (%llu bytes)\n", - enum_MSG(item->type), item->size); - break; - } - } - - if ((char *)item - ((char *)msg + msg->size) >= 8) { - kdbus_printf("invalid padding at end of message\n"); - ret = -EINVAL; - } - - kdbus_printf("\n"); - - return ret; -} - -void kdbus_msg_free(struct kdbus_msg *msg) -{ - const struct kdbus_item *item; - int nfds, i; - - if (!msg) - return; - - KDBUS_ITEM_FOREACH(item, msg, items) { - switch (item->type) { - /* close all memfds */ - case KDBUS_ITEM_PAYLOAD_MEMFD: - close(item->memfd.fd); - break; - case KDBUS_ITEM_FDS: - nfds = (item->size - KDBUS_ITEM_HEADER_SIZE) / - sizeof(int); - - for (i = 0; i < nfds; i++) - close(item->fds[i]); - - break; - } - } -} - -int kdbus_msg_recv(struct kdbus_conn *conn, - struct kdbus_msg **msg_out, - uint64_t *offset) -{ - struct kdbus_cmd_recv recv = { .size = sizeof(recv) }; - struct kdbus_msg *msg; - int ret; - - ret = kdbus_cmd_recv(conn->fd, &recv); - if (ret < 0) - return ret; - - msg = (struct kdbus_msg *)(conn->buf + recv.msg.offset); - ret = kdbus_msg_dump(conn, msg); - if (ret < 0) { - kdbus_msg_free(msg); - return ret; - } - - if (msg_out) { - *msg_out = msg; - - if (offset) - *offset = recv.msg.offset; - } else { - kdbus_msg_free(msg); - - ret = kdbus_free(conn, recv.msg.offset); - if (ret < 0) - return ret; - } - - return 0; -} - -/* - * Returns: 0 on success, negative errno on failure. - * - * We must return -ETIMEDOUT, -ECONNREST, -EAGAIN and other errors. - * We must return the result of kdbus_msg_recv() - */ -int kdbus_msg_recv_poll(struct kdbus_conn *conn, - int timeout_ms, - struct kdbus_msg **msg_out, - uint64_t *offset) -{ - int ret; - - do { - struct timeval before, after, diff; - struct pollfd fd; - - fd.fd = conn->fd; - fd.events = POLLIN | POLLPRI | POLLHUP; - fd.revents = 0; - - gettimeofday(&before, NULL); - ret = poll(&fd, 1, timeout_ms); - gettimeofday(&after, NULL); - - if (ret == 0) { - ret = -ETIMEDOUT; - break; - } - - if (ret > 0) { - if (fd.revents & POLLIN) - ret = kdbus_msg_recv(conn, msg_out, offset); - - if (fd.revents & (POLLHUP | POLLERR)) - ret = -ECONNRESET; - } - - if (ret == 0 || ret != -EAGAIN) - break; - - timersub(&after, &before, &diff); - timeout_ms -= diff.tv_sec * 1000UL + - diff.tv_usec / 1000UL; - } while (timeout_ms > 0); - - return ret; -} - -int kdbus_free(const struct kdbus_conn *conn, uint64_t offset) -{ - struct kdbus_cmd_free cmd_free = {}; - int ret; - - cmd_free.size = sizeof(cmd_free); - cmd_free.offset = offset; - cmd_free.flags = 0; - - ret = kdbus_cmd_free(conn->fd, &cmd_free); - if (ret < 0) { - kdbus_printf("KDBUS_CMD_FREE failed: %d (%m)\n", ret); - return ret; - } - - return 0; -} - -int kdbus_name_acquire(struct kdbus_conn *conn, - const char *name, uint64_t *flags) -{ - struct kdbus_cmd *cmd_name; - size_t name_len = strlen(name) + 1; - uint64_t size = sizeof(*cmd_name) + KDBUS_ITEM_SIZE(name_len); - struct kdbus_item *item; - int ret; - - cmd_name = alloca(size); - - memset(cmd_name, 0, size); - - item = cmd_name->items; - item->size = KDBUS_ITEM_HEADER_SIZE + name_len; - item->type = KDBUS_ITEM_NAME; - strcpy(item->str, name); - - cmd_name->size = size; - if (flags) - cmd_name->flags = *flags; - - ret = kdbus_cmd_name_acquire(conn->fd, cmd_name); - if (ret < 0) { - kdbus_printf("error aquiring name: %s\n", strerror(-ret)); - return ret; - } - - kdbus_printf("%s(): flags after call: 0x%llx\n", __func__, - cmd_name->return_flags); - - if (flags) - *flags = cmd_name->return_flags; - - return 0; -} - -int kdbus_name_release(struct kdbus_conn *conn, const char *name) -{ - struct kdbus_cmd *cmd_name; - size_t name_len = strlen(name) + 1; - uint64_t size = sizeof(*cmd_name) + KDBUS_ITEM_SIZE(name_len); - struct kdbus_item *item; - int ret; - - cmd_name = alloca(size); - - memset(cmd_name, 0, size); - - item = cmd_name->items; - item->size = KDBUS_ITEM_HEADER_SIZE + name_len; - item->type = KDBUS_ITEM_NAME; - strcpy(item->str, name); - - cmd_name->size = size; - - kdbus_printf("conn %lld giving up name '%s'\n", - (unsigned long long) conn->id, name); - - ret = kdbus_cmd_name_release(conn->fd, cmd_name); - if (ret < 0) { - kdbus_printf("error releasing name: %s\n", strerror(-ret)); - return ret; - } - - return 0; -} - -int kdbus_list(struct kdbus_conn *conn, uint64_t flags) -{ - struct kdbus_cmd_list cmd_list = {}; - struct kdbus_info *list, *name; - int ret; - - cmd_list.size = sizeof(cmd_list); - cmd_list.flags = flags; - - ret = kdbus_cmd_list(conn->fd, &cmd_list); - if (ret < 0) { - kdbus_printf("error listing names: %d (%m)\n", ret); - return ret; - } - - kdbus_printf("REGISTRY:\n"); - list = (struct kdbus_info *)(conn->buf + cmd_list.offset); - - KDBUS_FOREACH(name, list, cmd_list.list_size) { - uint64_t flags = 0; - struct kdbus_item *item; - const char *n = "MISSING-NAME"; - - if (name->size == sizeof(struct kdbus_cmd)) - continue; - - KDBUS_ITEM_FOREACH(item, name, items) - if (item->type == KDBUS_ITEM_OWNED_NAME) { - n = item->name.name; - flags = item->name.flags; - - kdbus_printf("%8llu flags=0x%08llx conn=0x%08llx '%s'\n", - name->id, - (unsigned long long) flags, - name->flags, n); - } - } - kdbus_printf("\n"); - - ret = kdbus_free(conn, cmd_list.offset); - - return ret; -} - -int kdbus_conn_update_attach_flags(struct kdbus_conn *conn, - uint64_t attach_flags_send, - uint64_t attach_flags_recv) -{ - int ret; - size_t size; - struct kdbus_cmd *update; - struct kdbus_item *item; - - size = sizeof(struct kdbus_cmd); - size += KDBUS_ITEM_SIZE(sizeof(uint64_t)) * 2; - - update = malloc(size); - if (!update) { - kdbus_printf("error malloc: %m\n"); - return -ENOMEM; - } - - memset(update, 0, size); - update->size = size; - - item = update->items; - - item->type = KDBUS_ITEM_ATTACH_FLAGS_SEND; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(uint64_t); - item->data64[0] = attach_flags_send; - item = KDBUS_ITEM_NEXT(item); - - item->type = KDBUS_ITEM_ATTACH_FLAGS_RECV; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(uint64_t); - item->data64[0] = attach_flags_recv; - item = KDBUS_ITEM_NEXT(item); - - ret = kdbus_cmd_update(conn->fd, update); - if (ret < 0) - kdbus_printf("error conn update: %d (%m)\n", ret); - - free(update); - - return ret; -} - -int kdbus_conn_update_policy(struct kdbus_conn *conn, const char *name, - const struct kdbus_policy_access *access, - size_t num_access) -{ - struct kdbus_cmd *update; - struct kdbus_item *item; - size_t i, size; - int ret; - - size = sizeof(struct kdbus_cmd); - size += KDBUS_ITEM_SIZE(strlen(name) + 1); - size += num_access * KDBUS_ITEM_SIZE(sizeof(struct kdbus_policy_access)); - - update = malloc(size); - if (!update) { - kdbus_printf("error malloc: %m\n"); - return -ENOMEM; - } - - memset(update, 0, size); - update->size = size; - - item = update->items; - - item->type = KDBUS_ITEM_NAME; - item->size = KDBUS_ITEM_HEADER_SIZE + strlen(name) + 1; - strcpy(item->str, name); - item = KDBUS_ITEM_NEXT(item); - - for (i = 0; i < num_access; i++) { - item->size = KDBUS_ITEM_HEADER_SIZE + - sizeof(struct kdbus_policy_access); - item->type = KDBUS_ITEM_POLICY_ACCESS; - - item->policy_access.type = access[i].type; - item->policy_access.access = access[i].access; - item->policy_access.id = access[i].id; - - item = KDBUS_ITEM_NEXT(item); - } - - ret = kdbus_cmd_update(conn->fd, update); - if (ret < 0) - kdbus_printf("error conn update: %d (%m)\n", ret); - - free(update); - - return ret; -} - -int kdbus_add_match_id(struct kdbus_conn *conn, uint64_t cookie, - uint64_t type, uint64_t id) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - struct kdbus_notify_id_change chg; - } item; - } buf; - int ret; - - memset(&buf, 0, sizeof(buf)); - - buf.cmd.size = sizeof(buf); - buf.cmd.cookie = cookie; - buf.item.size = sizeof(buf.item); - buf.item.type = type; - buf.item.chg.id = id; - - ret = kdbus_cmd_match_add(conn->fd, &buf.cmd); - if (ret < 0) - kdbus_printf("--- error adding conn match: %d (%m)\n", ret); - - return ret; -} - -int kdbus_add_match_empty(struct kdbus_conn *conn) -{ - struct { - struct kdbus_cmd_match cmd; - struct kdbus_item item; - } buf; - int ret; - - memset(&buf, 0, sizeof(buf)); - - buf.item.size = sizeof(uint64_t) * 3; - buf.item.type = KDBUS_ITEM_ID; - buf.item.id = KDBUS_MATCH_ID_ANY; - - buf.cmd.size = sizeof(buf.cmd) + buf.item.size; - - ret = kdbus_cmd_match_add(conn->fd, &buf.cmd); - if (ret < 0) - kdbus_printf("--- error adding conn match: %d (%m)\n", ret); - - return ret; -} - -static int all_ids_are_mapped(const char *path) -{ - int ret; - FILE *file; - uint32_t inside_id, length; - - file = fopen(path, "r"); - if (!file) { - ret = -errno; - kdbus_printf("error fopen() %s: %d (%m)\n", - path, ret); - return ret; - } - - ret = fscanf(file, "%u\t%*u\t%u", &inside_id, &length); - if (ret != 2) { - if (ferror(file)) - ret = -errno; - else - ret = -EIO; - - kdbus_printf("--- error fscanf(): %d\n", ret); - fclose(file); - return ret; - } - - fclose(file); - - /* - * If length is 4294967295 which means the invalid uid - * (uid_t) -1 then we are able to map all uid/gids - */ - if (inside_id == 0 && length == (uid_t) -1) - return 1; - - return 0; -} - -int all_uids_gids_are_mapped(void) -{ - int ret; - - ret = all_ids_are_mapped("/proc/self/uid_map"); - if (ret <= 0) { - kdbus_printf("--- error not all uids are mapped\n"); - return 0; - } - - ret = all_ids_are_mapped("/proc/self/gid_map"); - if (ret <= 0) { - kdbus_printf("--- error not all gids are mapped\n"); - return 0; - } - - return 1; -} - -int drop_privileges(uid_t uid, gid_t gid) -{ - int ret; - - ret = setgroups(0, NULL); - if (ret < 0) { - ret = -errno; - kdbus_printf("error setgroups: %d (%m)\n", ret); - return ret; - } - - ret = setresgid(gid, gid, gid); - if (ret < 0) { - ret = -errno; - kdbus_printf("error setresgid: %d (%m)\n", ret); - return ret; - } - - ret = setresuid(uid, uid, uid); - if (ret < 0) { - ret = -errno; - kdbus_printf("error setresuid: %d (%m)\n", ret); - return ret; - } - - return ret; -} - -uint64_t now(clockid_t clock) -{ - struct timespec spec; - - clock_gettime(clock, &spec); - return spec.tv_sec * 1000ULL * 1000ULL * 1000ULL + spec.tv_nsec; -} - -char *unique_name(const char *prefix) -{ - unsigned int i; - uint64_t u_now; - char n[17]; - char *str; - int r; - - /* - * This returns a random string which is guaranteed to be - * globally unique across all calls to unique_name(). We - * compose the string as: - * <prefix>-<random>-<time> - * With: - * <prefix>: string provided by the caller - * <random>: a random alpha string of 16 characters - * <time>: the current time in micro-seconds since last boot - * - * The <random> part makes the string always look vastly different, - * the <time> part makes sure no two calls return the same string. - */ - - u_now = now(CLOCK_MONOTONIC); - - for (i = 0; i < sizeof(n) - 1; ++i) - n[i] = 'a' + (rand() % ('z' - 'a')); - n[sizeof(n) - 1] = 0; - - r = asprintf(&str, "%s-%s-%" PRIu64, prefix, n, u_now); - if (r < 0) - return NULL; - - return str; -} - -static int do_userns_map_id(pid_t pid, - const char *map_file, - const char *map_id) -{ - int ret; - int fd; - char *map; - unsigned int i; - - map = strndupa(map_id, strlen(map_id)); - if (!map) { - ret = -errno; - kdbus_printf("error strndupa %s: %d (%m)\n", - map_file, ret); - return ret; - } - - for (i = 0; i < strlen(map); i++) - if (map[i] == ',') - map[i] = '\n'; - - fd = open(map_file, O_RDWR); - if (fd < 0) { - ret = -errno; - kdbus_printf("error open %s: %d (%m)\n", - map_file, ret); - return ret; - } - - ret = write(fd, map, strlen(map)); - if (ret < 0) { - ret = -errno; - kdbus_printf("error write to %s: %d (%m)\n", - map_file, ret); - goto out; - } - - ret = 0; - -out: - close(fd); - return ret; -} - -int userns_map_uid_gid(pid_t pid, - const char *map_uid, - const char *map_gid) -{ - int fd, ret; - char file_id[128] = {'\0'}; - - snprintf(file_id, sizeof(file_id), "/proc/%ld/uid_map", - (long) pid); - - ret = do_userns_map_id(pid, file_id, map_uid); - if (ret < 0) - return ret; - - snprintf(file_id, sizeof(file_id), "/proc/%ld/setgroups", - (long) pid); - - fd = open(file_id, O_WRONLY); - if (fd >= 0) { - write(fd, "deny\n", 5); - close(fd); - } - - snprintf(file_id, sizeof(file_id), "/proc/%ld/gid_map", - (long) pid); - - return do_userns_map_id(pid, file_id, map_gid); -} - -static int do_cap_get_flag(cap_t caps, cap_value_t cap) -{ - int ret; - cap_flag_value_t flag_set; - - ret = cap_get_flag(caps, cap, CAP_EFFECTIVE, &flag_set); - if (ret < 0) { - ret = -errno; - kdbus_printf("error cap_get_flag(): %d (%m)\n", ret); - return ret; - } - - return (flag_set == CAP_SET); -} - -/* - * Returns: - * 1 in case all the requested effective capabilities are set. - * 0 in case we do not have the requested capabilities. This value - * will be used to abort tests with TEST_SKIP - * Negative errno on failure. - * - * Terminate args with a negative value. - */ -int test_is_capable(int cap, ...) -{ - int ret; - va_list ap; - cap_t caps; - - caps = cap_get_proc(); - if (!caps) { - ret = -errno; - kdbus_printf("error cap_get_proc(): %d (%m)\n", ret); - return ret; - } - - ret = do_cap_get_flag(caps, (cap_value_t)cap); - if (ret <= 0) - goto out; - - va_start(ap, cap); - while ((cap = va_arg(ap, int)) > 0) { - ret = do_cap_get_flag(caps, (cap_value_t)cap); - if (ret <= 0) - break; - } - va_end(ap); - -out: - cap_free(caps); - return ret; -} - -int config_user_ns_is_enabled(void) -{ - return (access("/proc/self/uid_map", F_OK) == 0); -} - -int config_auditsyscall_is_enabled(void) -{ - return (access("/proc/self/loginuid", F_OK) == 0); -} - -int config_cgroups_is_enabled(void) -{ - return (access("/proc/self/cgroup", F_OK) == 0); -} - -int config_security_is_enabled(void) -{ - int fd; - int ret; - char buf[128]; - - /* CONFIG_SECURITY is disabled */ - if (access("/proc/self/attr/current", F_OK) != 0) - return 0; - - /* - * Now only if read() fails with -EINVAL then we assume - * that SECLABEL and LSM are disabled - */ - fd = open("/proc/self/attr/current", O_RDONLY|O_CLOEXEC); - if (fd < 0) - return 1; - - ret = read(fd, buf, sizeof(buf)); - if (ret == -1 && errno == EINVAL) - ret = 0; - else - ret = 1; - - close(fd); - - return ret; -} diff --git a/tools/testing/selftests/kdbus/kdbus-util.h b/tools/testing/selftests/kdbus/kdbus-util.h deleted file mode 100644 index e1e18b92f..000000000 --- a/tools/testing/selftests/kdbus/kdbus-util.h +++ /dev/null @@ -1,218 +0,0 @@ -/* - * Copyright (C) 2013-2015 Kay Sievers - * Copyright (C) 2013-2015 Daniel Mack - * - * kdbus is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation; either version 2.1 of the License, or (at - * your option) any later version. - */ - -#pragma once - -#define BIT(X) (1 << (X)) - -#include <time.h> -#include <stdbool.h> -#include <linux/kdbus.h> - -#define _STRINGIFY(x) #x -#define STRINGIFY(x) _STRINGIFY(x) -#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) - -#define KDBUS_PTR(addr) ((void *)(uintptr_t)(addr)) - -#define KDBUS_ALIGN8(l) (((l) + 7) & ~7) -#define KDBUS_ITEM_HEADER_SIZE offsetof(struct kdbus_item, data) -#define KDBUS_ITEM_SIZE(s) KDBUS_ALIGN8((s) + KDBUS_ITEM_HEADER_SIZE) - -#define KDBUS_ITEM_NEXT(item) \ - (typeof(item))((uint8_t *)(item) + KDBUS_ALIGN8((item)->size)) -#define KDBUS_ITEM_FOREACH(item, head, first) \ - for ((item) = (head)->first; \ - ((uint8_t *)(item) < (uint8_t *)(head) + (head)->size) && \ - ((uint8_t *)(item) >= (uint8_t *)(head)); \ - (item) = KDBUS_ITEM_NEXT(item)) -#define KDBUS_FOREACH(iter, first, _size) \ - for ((iter) = (first); \ - ((uint8_t *)(iter) < (uint8_t *)(first) + (_size)) && \ - ((uint8_t *)(iter) >= (uint8_t *)(first)); \ - (iter) = (void *)((uint8_t *)(iter) + KDBUS_ALIGN8((iter)->size))) - -#define _KDBUS_ATTACH_BITS_SET_NR (__builtin_popcountll(_KDBUS_ATTACH_ALL)) - -/* Sum of KDBUS_ITEM_* that reflects _KDBUS_ATTACH_ALL */ -#define KDBUS_ATTACH_ITEMS_TYPE_SUM \ - ((((_KDBUS_ATTACH_BITS_SET_NR - 1) * \ - ((_KDBUS_ATTACH_BITS_SET_NR - 1) + 1)) / 2) + \ - (_KDBUS_ITEM_ATTACH_BASE * _KDBUS_ATTACH_BITS_SET_NR)) - -#define POOL_SIZE (16 * 1024LU * 1024LU) - -#define UNPRIV_UID 65534 -#define UNPRIV_GID 65534 - -/* Dump as user of process, useful for user namespace testing */ -#define SUID_DUMP_USER 1 - -extern int kdbus_util_verbose; - -#define kdbus_printf(X...) \ - if (kdbus_util_verbose) \ - printf(X) - -#define RUN_UNPRIVILEGED(child_uid, child_gid, _child_, _parent_) ({ \ - pid_t pid, rpid; \ - int ret; \ - \ - pid = fork(); \ - if (pid == 0) { \ - ret = drop_privileges(child_uid, child_gid); \ - ASSERT_EXIT_VAL(ret == 0, ret); \ - \ - _child_; \ - _exit(0); \ - } else if (pid > 0) { \ - _parent_; \ - rpid = waitpid(pid, &ret, 0); \ - ASSERT_RETURN(rpid == pid); \ - ASSERT_RETURN(WIFEXITED(ret)); \ - ASSERT_RETURN(WEXITSTATUS(ret) == 0); \ - ret = TEST_OK; \ - } else { \ - ret = pid; \ - } \ - \ - ret; \ - }) - -#define RUN_UNPRIVILEGED_CONN(_var_, _bus_, _code_) \ - RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_GID, ({ \ - struct kdbus_conn *_var_; \ - _var_ = kdbus_hello(_bus_, 0, NULL, 0); \ - ASSERT_EXIT(_var_); \ - _code_; \ - kdbus_conn_free(_var_); \ - }), ({ 0; })) - -#define RUN_CLONE_CHILD(clone_ret, flags, _setup_, _child_body_, \ - _parent_setup_, _parent_body_) ({ \ - pid_t pid, rpid; \ - int ret; \ - int efd = -1; \ - \ - _setup_; \ - efd = eventfd(0, EFD_CLOEXEC); \ - ASSERT_RETURN(efd >= 0); \ - *(clone_ret) = 0; \ - pid = syscall(__NR_clone, flags, NULL); \ - if (pid == 0) { \ - eventfd_t event_status = 0; \ - ret = prctl(PR_SET_PDEATHSIG, SIGKILL); \ - ASSERT_EXIT(ret == 0); \ - ret = eventfd_read(efd, &event_status); \ - if (ret < 0 || event_status != 1) { \ - kdbus_printf("error eventfd_read()\n"); \ - _exit(EXIT_FAILURE); \ - } \ - _child_body_; \ - _exit(0); \ - } else if (pid > 0) { \ - _parent_setup_; \ - ret = eventfd_write(efd, 1); \ - ASSERT_RETURN(ret >= 0); \ - _parent_body_; \ - rpid = waitpid(pid, &ret, 0); \ - ASSERT_RETURN(rpid == pid); \ - ASSERT_RETURN(WIFEXITED(ret)); \ - ASSERT_RETURN(WEXITSTATUS(ret) == 0); \ - ret = TEST_OK; \ - } else { \ - ret = -errno; \ - *(clone_ret) = -errno; \ - } \ - close(efd); \ - ret; \ -}) - -/* Enums for parent if it should drop privs or not */ -enum kdbus_drop_parent { - DO_NOT_DROP, - DROP_SAME_UNPRIV, - DROP_OTHER_UNPRIV, -}; - -struct kdbus_conn { - int fd; - uint64_t id; - unsigned char *buf; -}; - -int kdbus_sysfs_get_parameter_mask(const char *path, uint64_t *mask); -int kdbus_sysfs_set_parameter_mask(const char *path, uint64_t mask); - -int sys_memfd_create(const char *name, __u64 size); -int sys_memfd_seal_set(int fd); -off_t sys_memfd_get_size(int fd, off_t *size); - -int kdbus_list(struct kdbus_conn *conn, uint64_t flags); -int kdbus_name_release(struct kdbus_conn *conn, const char *name); -int kdbus_name_acquire(struct kdbus_conn *conn, const char *name, - uint64_t *flags); -void kdbus_msg_free(struct kdbus_msg *msg); -int kdbus_msg_recv(struct kdbus_conn *conn, - struct kdbus_msg **msg, uint64_t *offset); -int kdbus_msg_recv_poll(struct kdbus_conn *conn, int timeout_ms, - struct kdbus_msg **msg_out, uint64_t *offset); -int kdbus_free(const struct kdbus_conn *conn, uint64_t offset); -int kdbus_msg_dump(const struct kdbus_conn *conn, - const struct kdbus_msg *msg); -int kdbus_create_bus(int control_fd, const char *name, - uint64_t owner_meta, char **path); -int kdbus_msg_send(const struct kdbus_conn *conn, const char *name, - uint64_t cookie, uint64_t flags, uint64_t timeout, - int64_t priority, uint64_t dst_id); -int kdbus_msg_send_sync(const struct kdbus_conn *conn, const char *name, - uint64_t cookie, uint64_t flags, uint64_t timeout, - int64_t priority, uint64_t dst_id, int cancel_fd); -int kdbus_msg_send_reply(const struct kdbus_conn *conn, - uint64_t reply_cookie, - uint64_t dst_id); -struct kdbus_conn *kdbus_hello(const char *path, uint64_t hello_flags, - const struct kdbus_item *item, - size_t item_size); -struct kdbus_conn *kdbus_hello_registrar(const char *path, const char *name, - const struct kdbus_policy_access *access, - size_t num_access, uint64_t flags); -struct kdbus_conn *kdbus_hello_activator(const char *path, const char *name, - const struct kdbus_policy_access *access, - size_t num_access); -bool kdbus_item_in_message(struct kdbus_msg *msg, uint64_t type); -int kdbus_bus_creator_info(struct kdbus_conn *conn, - uint64_t flags, - uint64_t *offset); -int kdbus_conn_info(struct kdbus_conn *conn, uint64_t id, - const char *name, uint64_t flags, uint64_t *offset); -void kdbus_conn_free(struct kdbus_conn *conn); -int kdbus_conn_update_attach_flags(struct kdbus_conn *conn, - uint64_t attach_flags_send, - uint64_t attach_flags_recv); -int kdbus_conn_update_policy(struct kdbus_conn *conn, const char *name, - const struct kdbus_policy_access *access, - size_t num_access); - -int kdbus_add_match_id(struct kdbus_conn *conn, uint64_t cookie, - uint64_t type, uint64_t id); -int kdbus_add_match_empty(struct kdbus_conn *conn); - -int all_uids_gids_are_mapped(void); -int drop_privileges(uid_t uid, gid_t gid); -uint64_t now(clockid_t clock); -char *unique_name(const char *prefix); - -int userns_map_uid_gid(pid_t pid, const char *map_uid, const char *map_gid); -int test_is_capable(int cap, ...); -int config_user_ns_is_enabled(void); -int config_auditsyscall_is_enabled(void); -int config_cgroups_is_enabled(void); -int config_security_is_enabled(void); diff --git a/tools/testing/selftests/kdbus/test-activator.c b/tools/testing/selftests/kdbus/test-activator.c deleted file mode 100644 index c576a30ad..000000000 --- a/tools/testing/selftests/kdbus/test-activator.c +++ /dev/null @@ -1,321 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stdbool.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <poll.h> -#include <sys/capability.h> -#include <sys/types.h> -#include <sys/wait.h> - -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -static int kdbus_starter_poll(struct kdbus_conn *conn) -{ - int ret; - struct pollfd fd; - - fd.fd = conn->fd; - fd.events = POLLIN | POLLPRI | POLLHUP; - fd.revents = 0; - - ret = poll(&fd, 1, 100); - if (ret == 0) - return -ETIMEDOUT; - else if (ret > 0) { - if (fd.revents & POLLIN) - return 0; - - if (fd.revents & (POLLHUP | POLLERR)) - ret = -ECONNRESET; - } - - return ret; -} - -/* Ensure that kdbus activator logic is safe */ -static int kdbus_priv_activator(struct kdbus_test_env *env) -{ - int ret; - struct kdbus_msg *msg = NULL; - uint64_t cookie = 0xdeadbeef; - uint64_t flags; - struct kdbus_conn *activator; - struct kdbus_conn *service; - struct kdbus_conn *client; - struct kdbus_conn *holder; - struct kdbus_policy_access *access; - - access = (struct kdbus_policy_access[]){ - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = getuid(), - .access = KDBUS_POLICY_OWN, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = getuid(), - .access = KDBUS_POLICY_TALK, - }, - }; - - activator = kdbus_hello_activator(env->buspath, "foo.priv.activator", - access, 2); - ASSERT_RETURN(activator); - - service = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(service); - - client = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(client); - - /* - * Make sure that other users can't TALK to the activator - */ - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - /* Try to talk using the ID */ - ret = kdbus_msg_send(unpriv, NULL, 0xdeadbeef, 0, 0, - 0, activator->id); - ASSERT_EXIT(ret == -ENXIO); - - /* Try to talk to the name */ - ret = kdbus_msg_send(unpriv, "foo.priv.activator", - 0xdeadbeef, 0, 0, 0, - KDBUS_DST_ID_NAME); - ASSERT_EXIT(ret == -EPERM); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure that we did not receive anything, so the - * service will not be started automatically - */ - - ret = kdbus_starter_poll(activator); - ASSERT_RETURN(ret == -ETIMEDOUT); - - /* - * Now try to emulate the starter/service logic and - * acquire the name. - */ - - cookie++; - ret = kdbus_msg_send(service, "foo.priv.activator", cookie, - 0, 0, 0, KDBUS_DST_ID_NAME); - ASSERT_RETURN(ret == 0); - - ret = kdbus_starter_poll(activator); - ASSERT_RETURN(ret == 0); - - /* Policies are still checked, access denied */ - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - flags = KDBUS_NAME_REPLACE_EXISTING; - ret = kdbus_name_acquire(unpriv, "foo.priv.activator", - &flags); - ASSERT_RETURN(ret == -EPERM); - })); - ASSERT_RETURN(ret >= 0); - - flags = KDBUS_NAME_REPLACE_EXISTING; - ret = kdbus_name_acquire(service, "foo.priv.activator", - &flags); - ASSERT_RETURN(ret == 0); - - /* We read our previous starter message */ - - ret = kdbus_msg_recv_poll(service, 100, NULL, NULL); - ASSERT_RETURN(ret == 0); - - /* Try to talk, we still fail */ - - cookie++; - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - /* Try to talk to the name */ - ret = kdbus_msg_send(unpriv, "foo.priv.activator", - cookie, 0, 0, 0, - KDBUS_DST_ID_NAME); - ASSERT_EXIT(ret == -EPERM); - })); - ASSERT_RETURN(ret >= 0); - - /* Still nothing to read */ - - ret = kdbus_msg_recv_poll(service, 100, NULL, NULL); - ASSERT_RETURN(ret == -ETIMEDOUT); - - /* We receive every thing now */ - - cookie++; - ret = kdbus_msg_send(client, "foo.priv.activator", cookie, - 0, 0, 0, KDBUS_DST_ID_NAME); - ASSERT_RETURN(ret == 0); - ret = kdbus_msg_recv_poll(service, 100, &msg, NULL); - ASSERT_RETURN(ret == 0 && msg->cookie == cookie); - - kdbus_msg_free(msg); - - /* Policies default to deny TALK now */ - kdbus_conn_free(activator); - - cookie++; - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - /* Try to talk to the name */ - ret = kdbus_msg_send(unpriv, "foo.priv.activator", - cookie, 0, 0, 0, - KDBUS_DST_ID_NAME); - ASSERT_EXIT(ret == -EPERM); - })); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_msg_recv_poll(service, 100, NULL, NULL); - ASSERT_RETURN(ret == -ETIMEDOUT); - - /* Same user is able to TALK */ - cookie++; - ret = kdbus_msg_send(client, "foo.priv.activator", cookie, - 0, 0, 0, KDBUS_DST_ID_NAME); - ASSERT_RETURN(ret == 0); - ret = kdbus_msg_recv_poll(service, 100, &msg, NULL); - ASSERT_RETURN(ret == 0 && msg->cookie == cookie); - - kdbus_msg_free(msg); - - access = (struct kdbus_policy_access []){ - { - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = getuid(), - .access = KDBUS_POLICY_TALK, - }, - }; - - holder = kdbus_hello_registrar(env->buspath, "foo.priv.activator", - access, 1, KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(holder); - - /* Now we are able to TALK to the name */ - - cookie++; - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - /* Try to talk to the name */ - ret = kdbus_msg_send(unpriv, "foo.priv.activator", - cookie, 0, 0, 0, - KDBUS_DST_ID_NAME); - ASSERT_EXIT(ret == 0); - })); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_msg_recv_poll(service, 100, NULL, NULL); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - flags = KDBUS_NAME_REPLACE_EXISTING; - ret = kdbus_name_acquire(unpriv, "foo.priv.activator", - &flags); - ASSERT_RETURN(ret == -EPERM); - })); - ASSERT_RETURN(ret >= 0); - - kdbus_conn_free(service); - kdbus_conn_free(client); - kdbus_conn_free(holder); - - return 0; -} - -int kdbus_test_activator(struct kdbus_test_env *env) -{ - int ret; - struct kdbus_conn *activator; - struct pollfd fds[2]; - bool activator_done = false; - struct kdbus_policy_access access[2]; - - access[0].type = KDBUS_POLICY_ACCESS_USER; - access[0].id = getuid(); - access[0].access = KDBUS_POLICY_OWN; - - access[1].type = KDBUS_POLICY_ACCESS_WORLD; - access[1].access = KDBUS_POLICY_TALK; - - activator = kdbus_hello_activator(env->buspath, "foo.test.activator", - access, 2); - ASSERT_RETURN(activator); - - ret = kdbus_add_match_empty(env->conn); - ASSERT_RETURN(ret == 0); - - ret = kdbus_list(env->conn, KDBUS_LIST_NAMES | - KDBUS_LIST_UNIQUE | - KDBUS_LIST_ACTIVATORS | - KDBUS_LIST_QUEUED); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_send(env->conn, "foo.test.activator", 0xdeafbeef, - 0, 0, 0, KDBUS_DST_ID_NAME); - ASSERT_RETURN(ret == 0); - - fds[0].fd = activator->fd; - fds[1].fd = env->conn->fd; - - kdbus_printf("-- entering poll loop ...\n"); - - for (;;) { - int i, nfds = sizeof(fds) / sizeof(fds[0]); - - for (i = 0; i < nfds; i++) { - fds[i].events = POLLIN | POLLPRI; - fds[i].revents = 0; - } - - ret = poll(fds, nfds, 3000); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_list(env->conn, KDBUS_LIST_NAMES); - ASSERT_RETURN(ret == 0); - - if ((fds[0].revents & POLLIN) && !activator_done) { - uint64_t flags = KDBUS_NAME_REPLACE_EXISTING; - - kdbus_printf("Starter was called back!\n"); - - ret = kdbus_name_acquire(env->conn, - "foo.test.activator", &flags); - ASSERT_RETURN(ret == 0); - - activator_done = true; - } - - if (fds[1].revents & POLLIN) { - kdbus_msg_recv(env->conn, NULL, NULL); - break; - } - } - - /* Check if all uids/gids are mapped */ - if (!all_uids_gids_are_mapped()) - return TEST_SKIP; - - /* Check now capabilities, so we run the previous tests */ - ret = test_is_capable(CAP_SETUID, CAP_SETGID, -1); - ASSERT_RETURN(ret >= 0); - - if (!ret) - return TEST_SKIP; - - ret = kdbus_priv_activator(env); - ASSERT_RETURN(ret == 0); - - kdbus_conn_free(activator); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-benchmark.c b/tools/testing/selftests/kdbus/test-benchmark.c deleted file mode 100644 index 8a9744b00..000000000 --- a/tools/testing/selftests/kdbus/test-benchmark.c +++ /dev/null @@ -1,451 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <locale.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <stdbool.h> -#include <errno.h> -#include <assert.h> -#include <poll.h> -#include <sys/time.h> -#include <sys/mman.h> -#include <sys/socket.h> -#include <math.h> - -#include "kdbus-api.h" -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -#define SERVICE_NAME "foo.bar.echo" - -/* - * To have a banchmark comparison with unix socket, set: - * user_memfd = false; - * compare_uds = true; - * attach_none = true; do not attached metadata - */ - -static bool use_memfd = true; /* transmit memfd? */ -static bool compare_uds = false; /* unix-socket comparison? */ -static bool attach_none = false; /* clear attach-flags? */ -static char stress_payload[8192]; - -struct stats { - uint64_t count; - uint64_t latency_acc; - uint64_t latency_low; - uint64_t latency_high; - uint64_t latency_avg; - uint64_t latency_ssquares; -}; - -static struct stats stats; - -static void reset_stats(void) -{ - stats.count = 0; - stats.latency_acc = 0; - stats.latency_low = UINT64_MAX; - stats.latency_high = 0; - stats.latency_avg = 0; - stats.latency_ssquares = 0; -} - -static void dump_stats(bool is_uds) -{ - if (stats.count > 0) { - kdbus_printf("stats %s: %'llu packets processed, latency (nsecs) min/max/avg/dev %'7llu // %'7llu // %'7llu // %'7.f\n", - is_uds ? " (UNIX)" : "(KDBUS)", - (unsigned long long) stats.count, - (unsigned long long) stats.latency_low, - (unsigned long long) stats.latency_high, - (unsigned long long) stats.latency_avg, - sqrt(stats.latency_ssquares / stats.count)); - } else { - kdbus_printf("*** no packets received. bus stuck?\n"); - } -} - -static void add_stats(uint64_t prev) -{ - uint64_t diff, latency_avg_prev; - - diff = now(CLOCK_THREAD_CPUTIME_ID) - prev; - - stats.count++; - stats.latency_acc += diff; - - /* see Welford62 */ - latency_avg_prev = stats.latency_avg; - stats.latency_avg = stats.latency_acc / stats.count; - stats.latency_ssquares += (diff - latency_avg_prev) * (diff - stats.latency_avg); - - if (stats.latency_low > diff) - stats.latency_low = diff; - - if (stats.latency_high < diff) - stats.latency_high = diff; -} - -static int setup_simple_kdbus_msg(struct kdbus_conn *conn, - uint64_t dst_id, - struct kdbus_msg **msg_out) -{ - struct kdbus_msg *msg; - struct kdbus_item *item; - uint64_t size; - - size = sizeof(struct kdbus_msg); - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec)); - - msg = malloc(size); - ASSERT_RETURN_VAL(msg, -ENOMEM); - - memset(msg, 0, size); - msg->size = size; - msg->src_id = conn->id; - msg->dst_id = dst_id; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - - item = msg->items; - - item->type = KDBUS_ITEM_PAYLOAD_VEC; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); - item->vec.address = (uintptr_t) stress_payload; - item->vec.size = sizeof(stress_payload); - item = KDBUS_ITEM_NEXT(item); - - *msg_out = msg; - - return 0; -} - -static int setup_memfd_kdbus_msg(struct kdbus_conn *conn, - uint64_t dst_id, - off_t *memfd_item_offset, - struct kdbus_msg **msg_out) -{ - struct kdbus_msg *msg; - struct kdbus_item *item; - uint64_t size; - - size = sizeof(struct kdbus_msg); - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec)); - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_memfd)); - - msg = malloc(size); - ASSERT_RETURN_VAL(msg, -ENOMEM); - - memset(msg, 0, size); - msg->size = size; - msg->src_id = conn->id; - msg->dst_id = dst_id; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - - item = msg->items; - - item->type = KDBUS_ITEM_PAYLOAD_VEC; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); - item->vec.address = (uintptr_t) stress_payload; - item->vec.size = sizeof(stress_payload); - item = KDBUS_ITEM_NEXT(item); - - item->type = KDBUS_ITEM_PAYLOAD_MEMFD; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_memfd); - item->memfd.size = sizeof(uint64_t); - - *memfd_item_offset = (unsigned char *)item - (unsigned char *)msg; - *msg_out = msg; - - return 0; -} - -static int -send_echo_request(struct kdbus_conn *conn, uint64_t dst_id, - void *kdbus_msg, off_t memfd_item_offset) -{ - struct kdbus_cmd_send cmd = {}; - int memfd = -1; - int ret; - - if (use_memfd) { - uint64_t now_ns = now(CLOCK_THREAD_CPUTIME_ID); - struct kdbus_item *item = memfd_item_offset + kdbus_msg; - memfd = sys_memfd_create("memfd-name", 0); - ASSERT_RETURN_VAL(memfd >= 0, memfd); - - ret = write(memfd, &now_ns, sizeof(now_ns)); - ASSERT_RETURN_VAL(ret == sizeof(now_ns), -EAGAIN); - - ret = sys_memfd_seal_set(memfd); - ASSERT_RETURN_VAL(ret == 0, -errno); - - item->memfd.fd = memfd; - } - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)kdbus_msg; - - ret = kdbus_cmd_send(conn->fd, &cmd); - ASSERT_RETURN_VAL(ret == 0, ret); - - close(memfd); - - return 0; -} - -static int -handle_echo_reply(struct kdbus_conn *conn, uint64_t send_ns) -{ - int ret; - struct kdbus_cmd_recv recv = { .size = sizeof(recv) }; - struct kdbus_msg *msg; - const struct kdbus_item *item; - bool has_memfd = false; - - ret = kdbus_cmd_recv(conn->fd, &recv); - if (ret == -EAGAIN) - return ret; - - ASSERT_RETURN_VAL(ret == 0, ret); - - if (!use_memfd) - goto out; - - msg = (struct kdbus_msg *)(conn->buf + recv.msg.offset); - - KDBUS_ITEM_FOREACH(item, msg, items) { - switch (item->type) { - case KDBUS_ITEM_PAYLOAD_MEMFD: { - char *buf; - - buf = mmap(NULL, item->memfd.size, PROT_READ, - MAP_PRIVATE, item->memfd.fd, 0); - ASSERT_RETURN_VAL(buf != MAP_FAILED, -EINVAL); - ASSERT_RETURN_VAL(item->memfd.size == sizeof(uint64_t), - -EINVAL); - - add_stats(*(uint64_t*)buf); - munmap(buf, item->memfd.size); - close(item->memfd.fd); - has_memfd = true; - break; - } - - case KDBUS_ITEM_PAYLOAD_OFF: - /* ignore */ - break; - } - } - -out: - if (!has_memfd) - add_stats(send_ns); - - ret = kdbus_free(conn, recv.msg.offset); - ASSERT_RETURN_VAL(ret == 0, -errno); - - return 0; -} - -static int benchmark(struct kdbus_test_env *env) -{ - static char buf[sizeof(stress_payload)]; - struct kdbus_msg *kdbus_msg = NULL; - off_t memfd_cached_offset = 0; - int ret; - struct kdbus_conn *conn_a, *conn_b; - struct pollfd fds[2]; - uint64_t start, send_ns, now_ns, diff; - unsigned int i; - int uds[2]; - - setlocale(LC_ALL, ""); - - for (i = 0; i < sizeof(stress_payload); i++) - stress_payload[i] = i; - - /* setup kdbus pair */ - - conn_a = kdbus_hello(env->buspath, 0, NULL, 0); - conn_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_a && conn_b); - - ret = kdbus_add_match_empty(conn_a); - ASSERT_RETURN(ret == 0); - - ret = kdbus_add_match_empty(conn_b); - ASSERT_RETURN(ret == 0); - - ret = kdbus_name_acquire(conn_a, SERVICE_NAME, NULL); - ASSERT_RETURN(ret == 0); - - if (attach_none) { - ret = kdbus_conn_update_attach_flags(conn_a, - _KDBUS_ATTACH_ALL, - 0); - ASSERT_RETURN(ret == 0); - } - - /* setup UDS pair */ - - ret = socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_NONBLOCK, 0, uds); - ASSERT_RETURN(ret == 0); - - /* setup a kdbus msg now */ - if (use_memfd) { - ret = setup_memfd_kdbus_msg(conn_b, conn_a->id, - &memfd_cached_offset, - &kdbus_msg); - ASSERT_RETURN(ret == 0); - } else { - ret = setup_simple_kdbus_msg(conn_b, conn_a->id, &kdbus_msg); - ASSERT_RETURN(ret == 0); - } - - /* start benchmark */ - - kdbus_printf("-- entering poll loop ...\n"); - - do { - /* run kdbus benchmark */ - fds[0].fd = conn_a->fd; - fds[1].fd = conn_b->fd; - - /* cancel any pending message */ - handle_echo_reply(conn_a, 0); - - start = now(CLOCK_THREAD_CPUTIME_ID); - reset_stats(); - - send_ns = now(CLOCK_THREAD_CPUTIME_ID); - ret = send_echo_request(conn_b, conn_a->id, - kdbus_msg, memfd_cached_offset); - ASSERT_RETURN(ret == 0); - - while (1) { - unsigned int nfds = sizeof(fds) / sizeof(fds[0]); - unsigned int i; - - for (i = 0; i < nfds; i++) { - fds[i].events = POLLIN | POLLPRI | POLLHUP; - fds[i].revents = 0; - } - - ret = poll(fds, nfds, 10); - if (ret < 0) - break; - - if (fds[0].revents & POLLIN) { - ret = handle_echo_reply(conn_a, send_ns); - ASSERT_RETURN(ret == 0); - - send_ns = now(CLOCK_THREAD_CPUTIME_ID); - ret = send_echo_request(conn_b, conn_a->id, - kdbus_msg, - memfd_cached_offset); - ASSERT_RETURN(ret == 0); - } - - now_ns = now(CLOCK_THREAD_CPUTIME_ID); - diff = now_ns - start; - if (diff > 1000000000ULL) { - start = now_ns; - - dump_stats(false); - break; - } - } - - if (!compare_uds) - continue; - - /* run unix-socket benchmark as comparison */ - - fds[0].fd = uds[0]; - fds[1].fd = uds[1]; - - /* cancel any pendign message */ - read(uds[1], buf, sizeof(buf)); - - start = now(CLOCK_THREAD_CPUTIME_ID); - reset_stats(); - - send_ns = now(CLOCK_THREAD_CPUTIME_ID); - ret = write(uds[0], stress_payload, sizeof(stress_payload)); - ASSERT_RETURN(ret == sizeof(stress_payload)); - - while (1) { - unsigned int nfds = sizeof(fds) / sizeof(fds[0]); - unsigned int i; - - for (i = 0; i < nfds; i++) { - fds[i].events = POLLIN | POLLPRI | POLLHUP; - fds[i].revents = 0; - } - - ret = poll(fds, nfds, 10); - if (ret < 0) - break; - - if (fds[1].revents & POLLIN) { - ret = read(uds[1], buf, sizeof(buf)); - ASSERT_RETURN(ret == sizeof(buf)); - - add_stats(send_ns); - - send_ns = now(CLOCK_THREAD_CPUTIME_ID); - ret = write(uds[0], buf, sizeof(buf)); - ASSERT_RETURN(ret == sizeof(buf)); - } - - now_ns = now(CLOCK_THREAD_CPUTIME_ID); - diff = now_ns - start; - if (diff > 1000000000ULL) { - start = now_ns; - - dump_stats(true); - break; - } - } - - } while (kdbus_util_verbose); - - kdbus_printf("-- closing bus connections\n"); - - free(kdbus_msg); - - kdbus_conn_free(conn_a); - kdbus_conn_free(conn_b); - - return (stats.count > 1) ? TEST_OK : TEST_ERR; -} - -int kdbus_test_benchmark(struct kdbus_test_env *env) -{ - use_memfd = true; - attach_none = false; - compare_uds = false; - return benchmark(env); -} - -int kdbus_test_benchmark_nomemfds(struct kdbus_test_env *env) -{ - use_memfd = false; - attach_none = false; - compare_uds = false; - return benchmark(env); -} - -int kdbus_test_benchmark_uds(struct kdbus_test_env *env) -{ - use_memfd = false; - attach_none = true; - compare_uds = true; - return benchmark(env); -} diff --git a/tools/testing/selftests/kdbus/test-bus.c b/tools/testing/selftests/kdbus/test-bus.c deleted file mode 100644 index 762fb3039..000000000 --- a/tools/testing/selftests/kdbus/test-bus.c +++ /dev/null @@ -1,175 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <limits.h> -#include <sys/mman.h> -#include <stdbool.h> - -#include "kdbus-api.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -static struct kdbus_item *kdbus_get_item(struct kdbus_info *info, - uint64_t type) -{ - struct kdbus_item *item; - - KDBUS_ITEM_FOREACH(item, info, items) - if (item->type == type) - return item; - - return NULL; -} - -static int test_bus_creator_info(const char *bus_path) -{ - int ret; - uint64_t offset; - struct kdbus_conn *conn; - struct kdbus_info *info; - struct kdbus_item *item; - char *tmp, *busname; - - /* extract the bus-name from @bus_path */ - tmp = strdup(bus_path); - ASSERT_RETURN(tmp); - busname = strrchr(tmp, '/'); - ASSERT_RETURN(busname); - *busname = 0; - busname = strrchr(tmp, '/'); - ASSERT_RETURN(busname); - ++busname; - - conn = kdbus_hello(bus_path, 0, NULL, 0); - ASSERT_RETURN(conn); - - ret = kdbus_bus_creator_info(conn, _KDBUS_ATTACH_ALL, &offset); - ASSERT_RETURN(ret == 0); - - info = (struct kdbus_info *)(conn->buf + offset); - - item = kdbus_get_item(info, KDBUS_ITEM_MAKE_NAME); - ASSERT_RETURN(item); - ASSERT_RETURN(!strcmp(item->str, busname)); - - ret = kdbus_free(conn, offset); - ASSERT_RETURN_VAL(ret == 0, ret); - - free(tmp); - kdbus_conn_free(conn); - return 0; -} - -int kdbus_test_bus_make(struct kdbus_test_env *env) -{ - struct { - struct kdbus_cmd cmd; - - /* bloom size item */ - struct { - uint64_t size; - uint64_t type; - struct kdbus_bloom_parameter bloom; - } bs; - - /* name item */ - uint64_t n_size; - uint64_t n_type; - char name[64]; - } bus_make; - char s[PATH_MAX], *name; - int ret, control_fd2; - uid_t uid; - - name = unique_name(""); - ASSERT_RETURN(name); - - snprintf(s, sizeof(s), "%s/control", env->root); - env->control_fd = open(s, O_RDWR|O_CLOEXEC); - ASSERT_RETURN(env->control_fd >= 0); - - control_fd2 = open(s, O_RDWR|O_CLOEXEC); - ASSERT_RETURN(control_fd2 >= 0); - - memset(&bus_make, 0, sizeof(bus_make)); - - bus_make.bs.size = sizeof(bus_make.bs); - bus_make.bs.type = KDBUS_ITEM_BLOOM_PARAMETER; - bus_make.bs.bloom.size = 64; - bus_make.bs.bloom.n_hash = 1; - - bus_make.n_type = KDBUS_ITEM_MAKE_NAME; - - uid = getuid(); - - /* missing uid prefix */ - snprintf(bus_make.name, sizeof(bus_make.name), "foo"); - bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1; - bus_make.cmd.size = sizeof(struct kdbus_cmd) + - sizeof(bus_make.bs) + bus_make.n_size; - ret = kdbus_cmd_bus_make(env->control_fd, &bus_make.cmd); - ASSERT_RETURN(ret == -EINVAL); - - /* non alphanumeric character */ - snprintf(bus_make.name, sizeof(bus_make.name), "%u-blah@123", uid); - bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1; - bus_make.cmd.size = sizeof(struct kdbus_cmd) + - sizeof(bus_make.bs) + bus_make.n_size; - ret = kdbus_cmd_bus_make(env->control_fd, &bus_make.cmd); - ASSERT_RETURN(ret == -EINVAL); - - /* '-' at the end */ - snprintf(bus_make.name, sizeof(bus_make.name), "%u-blah-", uid); - bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1; - bus_make.cmd.size = sizeof(struct kdbus_cmd) + - sizeof(bus_make.bs) + bus_make.n_size; - ret = kdbus_cmd_bus_make(env->control_fd, &bus_make.cmd); - ASSERT_RETURN(ret == -EINVAL); - - /* create a new bus */ - snprintf(bus_make.name, sizeof(bus_make.name), "%u-%s-1", uid, name); - bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1; - bus_make.cmd.size = sizeof(struct kdbus_cmd) + - sizeof(bus_make.bs) + bus_make.n_size; - ret = kdbus_cmd_bus_make(env->control_fd, &bus_make.cmd); - ASSERT_RETURN(ret == 0); - - ret = kdbus_cmd_bus_make(control_fd2, &bus_make.cmd); - ASSERT_RETURN(ret == -EEXIST); - - snprintf(s, sizeof(s), "%s/%u-%s-1/bus", env->root, uid, name); - ASSERT_RETURN(access(s, F_OK) == 0); - - ret = test_bus_creator_info(s); - ASSERT_RETURN(ret == 0); - - /* can't use the same fd for bus make twice, even though a different - * bus name is used - */ - snprintf(bus_make.name, sizeof(bus_make.name), "%u-%s-2", uid, name); - bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1; - bus_make.cmd.size = sizeof(struct kdbus_cmd) + - sizeof(bus_make.bs) + bus_make.n_size; - ret = kdbus_cmd_bus_make(env->control_fd, &bus_make.cmd); - ASSERT_RETURN(ret == -EBADFD); - - /* create a new bus, with different fd and different bus name */ - snprintf(bus_make.name, sizeof(bus_make.name), "%u-%s-2", uid, name); - bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1; - bus_make.cmd.size = sizeof(struct kdbus_cmd) + - sizeof(bus_make.bs) + bus_make.n_size; - ret = kdbus_cmd_bus_make(control_fd2, &bus_make.cmd); - ASSERT_RETURN(ret == 0); - - close(control_fd2); - free(name); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-chat.c b/tools/testing/selftests/kdbus/test-chat.c deleted file mode 100644 index 41e5b53fe..000000000 --- a/tools/testing/selftests/kdbus/test-chat.c +++ /dev/null @@ -1,124 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <poll.h> -#include <stdbool.h> - -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -int kdbus_test_chat(struct kdbus_test_env *env) -{ - int ret, cookie; - struct kdbus_conn *conn_a, *conn_b; - struct pollfd fds[2]; - uint64_t flags; - int count; - - conn_a = kdbus_hello(env->buspath, 0, NULL, 0); - conn_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_a && conn_b); - - flags = KDBUS_NAME_ALLOW_REPLACEMENT; - ret = kdbus_name_acquire(conn_a, "foo.bar.test", &flags); - ASSERT_RETURN(ret == 0); - - ret = kdbus_name_acquire(conn_a, "foo.bar.baz", NULL); - ASSERT_RETURN(ret == 0); - - flags = KDBUS_NAME_QUEUE; - ret = kdbus_name_acquire(conn_b, "foo.bar.baz", &flags); - ASSERT_RETURN(ret == 0); - - ret = kdbus_name_acquire(conn_a, "foo.bar.double", NULL); - ASSERT_RETURN(ret == 0); - - flags = 0; - ret = kdbus_name_acquire(conn_a, "foo.bar.double", &flags); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(!(flags & KDBUS_NAME_ACQUIRED)); - - ret = kdbus_name_release(conn_a, "foo.bar.double"); - ASSERT_RETURN(ret == 0); - - ret = kdbus_name_release(conn_a, "foo.bar.double"); - ASSERT_RETURN(ret == -ESRCH); - - ret = kdbus_list(conn_b, KDBUS_LIST_UNIQUE | - KDBUS_LIST_NAMES | - KDBUS_LIST_QUEUED | - KDBUS_LIST_ACTIVATORS); - ASSERT_RETURN(ret == 0); - - ret = kdbus_add_match_empty(conn_a); - ASSERT_RETURN(ret == 0); - - ret = kdbus_add_match_empty(conn_b); - ASSERT_RETURN(ret == 0); - - cookie = 0; - ret = kdbus_msg_send(conn_b, NULL, 0xc0000000 | cookie, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - fds[0].fd = conn_a->fd; - fds[1].fd = conn_b->fd; - - kdbus_printf("-- entering poll loop ...\n"); - - for (count = 0;; count++) { - int i, nfds = sizeof(fds) / sizeof(fds[0]); - - for (i = 0; i < nfds; i++) { - fds[i].events = POLLIN | POLLPRI | POLLHUP; - fds[i].revents = 0; - } - - ret = poll(fds, nfds, 3000); - ASSERT_RETURN(ret >= 0); - - if (fds[0].revents & POLLIN) { - if (count > 2) - kdbus_name_release(conn_a, "foo.bar.baz"); - - ret = kdbus_msg_recv(conn_a, NULL, NULL); - ASSERT_RETURN(ret == 0); - ret = kdbus_msg_send(conn_a, NULL, - 0xc0000000 | cookie++, - 0, 0, 0, conn_b->id); - ASSERT_RETURN(ret == 0); - } - - if (fds[1].revents & POLLIN) { - ret = kdbus_msg_recv(conn_b, NULL, NULL); - ASSERT_RETURN(ret == 0); - ret = kdbus_msg_send(conn_b, NULL, - 0xc0000000 | cookie++, - 0, 0, 0, conn_a->id); - ASSERT_RETURN(ret == 0); - } - - ret = kdbus_list(conn_b, KDBUS_LIST_UNIQUE | - KDBUS_LIST_NAMES | - KDBUS_LIST_QUEUED | - KDBUS_LIST_ACTIVATORS); - ASSERT_RETURN(ret == 0); - - if (count > 10) - break; - } - - kdbus_printf("-- closing bus connections\n"); - kdbus_conn_free(conn_a); - kdbus_conn_free(conn_b); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-connection.c b/tools/testing/selftests/kdbus/test-connection.c deleted file mode 100644 index 4688ce8ec..000000000 --- a/tools/testing/selftests/kdbus/test-connection.c +++ /dev/null @@ -1,597 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <limits.h> -#include <sys/types.h> -#include <sys/capability.h> -#include <sys/mman.h> -#include <sys/syscall.h> -#include <sys/wait.h> -#include <stdbool.h> - -#include "kdbus-api.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -int kdbus_test_hello(struct kdbus_test_env *env) -{ - struct kdbus_cmd_free cmd_free = {}; - struct kdbus_cmd_hello hello; - int fd, ret; - - memset(&hello, 0, sizeof(hello)); - - fd = open(env->buspath, O_RDWR|O_CLOEXEC); - ASSERT_RETURN(fd >= 0); - - hello.flags = KDBUS_HELLO_ACCEPT_FD; - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - hello.attach_flags_recv = _KDBUS_ATTACH_ALL; - hello.size = sizeof(struct kdbus_cmd_hello); - hello.pool_size = POOL_SIZE; - - /* an unaligned hello must result in -EFAULT */ - ret = kdbus_cmd_hello(fd, (struct kdbus_cmd_hello *) ((char *) &hello + 1)); - ASSERT_RETURN(ret == -EFAULT); - - /* a size of 0 must return EMSGSIZE */ - hello.size = 1; - hello.flags = KDBUS_HELLO_ACCEPT_FD; - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - ret = kdbus_cmd_hello(fd, &hello); - ASSERT_RETURN(ret == -EINVAL); - - hello.size = sizeof(struct kdbus_cmd_hello); - - /* check faulty flags */ - hello.flags = 1ULL << 32; - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - ret = kdbus_cmd_hello(fd, &hello); - ASSERT_RETURN(ret == -EINVAL); - - /* check for faulty pool sizes */ - hello.pool_size = 0; - hello.flags = KDBUS_HELLO_ACCEPT_FD; - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - ret = kdbus_cmd_hello(fd, &hello); - ASSERT_RETURN(ret == -EINVAL); - - hello.pool_size = 4097; - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - ret = kdbus_cmd_hello(fd, &hello); - ASSERT_RETURN(ret == -EINVAL); - - hello.pool_size = POOL_SIZE; - - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - hello.offset = (__u64)-1; - - /* success test */ - ret = kdbus_cmd_hello(fd, &hello); - ASSERT_RETURN(ret == 0); - - /* The kernel should have returned some items */ - ASSERT_RETURN(hello.offset != (__u64)-1); - cmd_free.size = sizeof(cmd_free); - cmd_free.offset = hello.offset; - ret = kdbus_cmd_free(fd, &cmd_free); - ASSERT_RETURN(ret >= 0); - - close(fd); - - fd = open(env->buspath, O_RDWR|O_CLOEXEC); - ASSERT_RETURN(fd >= 0); - - /* no ACTIVATOR flag without a name */ - hello.flags = KDBUS_HELLO_ACTIVATOR; - ret = kdbus_cmd_hello(fd, &hello); - ASSERT_RETURN(ret == -EINVAL); - - close(fd); - - return TEST_OK; -} - -int kdbus_test_byebye(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn; - struct kdbus_cmd_recv cmd_recv = { .size = sizeof(cmd_recv) }; - struct kdbus_cmd cmd_byebye = { .size = sizeof(cmd_byebye) }; - int ret; - - /* create a 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - ret = kdbus_add_match_empty(conn); - ASSERT_RETURN(ret == 0); - - ret = kdbus_add_match_empty(env->conn); - ASSERT_RETURN(ret == 0); - - /* send over 1st connection */ - ret = kdbus_msg_send(env->conn, NULL, 0, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - /* say byebye on the 2nd, which must fail */ - ret = kdbus_cmd_byebye(conn->fd, &cmd_byebye); - ASSERT_RETURN(ret == -EBUSY); - - /* receive the message */ - ret = kdbus_cmd_recv(conn->fd, &cmd_recv); - ASSERT_RETURN(ret == 0); - - ret = kdbus_free(conn, cmd_recv.msg.offset); - ASSERT_RETURN(ret == 0); - - /* and try again */ - ret = kdbus_cmd_byebye(conn->fd, &cmd_byebye); - ASSERT_RETURN(ret == 0); - - /* a 2nd try should result in -ECONNRESET */ - ret = kdbus_cmd_byebye(conn->fd, &cmd_byebye); - ASSERT_RETURN(ret == -ECONNRESET); - - kdbus_conn_free(conn); - - return TEST_OK; -} - -/* Get only the first item */ -static struct kdbus_item *kdbus_get_item(struct kdbus_info *info, - uint64_t type) -{ - struct kdbus_item *item; - - KDBUS_ITEM_FOREACH(item, info, items) - if (item->type == type) - return item; - - return NULL; -} - -static unsigned int kdbus_count_item(struct kdbus_info *info, - uint64_t type) -{ - unsigned int i = 0; - const struct kdbus_item *item; - - KDBUS_ITEM_FOREACH(item, info, items) - if (item->type == type) - i++; - - return i; -} - -static int kdbus_fuzz_conn_info(struct kdbus_test_env *env, int capable) -{ - int ret; - unsigned int cnt = 0; - uint64_t offset = 0; - struct kdbus_info *info; - struct kdbus_conn *conn; - struct kdbus_conn *privileged; - const struct kdbus_item *item; - uint64_t valid_flags = KDBUS_ATTACH_NAMES | - KDBUS_ATTACH_CREDS | - KDBUS_ATTACH_PIDS | - KDBUS_ATTACH_CONN_DESCRIPTION; - - uint64_t invalid_flags = KDBUS_ATTACH_NAMES | - KDBUS_ATTACH_CREDS | - KDBUS_ATTACH_PIDS | - KDBUS_ATTACH_CAPS | - KDBUS_ATTACH_CGROUP | - KDBUS_ATTACH_CONN_DESCRIPTION; - - struct kdbus_creds cached_creds; - uid_t ruid, euid, suid; - gid_t rgid, egid, sgid; - - getresuid(&ruid, &euid, &suid); - getresgid(&rgid, &egid, &sgid); - - cached_creds.uid = ruid; - cached_creds.euid = euid; - cached_creds.suid = suid; - cached_creds.fsuid = ruid; - - cached_creds.gid = rgid; - cached_creds.egid = egid; - cached_creds.sgid = sgid; - cached_creds.fsgid = rgid; - - struct kdbus_pids cached_pids = { - .pid = getpid(), - .tid = syscall(SYS_gettid), - .ppid = getppid(), - }; - - ret = kdbus_conn_info(env->conn, env->conn->id, NULL, - valid_flags, &offset); - ASSERT_RETURN(ret == 0); - - info = (struct kdbus_info *)(env->conn->buf + offset); - ASSERT_RETURN(info->id == env->conn->id); - - /* We do not have any well-known name */ - item = kdbus_get_item(info, KDBUS_ITEM_NAME); - ASSERT_RETURN(item == NULL); - - item = kdbus_get_item(info, KDBUS_ITEM_CONN_DESCRIPTION); - if (valid_flags & KDBUS_ATTACH_CONN_DESCRIPTION) { - ASSERT_RETURN(item); - } else { - ASSERT_RETURN(item == NULL); - } - - kdbus_free(env->conn, offset); - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - privileged = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(privileged); - - ret = kdbus_conn_info(conn, conn->id, NULL, valid_flags, &offset); - ASSERT_RETURN(ret == 0); - - info = (struct kdbus_info *)(conn->buf + offset); - ASSERT_RETURN(info->id == conn->id); - - /* We do not have any well-known name */ - item = kdbus_get_item(info, KDBUS_ITEM_NAME); - ASSERT_RETURN(item == NULL); - - cnt = kdbus_count_item(info, KDBUS_ITEM_CREDS); - if (valid_flags & KDBUS_ATTACH_CREDS) { - ASSERT_RETURN(cnt == 1); - - item = kdbus_get_item(info, KDBUS_ITEM_CREDS); - ASSERT_RETURN(item); - - /* Compare received items with cached creds */ - ASSERT_RETURN(memcmp(&item->creds, &cached_creds, - sizeof(struct kdbus_creds)) == 0); - } else { - ASSERT_RETURN(cnt == 0); - } - - item = kdbus_get_item(info, KDBUS_ITEM_PIDS); - if (valid_flags & KDBUS_ATTACH_PIDS) { - ASSERT_RETURN(item); - - /* Compare item->pids with cached PIDs */ - ASSERT_RETURN(item->pids.pid == cached_pids.pid && - item->pids.tid == cached_pids.tid && - item->pids.ppid == cached_pids.ppid); - } else { - ASSERT_RETURN(item == NULL); - } - - /* We did not request KDBUS_ITEM_CAPS */ - item = kdbus_get_item(info, KDBUS_ITEM_CAPS); - ASSERT_RETURN(item == NULL); - - kdbus_free(conn, offset); - - ret = kdbus_name_acquire(conn, "com.example.a", NULL); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_conn_info(conn, conn->id, NULL, valid_flags, &offset); - ASSERT_RETURN(ret == 0); - - info = (struct kdbus_info *)(conn->buf + offset); - ASSERT_RETURN(info->id == conn->id); - - item = kdbus_get_item(info, KDBUS_ITEM_OWNED_NAME); - if (valid_flags & KDBUS_ATTACH_NAMES) { - ASSERT_RETURN(item && !strcmp(item->name.name, "com.example.a")); - } else { - ASSERT_RETURN(item == NULL); - } - - kdbus_free(conn, offset); - - ret = kdbus_conn_info(conn, 0, "com.example.a", valid_flags, &offset); - ASSERT_RETURN(ret == 0); - - info = (struct kdbus_info *)(conn->buf + offset); - ASSERT_RETURN(info->id == conn->id); - - kdbus_free(conn, offset); - - /* does not have the necessary caps to drop to unprivileged */ - if (!capable) - goto continue_test; - - ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_GID, ({ - ret = kdbus_conn_info(conn, conn->id, NULL, - valid_flags, &offset); - ASSERT_EXIT(ret == 0); - - info = (struct kdbus_info *)(conn->buf + offset); - ASSERT_EXIT(info->id == conn->id); - - if (valid_flags & KDBUS_ATTACH_NAMES) { - item = kdbus_get_item(info, KDBUS_ITEM_OWNED_NAME); - ASSERT_EXIT(item && - strcmp(item->name.name, - "com.example.a") == 0); - } - - if (valid_flags & KDBUS_ATTACH_CREDS) { - item = kdbus_get_item(info, KDBUS_ITEM_CREDS); - ASSERT_EXIT(item); - - /* Compare received items with cached creds */ - ASSERT_EXIT(memcmp(&item->creds, &cached_creds, - sizeof(struct kdbus_creds)) == 0); - } - - if (valid_flags & KDBUS_ATTACH_PIDS) { - item = kdbus_get_item(info, KDBUS_ITEM_PIDS); - ASSERT_EXIT(item); - - /* - * Compare item->pids with cached pids of - * privileged one. - * - * cmd_info will always return cached pids. - */ - ASSERT_EXIT(item->pids.pid == cached_pids.pid && - item->pids.tid == cached_pids.tid); - } - - kdbus_free(conn, offset); - - /* - * Use invalid_flags and make sure that userspace - * do not play with us. - */ - ret = kdbus_conn_info(conn, conn->id, NULL, - invalid_flags, &offset); - ASSERT_EXIT(ret == 0); - - /* - * Make sure that we return only one creds item and - * it points to the cached creds. - */ - cnt = kdbus_count_item(info, KDBUS_ITEM_CREDS); - if (invalid_flags & KDBUS_ATTACH_CREDS) { - ASSERT_EXIT(cnt == 1); - - item = kdbus_get_item(info, KDBUS_ITEM_CREDS); - ASSERT_EXIT(item); - - /* Compare received items with cached creds */ - ASSERT_EXIT(memcmp(&item->creds, &cached_creds, - sizeof(struct kdbus_creds)) == 0); - } else { - ASSERT_EXIT(cnt == 0); - } - - if (invalid_flags & KDBUS_ATTACH_PIDS) { - cnt = kdbus_count_item(info, KDBUS_ITEM_PIDS); - ASSERT_EXIT(cnt == 1); - - item = kdbus_get_item(info, KDBUS_ITEM_PIDS); - ASSERT_EXIT(item); - - /* Compare item->pids with cached pids */ - ASSERT_EXIT(item->pids.pid == cached_pids.pid && - item->pids.tid == cached_pids.tid); - } - - cnt = kdbus_count_item(info, KDBUS_ITEM_CGROUP); - if (invalid_flags & KDBUS_ATTACH_CGROUP) { - ASSERT_EXIT(cnt == 1); - } else { - ASSERT_EXIT(cnt == 0); - } - - cnt = kdbus_count_item(info, KDBUS_ITEM_CAPS); - if (invalid_flags & KDBUS_ATTACH_CAPS) { - ASSERT_EXIT(cnt == 1); - } else { - ASSERT_EXIT(cnt == 0); - } - - kdbus_free(conn, offset); - }), - ({ 0; })); - ASSERT_RETURN(ret == 0); - -continue_test: - - /* A second name */ - ret = kdbus_name_acquire(conn, "com.example.b", NULL); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_conn_info(conn, conn->id, NULL, valid_flags, &offset); - ASSERT_RETURN(ret == 0); - - info = (struct kdbus_info *)(conn->buf + offset); - ASSERT_RETURN(info->id == conn->id); - - cnt = kdbus_count_item(info, KDBUS_ITEM_OWNED_NAME); - if (valid_flags & KDBUS_ATTACH_NAMES) { - ASSERT_RETURN(cnt == 2); - } else { - ASSERT_RETURN(cnt == 0); - } - - kdbus_free(conn, offset); - - ASSERT_RETURN(ret == 0); - - return 0; -} - -int kdbus_test_conn_info(struct kdbus_test_env *env) -{ - int ret; - int have_caps; - struct { - struct kdbus_cmd_info cmd_info; - - struct { - uint64_t size; - uint64_t type; - char str[64]; - } name; - } buf; - - buf.cmd_info.size = sizeof(struct kdbus_cmd_info); - buf.cmd_info.flags = 0; - buf.cmd_info.attach_flags = 0; - buf.cmd_info.id = env->conn->id; - - ret = kdbus_conn_info(env->conn, env->conn->id, NULL, 0, NULL); - ASSERT_RETURN(ret == 0); - - /* try to pass a name that is longer than the buffer's size */ - buf.name.size = KDBUS_ITEM_HEADER_SIZE + 1; - buf.name.type = KDBUS_ITEM_NAME; - strcpy(buf.name.str, "foo.bar.bla"); - - buf.cmd_info.id = 0; - buf.cmd_info.size = sizeof(buf.cmd_info) + buf.name.size; - ret = kdbus_cmd_conn_info(env->conn->fd, (struct kdbus_cmd_info *) &buf); - ASSERT_RETURN(ret == -EINVAL); - - /* Pass a non existent name */ - ret = kdbus_conn_info(env->conn, 0, "non.existent.name", 0, NULL); - ASSERT_RETURN(ret == -ESRCH); - - if (!all_uids_gids_are_mapped()) - return TEST_SKIP; - - /* Test for caps here, so we run the previous test */ - have_caps = test_is_capable(CAP_SETUID, CAP_SETGID, -1); - ASSERT_RETURN(have_caps >= 0); - - ret = kdbus_fuzz_conn_info(env, have_caps); - ASSERT_RETURN(ret == 0); - - /* Now if we have skipped some tests then let the user know */ - if (!have_caps) - return TEST_SKIP; - - return TEST_OK; -} - -int kdbus_test_conn_update(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn; - struct kdbus_msg *msg; - int found = 0; - int ret; - - /* - * kdbus_hello() sets all attach flags. Receive a message by this - * connection, and make sure a timestamp item (just to pick one) is - * present. - */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - ret = kdbus_msg_send(env->conn, NULL, 0x12345678, 0, 0, 0, conn->id); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - - found = kdbus_item_in_message(msg, KDBUS_ITEM_TIMESTAMP); - ASSERT_RETURN(found == 1); - - kdbus_msg_free(msg); - - /* - * Now, modify the attach flags and repeat the action. The item must - * now be missing. - */ - found = 0; - - ret = kdbus_conn_update_attach_flags(conn, - _KDBUS_ATTACH_ALL, - _KDBUS_ATTACH_ALL & - ~KDBUS_ATTACH_TIMESTAMP); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_send(env->conn, NULL, 0x12345678, 0, 0, 0, conn->id); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - - found = kdbus_item_in_message(msg, KDBUS_ITEM_TIMESTAMP); - ASSERT_RETURN(found == 0); - - /* Provide a bogus attach_flags value */ - ret = kdbus_conn_update_attach_flags(conn, - _KDBUS_ATTACH_ALL + 1, - _KDBUS_ATTACH_ALL); - ASSERT_RETURN(ret == -EINVAL); - - kdbus_msg_free(msg); - - kdbus_conn_free(conn); - - return TEST_OK; -} - -int kdbus_test_writable_pool(struct kdbus_test_env *env) -{ - struct kdbus_cmd_free cmd_free = {}; - struct kdbus_cmd_hello hello; - int fd, ret; - void *map; - - fd = open(env->buspath, O_RDWR | O_CLOEXEC); - ASSERT_RETURN(fd >= 0); - - memset(&hello, 0, sizeof(hello)); - hello.flags = KDBUS_HELLO_ACCEPT_FD; - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - hello.attach_flags_recv = _KDBUS_ATTACH_ALL; - hello.size = sizeof(struct kdbus_cmd_hello); - hello.pool_size = POOL_SIZE; - hello.offset = (__u64)-1; - - /* success test */ - ret = kdbus_cmd_hello(fd, &hello); - ASSERT_RETURN(ret == 0); - - /* The kernel should have returned some items */ - ASSERT_RETURN(hello.offset != (__u64)-1); - cmd_free.size = sizeof(cmd_free); - cmd_free.offset = hello.offset; - ret = kdbus_cmd_free(fd, &cmd_free); - ASSERT_RETURN(ret >= 0); - - /* pools cannot be mapped writable */ - map = mmap(NULL, POOL_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); - ASSERT_RETURN(map == MAP_FAILED); - - /* pools can always be mapped readable */ - map = mmap(NULL, POOL_SIZE, PROT_READ, MAP_SHARED, fd, 0); - ASSERT_RETURN(map != MAP_FAILED); - - /* make sure we cannot change protection masks to writable */ - ret = mprotect(map, POOL_SIZE, PROT_READ | PROT_WRITE); - ASSERT_RETURN(ret < 0); - - munmap(map, POOL_SIZE); - close(fd); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-daemon.c b/tools/testing/selftests/kdbus/test-daemon.c deleted file mode 100644 index 8bc238619..000000000 --- a/tools/testing/selftests/kdbus/test-daemon.c +++ /dev/null @@ -1,65 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <poll.h> -#include <stdbool.h> - -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -int kdbus_test_daemon(struct kdbus_test_env *env) -{ - struct pollfd fds[2]; - int count; - int ret; - - /* This test doesn't make any sense in non-interactive mode */ - if (!kdbus_util_verbose) - return TEST_OK; - - printf("Created connection %llu on bus '%s'\n", - (unsigned long long) env->conn->id, env->buspath); - - ret = kdbus_name_acquire(env->conn, "com.example.kdbus-test", NULL); - ASSERT_RETURN(ret == 0); - printf(" Aquired name: com.example.kdbus-test\n"); - - fds[0].fd = env->conn->fd; - fds[1].fd = STDIN_FILENO; - - printf("Monitoring connections:\n"); - - for (count = 0;; count++) { - int i, nfds = sizeof(fds) / sizeof(fds[0]); - - for (i = 0; i < nfds; i++) { - fds[i].events = POLLIN | POLLPRI | POLLHUP; - fds[i].revents = 0; - } - - ret = poll(fds, nfds, -1); - if (ret <= 0) - break; - - if (fds[0].revents & POLLIN) { - ret = kdbus_msg_recv(env->conn, NULL, NULL); - ASSERT_RETURN(ret == 0); - } - - /* stdin */ - if (fds[1].revents & POLLIN) - break; - } - - printf("Closing bus connection\n"); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-endpoint.c b/tools/testing/selftests/kdbus/test-endpoint.c deleted file mode 100644 index 34a7be49c..000000000 --- a/tools/testing/selftests/kdbus/test-endpoint.c +++ /dev/null @@ -1,352 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <libgen.h> -#include <sys/capability.h> -#include <sys/wait.h> -#include <stdbool.h> - -#include "kdbus-api.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -#define KDBUS_SYSNAME_MAX_LEN 63 - -static int install_name_add_match(struct kdbus_conn *conn, const char *name) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - struct kdbus_notify_name_change chg; - } item; - char name[64]; - } buf; - int ret; - - /* install the match rule */ - memset(&buf, 0, sizeof(buf)); - buf.item.type = KDBUS_ITEM_NAME_ADD; - buf.item.chg.old_id.id = KDBUS_MATCH_ID_ANY; - buf.item.chg.new_id.id = KDBUS_MATCH_ID_ANY; - strncpy(buf.name, name, sizeof(buf.name) - 1); - buf.item.size = sizeof(buf.item) + strlen(buf.name) + 1; - buf.cmd.size = sizeof(buf.cmd) + buf.item.size; - - ret = kdbus_cmd_match_add(conn->fd, &buf.cmd); - if (ret < 0) - return ret; - - return 0; -} - -static int create_endpoint(const char *buspath, uid_t uid, const char *name, - uint64_t flags) -{ - struct { - struct kdbus_cmd cmd; - - /* name item */ - struct { - uint64_t size; - uint64_t type; - /* max should be KDBUS_SYSNAME_MAX_LEN */ - char str[128]; - } name; - } ep_make; - int fd, ret; - - fd = open(buspath, O_RDWR); - if (fd < 0) - return fd; - - memset(&ep_make, 0, sizeof(ep_make)); - - snprintf(ep_make.name.str, - /* Use the KDBUS_SYSNAME_MAX_LEN or sizeof(str) */ - KDBUS_SYSNAME_MAX_LEN > strlen(name) ? - KDBUS_SYSNAME_MAX_LEN : sizeof(ep_make.name.str), - "%u-%s", uid, name); - - ep_make.name.type = KDBUS_ITEM_MAKE_NAME; - ep_make.name.size = KDBUS_ITEM_HEADER_SIZE + - strlen(ep_make.name.str) + 1; - - ep_make.cmd.flags = flags; - ep_make.cmd.size = sizeof(ep_make.cmd) + ep_make.name.size; - - ret = kdbus_cmd_endpoint_make(fd, &ep_make.cmd); - if (ret < 0) { - kdbus_printf("error creating endpoint: %d (%m)\n", ret); - return ret; - } - - return fd; -} - -static int unpriv_test_custom_ep(const char *buspath) -{ - int ret, ep_fd1, ep_fd2; - char *ep1, *ep2, *tmp1, *tmp2; - - tmp1 = strdup(buspath); - tmp2 = strdup(buspath); - ASSERT_RETURN(tmp1 && tmp2); - - ret = asprintf(&ep1, "%s/%u-%s", dirname(tmp1), getuid(), "apps1"); - ASSERT_RETURN(ret >= 0); - - ret = asprintf(&ep2, "%s/%u-%s", dirname(tmp2), getuid(), "apps2"); - ASSERT_RETURN(ret >= 0); - - free(tmp1); - free(tmp2); - - /* endpoint only accessible to current uid */ - ep_fd1 = create_endpoint(buspath, getuid(), "apps1", 0); - ASSERT_RETURN(ep_fd1 >= 0); - - /* endpoint world accessible */ - ep_fd2 = create_endpoint(buspath, getuid(), "apps2", - KDBUS_MAKE_ACCESS_WORLD); - ASSERT_RETURN(ep_fd2 >= 0); - - ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_UID, ({ - int ep_fd; - struct kdbus_conn *ep_conn; - - /* - * Make sure that we are not able to create custom - * endpoints - */ - ep_fd = create_endpoint(buspath, getuid(), - "unpriv_costum_ep", 0); - ASSERT_EXIT(ep_fd == -EPERM); - - /* - * Endpoint "apps1" only accessible to same users, - * that own the endpoint. Access denied by VFS - */ - ep_conn = kdbus_hello(ep1, 0, NULL, 0); - ASSERT_EXIT(!ep_conn && errno == EACCES); - - /* Endpoint "apps2" world accessible */ - ep_conn = kdbus_hello(ep2, 0, NULL, 0); - ASSERT_EXIT(ep_conn); - - kdbus_conn_free(ep_conn); - - _exit(EXIT_SUCCESS); - }), - ({ 0; })); - ASSERT_RETURN(ret == 0); - - close(ep_fd1); - close(ep_fd2); - free(ep1); - free(ep2); - - return 0; -} - -static int update_endpoint(int fd, const char *name) -{ - int len = strlen(name) + 1; - struct { - struct kdbus_cmd cmd; - - /* name item */ - struct { - uint64_t size; - uint64_t type; - char str[KDBUS_ALIGN8(len)]; - } name; - - struct { - uint64_t size; - uint64_t type; - struct kdbus_policy_access access; - } access; - } ep_update; - int ret; - - memset(&ep_update, 0, sizeof(ep_update)); - - ep_update.name.size = KDBUS_ITEM_HEADER_SIZE + len; - ep_update.name.type = KDBUS_ITEM_NAME; - strncpy(ep_update.name.str, name, sizeof(ep_update.name.str) - 1); - - ep_update.access.size = sizeof(ep_update.access); - ep_update.access.type = KDBUS_ITEM_POLICY_ACCESS; - ep_update.access.access.type = KDBUS_POLICY_ACCESS_WORLD; - ep_update.access.access.access = KDBUS_POLICY_SEE; - - ep_update.cmd.size = sizeof(ep_update); - - ret = kdbus_cmd_endpoint_update(fd, &ep_update.cmd); - if (ret < 0) { - kdbus_printf("error updating endpoint: %d (%m)\n", ret); - return ret; - } - - return 0; -} - -int kdbus_test_custom_endpoint(struct kdbus_test_env *env) -{ - char *ep, *tmp; - int ret, ep_fd; - struct kdbus_msg *msg; - struct kdbus_conn *ep_conn; - struct kdbus_conn *reader; - const char *name = "foo.bar.baz"; - const char *epname = "foo"; - char fake_ep[KDBUS_SYSNAME_MAX_LEN + 1] = {'\0'}; - - memset(fake_ep, 'X', sizeof(fake_ep) - 1); - - /* Try to create a custom endpoint with a long name */ - ret = create_endpoint(env->buspath, getuid(), fake_ep, 0); - ASSERT_RETURN(ret == -ENAMETOOLONG); - - /* Try to create a custom endpoint with a different uid */ - ret = create_endpoint(env->buspath, getuid() + 1, "foobar", 0); - ASSERT_RETURN(ret == -EINVAL); - - /* create a custom endpoint, and open a connection on it */ - ep_fd = create_endpoint(env->buspath, getuid(), "foo", 0); - ASSERT_RETURN(ep_fd >= 0); - - tmp = strdup(env->buspath); - ASSERT_RETURN(tmp); - - ret = asprintf(&ep, "%s/%u-%s", dirname(tmp), getuid(), epname); - free(tmp); - ASSERT_RETURN(ret >= 0); - - /* Register a connection that listen to broadcasts */ - reader = kdbus_hello(ep, 0, NULL, 0); - ASSERT_RETURN(reader); - - /* Register to kernel signals */ - ret = kdbus_add_match_id(reader, 0x1, KDBUS_ITEM_ID_ADD, - KDBUS_MATCH_ID_ANY); - ASSERT_RETURN(ret == 0); - - ret = kdbus_add_match_id(reader, 0x2, KDBUS_ITEM_ID_REMOVE, - KDBUS_MATCH_ID_ANY); - ASSERT_RETURN(ret == 0); - - ret = install_name_add_match(reader, name); - ASSERT_RETURN(ret == 0); - - /* Monitor connections are not supported on custom endpoints */ - ep_conn = kdbus_hello(ep, KDBUS_HELLO_MONITOR, NULL, 0); - ASSERT_RETURN(!ep_conn && errno == EOPNOTSUPP); - - ep_conn = kdbus_hello(ep, 0, NULL, 0); - ASSERT_RETURN(ep_conn); - - /* Check that the reader got the IdAdd notification */ - ret = kdbus_msg_recv(reader, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->items[0].type == KDBUS_ITEM_ID_ADD); - ASSERT_RETURN(msg->items[0].id_change.id == ep_conn->id); - kdbus_msg_free(msg); - - /* - * Add a name add match on the endpoint connection, acquire name from - * the unfiltered connection, and make sure the filtered connection - * did not get the notification on the name owner change. Also, the - * endpoint connection may not be able to call conn_info, neither on - * the name nor on the ID. - */ - ret = install_name_add_match(ep_conn, name); - ASSERT_RETURN(ret == 0); - - ret = kdbus_name_acquire(env->conn, name, NULL); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(ep_conn, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - ret = kdbus_conn_info(ep_conn, 0, name, 0, NULL); - ASSERT_RETURN(ret == -ESRCH); - - ret = kdbus_conn_info(ep_conn, 0, "random.crappy.name", 0, NULL); - ASSERT_RETURN(ret == -ESRCH); - - ret = kdbus_conn_info(ep_conn, env->conn->id, NULL, 0, NULL); - ASSERT_RETURN(ret == -ENXIO); - - ret = kdbus_conn_info(ep_conn, 0x0fffffffffffffffULL, NULL, 0, NULL); - ASSERT_RETURN(ret == -ENXIO); - - /* Check that the reader did not receive the name notification */ - ret = kdbus_msg_recv(reader, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - /* - * Release the name again, update the custom endpoint policy, - * and try again. This time, the connection on the custom endpoint - * should have gotten it. - */ - ret = kdbus_name_release(env->conn, name); - ASSERT_RETURN(ret == 0); - - /* Check that the reader did not receive the name notification */ - ret = kdbus_msg_recv(reader, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - ret = update_endpoint(ep_fd, name); - ASSERT_RETURN(ret == 0); - - ret = kdbus_name_acquire(env->conn, name, NULL); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(ep_conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->items[0].type == KDBUS_ITEM_NAME_ADD); - ASSERT_RETURN(msg->items[0].name_change.old_id.id == 0); - ASSERT_RETURN(msg->items[0].name_change.new_id.id == env->conn->id); - ASSERT_RETURN(strcmp(msg->items[0].name_change.name, name) == 0); - kdbus_msg_free(msg); - - ret = kdbus_msg_recv(reader, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(strcmp(msg->items[0].name_change.name, name) == 0); - - kdbus_msg_free(msg); - - ret = kdbus_conn_info(ep_conn, 0, name, 0, NULL); - ASSERT_RETURN(ret == 0); - - ret = kdbus_conn_info(ep_conn, env->conn->id, NULL, 0, NULL); - ASSERT_RETURN(ret == 0); - - /* If we have privileges test custom endpoints */ - ret = test_is_capable(CAP_SETUID, CAP_SETGID, -1); - ASSERT_RETURN(ret >= 0); - - /* - * All uids/gids are mapped and we have the necessary caps - */ - if (ret && all_uids_gids_are_mapped()) { - ret = unpriv_test_custom_ep(env->buspath); - ASSERT_RETURN(ret == 0); - } - - kdbus_conn_free(reader); - kdbus_conn_free(ep_conn); - close(ep_fd); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-fd.c b/tools/testing/selftests/kdbus/test-fd.c deleted file mode 100644 index 2ae0f5ae8..000000000 --- a/tools/testing/selftests/kdbus/test-fd.c +++ /dev/null @@ -1,789 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stdbool.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <sys/types.h> -#include <sys/mman.h> -#include <sys/socket.h> -#include <sys/wait.h> - -#include "kdbus-api.h" -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -#define KDBUS_MSG_MAX_ITEMS 128 -#define KDBUS_USER_MAX_CONN 256 - -/* maximum number of inflight fds in a target queue per user */ -#define KDBUS_CONN_MAX_FDS_PER_USER 16 - -/* maximum number of memfd items per message */ -#define KDBUS_MSG_MAX_MEMFD_ITEMS 16 - -static int make_msg_payload_dbus(uint64_t src_id, uint64_t dst_id, - uint64_t msg_size, - struct kdbus_msg **msg_dbus) -{ - struct kdbus_msg *msg; - - msg = malloc(msg_size); - ASSERT_RETURN_VAL(msg, -ENOMEM); - - memset(msg, 0, msg_size); - msg->size = msg_size; - msg->src_id = src_id; - msg->dst_id = dst_id; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - - *msg_dbus = msg; - - return 0; -} - -static void make_item_memfds(struct kdbus_item *item, - int *memfds, size_t memfd_size) -{ - size_t i; - - for (i = 0; i < memfd_size; i++) { - item->type = KDBUS_ITEM_PAYLOAD_MEMFD; - item->size = KDBUS_ITEM_HEADER_SIZE + - sizeof(struct kdbus_memfd); - item->memfd.fd = memfds[i]; - item->memfd.size = sizeof(uint64_t); /* const size */ - item = KDBUS_ITEM_NEXT(item); - } -} - -static void make_item_fds(struct kdbus_item *item, - int *fd_array, size_t fd_size) -{ - size_t i; - item->type = KDBUS_ITEM_FDS; - item->size = KDBUS_ITEM_HEADER_SIZE + (sizeof(int) * fd_size); - - for (i = 0; i < fd_size; i++) - item->fds[i] = fd_array[i]; -} - -static int memfd_write(const char *name, void *buf, size_t bufsize) -{ - ssize_t ret; - int memfd; - - memfd = sys_memfd_create(name, 0); - ASSERT_RETURN_VAL(memfd >= 0, memfd); - - ret = write(memfd, buf, bufsize); - ASSERT_RETURN_VAL(ret == (ssize_t)bufsize, -EAGAIN); - - ret = sys_memfd_seal_set(memfd); - ASSERT_RETURN_VAL(ret == 0, -errno); - - return memfd; -} - -static int send_memfds(struct kdbus_conn *conn, uint64_t dst_id, - int *memfds_array, size_t memfd_count) -{ - struct kdbus_cmd_send cmd = {}; - struct kdbus_item *item; - struct kdbus_msg *msg; - uint64_t size; - int ret; - - size = sizeof(struct kdbus_msg); - size += memfd_count * KDBUS_ITEM_SIZE(sizeof(struct kdbus_memfd)); - - if (dst_id == KDBUS_DST_ID_BROADCAST) - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter)) + 64; - - ret = make_msg_payload_dbus(conn->id, dst_id, size, &msg); - ASSERT_RETURN_VAL(ret == 0, ret); - - item = msg->items; - - if (dst_id == KDBUS_DST_ID_BROADCAST) { - item->type = KDBUS_ITEM_BLOOM_FILTER; - item->size = KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter)) + 64; - item = KDBUS_ITEM_NEXT(item); - - msg->flags |= KDBUS_MSG_SIGNAL; - } - - make_item_memfds(item, memfds_array, memfd_count); - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg; - - ret = kdbus_cmd_send(conn->fd, &cmd); - if (ret < 0) { - kdbus_printf("error sending message: %d (%m)\n", ret); - return ret; - } - - free(msg); - return 0; -} - -static int send_fds(struct kdbus_conn *conn, uint64_t dst_id, - int *fd_array, size_t fd_count) -{ - struct kdbus_cmd_send cmd = {}; - struct kdbus_item *item; - struct kdbus_msg *msg; - uint64_t size; - int ret; - - size = sizeof(struct kdbus_msg); - size += KDBUS_ITEM_SIZE(sizeof(int) * fd_count); - - if (dst_id == KDBUS_DST_ID_BROADCAST) - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter)) + 64; - - ret = make_msg_payload_dbus(conn->id, dst_id, size, &msg); - ASSERT_RETURN_VAL(ret == 0, ret); - - item = msg->items; - - if (dst_id == KDBUS_DST_ID_BROADCAST) { - item->type = KDBUS_ITEM_BLOOM_FILTER; - item->size = KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter)) + 64; - item = KDBUS_ITEM_NEXT(item); - - msg->flags |= KDBUS_MSG_SIGNAL; - } - - make_item_fds(item, fd_array, fd_count); - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg; - - ret = kdbus_cmd_send(conn->fd, &cmd); - if (ret < 0) { - kdbus_printf("error sending message: %d (%m)\n", ret); - return ret; - } - - free(msg); - return ret; -} - -static int send_fds_memfds(struct kdbus_conn *conn, uint64_t dst_id, - int *fds_array, size_t fd_count, - int *memfds_array, size_t memfd_count) -{ - struct kdbus_cmd_send cmd = {}; - struct kdbus_item *item; - struct kdbus_msg *msg; - uint64_t size; - int ret; - - size = sizeof(struct kdbus_msg); - size += memfd_count * KDBUS_ITEM_SIZE(sizeof(struct kdbus_memfd)); - size += KDBUS_ITEM_SIZE(sizeof(int) * fd_count); - - ret = make_msg_payload_dbus(conn->id, dst_id, size, &msg); - ASSERT_RETURN_VAL(ret == 0, ret); - - item = msg->items; - - make_item_fds(item, fds_array, fd_count); - item = KDBUS_ITEM_NEXT(item); - make_item_memfds(item, memfds_array, memfd_count); - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg; - - ret = kdbus_cmd_send(conn->fd, &cmd); - if (ret < 0) { - kdbus_printf("error sending message: %d (%m)\n", ret); - return ret; - } - - free(msg); - return ret; -} - -/* Return the number of received fds */ -static unsigned int kdbus_item_get_nfds(struct kdbus_msg *msg) -{ - unsigned int fds = 0; - const struct kdbus_item *item; - - KDBUS_ITEM_FOREACH(item, msg, items) { - switch (item->type) { - case KDBUS_ITEM_FDS: { - fds += (item->size - KDBUS_ITEM_HEADER_SIZE) / - sizeof(int); - break; - } - - case KDBUS_ITEM_PAYLOAD_MEMFD: - fds++; - break; - - default: - break; - } - } - - return fds; -} - -static struct kdbus_msg * -get_kdbus_msg_with_fd(struct kdbus_conn *conn_src, - uint64_t dst_id, uint64_t cookie, int fd) -{ - int ret; - uint64_t size; - struct kdbus_item *item; - struct kdbus_msg *msg; - - size = sizeof(struct kdbus_msg); - if (fd >= 0) - size += KDBUS_ITEM_SIZE(sizeof(int)); - - ret = make_msg_payload_dbus(conn_src->id, dst_id, size, &msg); - ASSERT_RETURN_VAL(ret == 0, NULL); - - msg->cookie = cookie; - - if (fd >= 0) { - item = msg->items; - - make_item_fds(item, (int *)&fd, 1); - } - - return msg; -} - -static int kdbus_test_no_fds(struct kdbus_test_env *env, - int *fds, int *memfd) -{ - pid_t pid; - int ret, status; - uint64_t cookie; - int connfd1, connfd2; - struct kdbus_msg *msg, *msg_sync_reply; - struct kdbus_cmd_hello hello; - struct kdbus_conn *conn_src, *conn_dst, *conn_dummy; - struct kdbus_cmd_send cmd = {}; - struct kdbus_cmd_free cmd_free = {}; - - conn_src = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_src); - - connfd1 = open(env->buspath, O_RDWR|O_CLOEXEC); - ASSERT_RETURN(connfd1 >= 0); - - connfd2 = open(env->buspath, O_RDWR|O_CLOEXEC); - ASSERT_RETURN(connfd2 >= 0); - - /* - * Create connections without KDBUS_HELLO_ACCEPT_FD - * to test if send fd operations are blocked - */ - conn_dst = malloc(sizeof(*conn_dst)); - ASSERT_RETURN(conn_dst); - - conn_dummy = malloc(sizeof(*conn_dummy)); - ASSERT_RETURN(conn_dummy); - - memset(&hello, 0, sizeof(hello)); - hello.size = sizeof(struct kdbus_cmd_hello); - hello.pool_size = POOL_SIZE; - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - - ret = kdbus_cmd_hello(connfd1, &hello); - ASSERT_RETURN(ret == 0); - - cmd_free.size = sizeof(cmd_free); - cmd_free.offset = hello.offset; - ret = kdbus_cmd_free(connfd1, &cmd_free); - ASSERT_RETURN(ret >= 0); - - conn_dst->fd = connfd1; - conn_dst->id = hello.id; - - memset(&hello, 0, sizeof(hello)); - hello.size = sizeof(struct kdbus_cmd_hello); - hello.pool_size = POOL_SIZE; - hello.attach_flags_send = _KDBUS_ATTACH_ALL; - - ret = kdbus_cmd_hello(connfd2, &hello); - ASSERT_RETURN(ret == 0); - - cmd_free.size = sizeof(cmd_free); - cmd_free.offset = hello.offset; - ret = kdbus_cmd_free(connfd2, &cmd_free); - ASSERT_RETURN(ret >= 0); - - conn_dummy->fd = connfd2; - conn_dummy->id = hello.id; - - conn_dst->buf = mmap(NULL, POOL_SIZE, PROT_READ, - MAP_SHARED, connfd1, 0); - ASSERT_RETURN(conn_dst->buf != MAP_FAILED); - - conn_dummy->buf = mmap(NULL, POOL_SIZE, PROT_READ, - MAP_SHARED, connfd2, 0); - ASSERT_RETURN(conn_dummy->buf != MAP_FAILED); - - /* - * Send fds to connection that do not accept fd passing - */ - ret = send_fds(conn_src, conn_dst->id, fds, 1); - ASSERT_RETURN(ret == -ECOMM); - - /* - * memfd are kdbus payload - */ - ret = send_memfds(conn_src, conn_dst->id, memfd, 1); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv_poll(conn_dst, 100, NULL, NULL); - ASSERT_RETURN(ret == 0); - - cookie = time(NULL); - - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, pid); - - if (pid == 0) { - struct timespec now; - - /* - * A sync send/reply to a connection that do not - * accept fds should fail if it contains an fd - */ - msg_sync_reply = get_kdbus_msg_with_fd(conn_dst, - conn_dummy->id, - cookie, fds[0]); - ASSERT_EXIT(msg_sync_reply); - - ret = clock_gettime(CLOCK_MONOTONIC_COARSE, &now); - ASSERT_EXIT(ret == 0); - - msg_sync_reply->timeout_ns = now.tv_sec * 1000000000ULL + - now.tv_nsec + 100000000ULL; - msg_sync_reply->flags = KDBUS_MSG_EXPECT_REPLY; - - memset(&cmd, 0, sizeof(cmd)); - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg_sync_reply; - cmd.flags = KDBUS_SEND_SYNC_REPLY; - - ret = kdbus_cmd_send(conn_dst->fd, &cmd); - ASSERT_EXIT(ret == -ECOMM); - - /* - * Now send a normal message, but the sync reply - * will fail since it contains an fd that the - * original sender do not want. - * - * The original sender will fail with -ETIMEDOUT - */ - cookie++; - ret = kdbus_msg_send_sync(conn_dst, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - 5000000000ULL, 0, conn_src->id, -1); - ASSERT_EXIT(ret == -EREMOTEIO); - - cookie++; - ret = kdbus_msg_recv_poll(conn_dst, 100, &msg, NULL); - ASSERT_EXIT(ret == 0); - ASSERT_EXIT(msg->cookie == cookie); - - free(msg_sync_reply); - kdbus_msg_free(msg); - - _exit(EXIT_SUCCESS); - } - - ret = kdbus_msg_recv_poll(conn_dummy, 100, NULL, NULL); - ASSERT_RETURN(ret == -ETIMEDOUT); - - cookie++; - ret = kdbus_msg_recv_poll(conn_src, 100, &msg, NULL); - ASSERT_RETURN(ret == 0 && msg->cookie == cookie); - - kdbus_msg_free(msg); - - /* - * Try to reply with a kdbus connection handle, this should - * fail with -EOPNOTSUPP - */ - msg_sync_reply = get_kdbus_msg_with_fd(conn_src, - conn_dst->id, - cookie, conn_dst->fd); - ASSERT_RETURN(msg_sync_reply); - - msg_sync_reply->cookie_reply = cookie; - - memset(&cmd, 0, sizeof(cmd)); - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg_sync_reply; - - ret = kdbus_cmd_send(conn_src->fd, &cmd); - ASSERT_RETURN(ret == -EOPNOTSUPP); - - free(msg_sync_reply); - - /* - * Try to reply with a normal fd, this should fail even - * if the response is a sync reply - * - * From the sender view we fail with -ECOMM - */ - msg_sync_reply = get_kdbus_msg_with_fd(conn_src, - conn_dst->id, - cookie, fds[0]); - ASSERT_RETURN(msg_sync_reply); - - msg_sync_reply->cookie_reply = cookie; - - memset(&cmd, 0, sizeof(cmd)); - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg_sync_reply; - - ret = kdbus_cmd_send(conn_src->fd, &cmd); - ASSERT_RETURN(ret == -ECOMM); - - free(msg_sync_reply); - - /* - * Resend another normal message and check if the queue - * is clear - */ - cookie++; - ret = kdbus_msg_send(conn_src, NULL, cookie, 0, 0, 0, - conn_dst->id); - ASSERT_RETURN(ret == 0); - - ret = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(ret >= 0, ret); - - kdbus_conn_free(conn_dummy); - kdbus_conn_free(conn_dst); - kdbus_conn_free(conn_src); - - return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR; -} - -static int kdbus_send_multiple_fds(struct kdbus_conn *conn_src, - struct kdbus_conn *conn_dst) -{ - int ret, i; - unsigned int nfds; - int fds[KDBUS_CONN_MAX_FDS_PER_USER + 1]; - int memfds[KDBUS_MSG_MAX_ITEMS + 1]; - struct kdbus_msg *msg; - uint64_t dummy_value; - - dummy_value = time(NULL); - - for (i = 0; i < KDBUS_CONN_MAX_FDS_PER_USER + 1; i++) { - fds[i] = open("/dev/null", O_RDWR|O_CLOEXEC); - ASSERT_RETURN_VAL(fds[i] >= 0, -errno); - } - - /* Send KDBUS_CONN_MAX_FDS_PER_USER with one more fd */ - ret = send_fds(conn_src, conn_dst->id, fds, - KDBUS_CONN_MAX_FDS_PER_USER + 1); - ASSERT_RETURN(ret == -EMFILE); - - /* Retry with the correct KDBUS_CONN_MAX_FDS_PER_USER */ - ret = send_fds(conn_src, conn_dst->id, fds, - KDBUS_CONN_MAX_FDS_PER_USER); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(conn_dst, &msg, NULL); - ASSERT_RETURN(ret == 0); - - /* Check we got the right number of fds */ - nfds = kdbus_item_get_nfds(msg); - ASSERT_RETURN(nfds == KDBUS_CONN_MAX_FDS_PER_USER); - - kdbus_msg_free(msg); - - for (i = 0; i < KDBUS_MSG_MAX_ITEMS + 1; i++, dummy_value++) { - memfds[i] = memfd_write("memfd-name", - &dummy_value, - sizeof(dummy_value)); - ASSERT_RETURN_VAL(memfds[i] >= 0, memfds[i]); - } - - /* Send KDBUS_MSG_MAX_ITEMS with one more memfd */ - ret = send_memfds(conn_src, conn_dst->id, - memfds, KDBUS_MSG_MAX_ITEMS + 1); - ASSERT_RETURN(ret == -E2BIG); - - ret = send_memfds(conn_src, conn_dst->id, - memfds, KDBUS_MSG_MAX_MEMFD_ITEMS + 1); - ASSERT_RETURN(ret == -E2BIG); - - /* Retry with the correct KDBUS_MSG_MAX_ITEMS */ - ret = send_memfds(conn_src, conn_dst->id, - memfds, KDBUS_MSG_MAX_MEMFD_ITEMS); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(conn_dst, &msg, NULL); - ASSERT_RETURN(ret == 0); - - /* Check we got the right number of fds */ - nfds = kdbus_item_get_nfds(msg); - ASSERT_RETURN(nfds == KDBUS_MSG_MAX_MEMFD_ITEMS); - - kdbus_msg_free(msg); - - - /* - * Combine multiple KDBUS_CONN_MAX_FDS_PER_USER+1 fds and - * 10 memfds - */ - ret = send_fds_memfds(conn_src, conn_dst->id, - fds, KDBUS_CONN_MAX_FDS_PER_USER + 1, - memfds, 10); - ASSERT_RETURN(ret == -EMFILE); - - ret = kdbus_msg_recv(conn_dst, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - /* - * Combine multiple KDBUS_CONN_MAX_FDS_PER_USER fds and - * (128 - 1) + 1 memfds, all fds take one item, while each - * memfd takes one item - */ - ret = send_fds_memfds(conn_src, conn_dst->id, - fds, KDBUS_CONN_MAX_FDS_PER_USER, - memfds, (KDBUS_MSG_MAX_ITEMS - 1) + 1); - ASSERT_RETURN(ret == -E2BIG); - - ret = send_fds_memfds(conn_src, conn_dst->id, - fds, KDBUS_CONN_MAX_FDS_PER_USER, - memfds, KDBUS_MSG_MAX_MEMFD_ITEMS + 1); - ASSERT_RETURN(ret == -E2BIG); - - ret = kdbus_msg_recv(conn_dst, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - /* - * Send KDBUS_CONN_MAX_FDS_PER_USER fds + - * KDBUS_MSG_MAX_MEMFD_ITEMS memfds - */ - ret = send_fds_memfds(conn_src, conn_dst->id, - fds, KDBUS_CONN_MAX_FDS_PER_USER, - memfds, KDBUS_MSG_MAX_MEMFD_ITEMS); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(conn_dst, &msg, NULL); - ASSERT_RETURN(ret == 0); - - /* Check we got the right number of fds */ - nfds = kdbus_item_get_nfds(msg); - ASSERT_RETURN(nfds == KDBUS_CONN_MAX_FDS_PER_USER + - KDBUS_MSG_MAX_MEMFD_ITEMS); - - kdbus_msg_free(msg); - - - /* - * Re-send fds + memfds, close them, but do not receive them - * and try to queue more - */ - ret = send_fds_memfds(conn_src, conn_dst->id, - fds, KDBUS_CONN_MAX_FDS_PER_USER, - memfds, KDBUS_MSG_MAX_MEMFD_ITEMS); - ASSERT_RETURN(ret == 0); - - /* close old references and get a new ones */ - for (i = 0; i < KDBUS_CONN_MAX_FDS_PER_USER + 1; i++) { - close(fds[i]); - fds[i] = open("/dev/null", O_RDWR|O_CLOEXEC); - ASSERT_RETURN_VAL(fds[i] >= 0, -errno); - } - - /* should fail since we have already fds in the queue */ - ret = send_fds(conn_src, conn_dst->id, fds, - KDBUS_CONN_MAX_FDS_PER_USER); - ASSERT_RETURN(ret == -EMFILE); - - /* This should succeed */ - ret = send_memfds(conn_src, conn_dst->id, - memfds, KDBUS_MSG_MAX_MEMFD_ITEMS); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(conn_dst, &msg, NULL); - ASSERT_RETURN(ret == 0); - - nfds = kdbus_item_get_nfds(msg); - ASSERT_RETURN(nfds == KDBUS_CONN_MAX_FDS_PER_USER + - KDBUS_MSG_MAX_MEMFD_ITEMS); - - kdbus_msg_free(msg); - - ret = kdbus_msg_recv(conn_dst, &msg, NULL); - ASSERT_RETURN(ret == 0); - - nfds = kdbus_item_get_nfds(msg); - ASSERT_RETURN(nfds == KDBUS_MSG_MAX_MEMFD_ITEMS); - - kdbus_msg_free(msg); - - ret = kdbus_msg_recv(conn_dst, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - for (i = 0; i < KDBUS_CONN_MAX_FDS_PER_USER + 1; i++) - close(fds[i]); - - for (i = 0; i < KDBUS_MSG_MAX_ITEMS + 1; i++) - close(memfds[i]); - - return 0; -} - -int kdbus_test_fd_passing(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn_src, *conn_dst; - const char *str = "stackenblocken"; - const struct kdbus_item *item; - struct kdbus_msg *msg; - unsigned int i; - uint64_t now; - int fds_conn[2]; - int sock_pair[2]; - int fds[2]; - int memfd; - int ret; - - now = (uint64_t) time(NULL); - - /* create two connections */ - conn_src = kdbus_hello(env->buspath, 0, NULL, 0); - conn_dst = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_src && conn_dst); - - fds_conn[0] = conn_src->fd; - fds_conn[1] = conn_dst->fd; - - ret = socketpair(AF_UNIX, SOCK_STREAM, 0, sock_pair); - ASSERT_RETURN(ret == 0); - - /* Setup memfd */ - memfd = memfd_write("memfd-name", &now, sizeof(now)); - ASSERT_RETURN(memfd >= 0); - - /* Setup pipes */ - ret = pipe(fds); - ASSERT_RETURN(ret == 0); - - i = write(fds[1], str, strlen(str)); - ASSERT_RETURN(i == strlen(str)); - - /* - * Try to ass the handle of a connection as message payload. - * This must fail. - */ - ret = send_fds(conn_src, conn_dst->id, fds_conn, 2); - ASSERT_RETURN(ret == -ENOTSUP); - - ret = send_fds(conn_dst, conn_src->id, fds_conn, 2); - ASSERT_RETURN(ret == -ENOTSUP); - - ret = send_fds(conn_src, conn_dst->id, sock_pair, 2); - ASSERT_RETURN(ret == -ENOTSUP); - - /* - * Send fds and memfds to connection that do not accept fds - */ - ret = kdbus_test_no_fds(env, fds, (int *)&memfd); - ASSERT_RETURN(ret == 0); - - /* Try to broadcast file descriptors. This must fail. */ - ret = send_fds(conn_src, KDBUS_DST_ID_BROADCAST, fds, 1); - ASSERT_RETURN(ret == -ENOTUNIQ); - - /* Try to broadcast memfd. This must succeed. */ - ret = send_memfds(conn_src, KDBUS_DST_ID_BROADCAST, (int *)&memfd, 1); - ASSERT_RETURN(ret == 0); - - /* Open code this loop */ -loop_send_fds: - - /* - * Send the read end of the pipe and close it. - */ - ret = send_fds(conn_src, conn_dst->id, fds, 1); - ASSERT_RETURN(ret == 0); - close(fds[0]); - - ret = kdbus_msg_recv(conn_dst, &msg, NULL); - ASSERT_RETURN(ret == 0); - - KDBUS_ITEM_FOREACH(item, msg, items) { - if (item->type == KDBUS_ITEM_FDS) { - char tmp[14]; - int nfds = (item->size - KDBUS_ITEM_HEADER_SIZE) / - sizeof(int); - ASSERT_RETURN(nfds == 1); - - i = read(item->fds[0], tmp, sizeof(tmp)); - if (i != 0) { - ASSERT_RETURN(i == sizeof(tmp)); - ASSERT_RETURN(memcmp(tmp, str, sizeof(tmp)) == 0); - - /* Write EOF */ - close(fds[1]); - - /* - * Resend the read end of the pipe, - * the receiver still holds a reference - * to it... - */ - goto loop_send_fds; - } - - /* Got EOF */ - - /* - * Close the last reference to the read end - * of the pipe, other references are - * automatically closed just after send. - */ - close(item->fds[0]); - } - } - - /* - * Try to resend the read end of the pipe. Must fail with - * -EBADF since both the sender and receiver closed their - * references to it. We assume the above since sender and - * receiver are on the same process. - */ - ret = send_fds(conn_src, conn_dst->id, fds, 1); - ASSERT_RETURN(ret == -EBADF); - - /* Then we clear out received any data... */ - kdbus_msg_free(msg); - - ret = kdbus_send_multiple_fds(conn_src, conn_dst); - ASSERT_RETURN(ret == 0); - - close(sock_pair[0]); - close(sock_pair[1]); - close(memfd); - - kdbus_conn_free(conn_src); - kdbus_conn_free(conn_dst); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-free.c b/tools/testing/selftests/kdbus/test-free.c deleted file mode 100644 index f666da3e8..000000000 --- a/tools/testing/selftests/kdbus/test-free.c +++ /dev/null @@ -1,64 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <stdbool.h> - -#include "kdbus-api.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -static int sample_ioctl_call(struct kdbus_test_env *env) -{ - int ret; - struct kdbus_cmd_list cmd_list = { - .flags = KDBUS_LIST_QUEUED, - .size = sizeof(cmd_list), - }; - - ret = kdbus_cmd_list(env->conn->fd, &cmd_list); - ASSERT_RETURN(ret == 0); - - /* DON'T FREE THIS SLICE OF MEMORY! */ - - return TEST_OK; -} - -int kdbus_test_free(struct kdbus_test_env *env) -{ - int ret; - struct kdbus_cmd_free cmd_free = {}; - - /* free an unallocated buffer */ - cmd_free.size = sizeof(cmd_free); - cmd_free.flags = 0; - cmd_free.offset = 0; - ret = kdbus_cmd_free(env->conn->fd, &cmd_free); - ASSERT_RETURN(ret == -ENXIO); - - /* free a buffer out of the pool's bounds */ - cmd_free.size = sizeof(cmd_free); - cmd_free.offset = POOL_SIZE + 1; - ret = kdbus_cmd_free(env->conn->fd, &cmd_free); - ASSERT_RETURN(ret == -ENXIO); - - /* - * The user application is responsible for freeing the allocated - * memory with the KDBUS_CMD_FREE ioctl, so let's test what happens - * if we forget about it. - */ - - ret = sample_ioctl_call(env); - ASSERT_RETURN(ret == 0); - - ret = sample_ioctl_call(env); - ASSERT_RETURN(ret == 0); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-match.c b/tools/testing/selftests/kdbus/test-match.c deleted file mode 100644 index 2360dc1d7..000000000 --- a/tools/testing/selftests/kdbus/test-match.c +++ /dev/null @@ -1,441 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <stdbool.h> - -#include "kdbus-api.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -int kdbus_test_match_id_add(struct kdbus_test_env *env) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - struct kdbus_notify_id_change chg; - } item; - } buf; - struct kdbus_conn *conn; - struct kdbus_msg *msg; - int ret; - - memset(&buf, 0, sizeof(buf)); - - buf.cmd.size = sizeof(buf); - buf.cmd.cookie = 0xdeafbeefdeaddead; - buf.item.size = sizeof(buf.item); - buf.item.type = KDBUS_ITEM_ID_ADD; - buf.item.chg.id = KDBUS_MATCH_ID_ANY; - - /* match on id add */ - ret = kdbus_cmd_match_add(env->conn->fd, &buf.cmd); - ASSERT_RETURN(ret == 0); - - /* create 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - /* 1st connection should have received a notification */ - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - - ASSERT_RETURN(msg->items[0].type == KDBUS_ITEM_ID_ADD); - ASSERT_RETURN(msg->items[0].id_change.id == conn->id); - - kdbus_conn_free(conn); - - return TEST_OK; -} - -int kdbus_test_match_id_remove(struct kdbus_test_env *env) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - struct kdbus_notify_id_change chg; - } item; - } buf; - struct kdbus_conn *conn; - struct kdbus_msg *msg; - size_t id; - int ret; - - /* create 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - id = conn->id; - - memset(&buf, 0, sizeof(buf)); - buf.cmd.size = sizeof(buf); - buf.cmd.cookie = 0xdeafbeefdeaddead; - buf.item.size = sizeof(buf.item); - buf.item.type = KDBUS_ITEM_ID_REMOVE; - buf.item.chg.id = id; - - /* register match on 2nd connection */ - ret = kdbus_cmd_match_add(env->conn->fd, &buf.cmd); - ASSERT_RETURN(ret == 0); - - /* remove 2nd connection again */ - kdbus_conn_free(conn); - - /* 1st connection should have received a notification */ - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - - ASSERT_RETURN(msg->items[0].type == KDBUS_ITEM_ID_REMOVE); - ASSERT_RETURN(msg->items[0].id_change.id == id); - - return TEST_OK; -} - -int kdbus_test_match_replace(struct kdbus_test_env *env) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - struct kdbus_notify_id_change chg; - } item; - } buf; - struct kdbus_conn *conn; - struct kdbus_msg *msg; - size_t id; - int ret; - - /* add a match to id_add */ - ASSERT_RETURN(kdbus_test_match_id_add(env) == TEST_OK); - - /* do a replace of the match from id_add to id_remove */ - memset(&buf, 0, sizeof(buf)); - - buf.cmd.size = sizeof(buf); - buf.cmd.cookie = 0xdeafbeefdeaddead; - buf.cmd.flags = KDBUS_MATCH_REPLACE; - buf.item.size = sizeof(buf.item); - buf.item.type = KDBUS_ITEM_ID_REMOVE; - buf.item.chg.id = KDBUS_MATCH_ID_ANY; - - ret = kdbus_cmd_match_add(env->conn->fd, &buf.cmd); - - /* create 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - id = conn->id; - - /* 1st connection should _not_ have received a notification */ - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret != 0); - - /* remove 2nd connection */ - kdbus_conn_free(conn); - - /* 1st connection should _now_ have received a notification */ - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - - ASSERT_RETURN(msg->items[0].type == KDBUS_ITEM_ID_REMOVE); - ASSERT_RETURN(msg->items[0].id_change.id == id); - - return TEST_OK; -} - -int kdbus_test_match_name_add(struct kdbus_test_env *env) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - struct kdbus_notify_name_change chg; - } item; - char name[64]; - } buf; - struct kdbus_msg *msg; - char *name; - int ret; - - name = "foo.bla.blaz"; - - /* install the match rule */ - memset(&buf, 0, sizeof(buf)); - buf.item.type = KDBUS_ITEM_NAME_ADD; - buf.item.chg.old_id.id = KDBUS_MATCH_ID_ANY; - buf.item.chg.new_id.id = KDBUS_MATCH_ID_ANY; - strncpy(buf.name, name, sizeof(buf.name) - 1); - buf.item.size = sizeof(buf.item) + strlen(buf.name) + 1; - buf.cmd.size = sizeof(buf.cmd) + buf.item.size; - - ret = kdbus_cmd_match_add(env->conn->fd, &buf.cmd); - ASSERT_RETURN(ret == 0); - - /* acquire the name */ - ret = kdbus_name_acquire(env->conn, name, NULL); - ASSERT_RETURN(ret == 0); - - /* we should have received a notification */ - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - - ASSERT_RETURN(msg->items[0].type == KDBUS_ITEM_NAME_ADD); - ASSERT_RETURN(msg->items[0].name_change.old_id.id == 0); - ASSERT_RETURN(msg->items[0].name_change.new_id.id == env->conn->id); - ASSERT_RETURN(strcmp(msg->items[0].name_change.name, name) == 0); - - return TEST_OK; -} - -int kdbus_test_match_name_remove(struct kdbus_test_env *env) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - struct kdbus_notify_name_change chg; - } item; - char name[64]; - } buf; - struct kdbus_msg *msg; - char *name; - int ret; - - name = "foo.bla.blaz"; - - /* acquire the name */ - ret = kdbus_name_acquire(env->conn, name, NULL); - ASSERT_RETURN(ret == 0); - - /* install the match rule */ - memset(&buf, 0, sizeof(buf)); - buf.item.type = KDBUS_ITEM_NAME_REMOVE; - buf.item.chg.old_id.id = KDBUS_MATCH_ID_ANY; - buf.item.chg.new_id.id = KDBUS_MATCH_ID_ANY; - strncpy(buf.name, name, sizeof(buf.name) - 1); - buf.item.size = sizeof(buf.item) + strlen(buf.name) + 1; - buf.cmd.size = sizeof(buf.cmd) + buf.item.size; - - ret = kdbus_cmd_match_add(env->conn->fd, &buf.cmd); - ASSERT_RETURN(ret == 0); - - /* release the name again */ - kdbus_name_release(env->conn, name); - ASSERT_RETURN(ret == 0); - - /* we should have received a notification */ - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - - ASSERT_RETURN(msg->items[0].type == KDBUS_ITEM_NAME_REMOVE); - ASSERT_RETURN(msg->items[0].name_change.old_id.id == env->conn->id); - ASSERT_RETURN(msg->items[0].name_change.new_id.id == 0); - ASSERT_RETURN(strcmp(msg->items[0].name_change.name, name) == 0); - - return TEST_OK; -} - -int kdbus_test_match_name_change(struct kdbus_test_env *env) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - struct kdbus_notify_name_change chg; - } item; - char name[64]; - } buf; - struct kdbus_conn *conn; - struct kdbus_msg *msg; - uint64_t flags; - char *name = "foo.bla.baz"; - int ret; - - /* acquire the name */ - ret = kdbus_name_acquire(env->conn, name, NULL); - ASSERT_RETURN(ret == 0); - - /* install the match rule */ - memset(&buf, 0, sizeof(buf)); - buf.item.type = KDBUS_ITEM_NAME_CHANGE; - buf.item.chg.old_id.id = KDBUS_MATCH_ID_ANY; - buf.item.chg.new_id.id = KDBUS_MATCH_ID_ANY; - strncpy(buf.name, name, sizeof(buf.name) - 1); - buf.item.size = sizeof(buf.item) + strlen(buf.name) + 1; - buf.cmd.size = sizeof(buf.cmd) + buf.item.size; - - ret = kdbus_cmd_match_add(env->conn->fd, &buf.cmd); - ASSERT_RETURN(ret == 0); - - /* create a 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - /* allow the new connection to own the same name */ - /* queue the 2nd connection as waiting owner */ - flags = KDBUS_NAME_QUEUE; - ret = kdbus_name_acquire(conn, name, &flags); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(flags & KDBUS_NAME_IN_QUEUE); - - /* release name from 1st connection */ - ret = kdbus_name_release(env->conn, name); - ASSERT_RETURN(ret == 0); - - /* we should have received a notification */ - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - - ASSERT_RETURN(msg->items[0].type == KDBUS_ITEM_NAME_CHANGE); - ASSERT_RETURN(msg->items[0].name_change.old_id.id == env->conn->id); - ASSERT_RETURN(msg->items[0].name_change.new_id.id == conn->id); - ASSERT_RETURN(strcmp(msg->items[0].name_change.name, name) == 0); - - kdbus_conn_free(conn); - - return TEST_OK; -} - -static int send_bloom_filter(const struct kdbus_conn *conn, - uint64_t cookie, - const uint8_t *filter, - size_t filter_size, - uint64_t filter_generation) -{ - struct kdbus_cmd_send cmd = {}; - struct kdbus_msg *msg; - struct kdbus_item *item; - uint64_t size; - int ret; - - size = sizeof(struct kdbus_msg); - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter)) + filter_size; - - msg = alloca(size); - - memset(msg, 0, size); - msg->size = size; - msg->src_id = conn->id; - msg->dst_id = KDBUS_DST_ID_BROADCAST; - msg->flags = KDBUS_MSG_SIGNAL; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - msg->cookie = cookie; - - item = msg->items; - item->type = KDBUS_ITEM_BLOOM_FILTER; - item->size = KDBUS_ITEM_SIZE(sizeof(struct kdbus_bloom_filter)) + - filter_size; - - item->bloom_filter.generation = filter_generation; - memcpy(item->bloom_filter.data, filter, filter_size); - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg; - - ret = kdbus_cmd_send(conn->fd, &cmd); - if (ret < 0) { - kdbus_printf("error sending message: %d (%m)\n", ret); - return ret; - } - - return 0; -} - -int kdbus_test_match_bloom(struct kdbus_test_env *env) -{ - struct { - struct kdbus_cmd_match cmd; - struct { - uint64_t size; - uint64_t type; - uint8_t data_gen0[64]; - uint8_t data_gen1[64]; - } item; - } buf; - struct kdbus_conn *conn; - struct kdbus_msg *msg; - uint64_t cookie = 0xf000f00f; - uint8_t filter[64]; - int ret; - - /* install the match rule */ - memset(&buf, 0, sizeof(buf)); - buf.cmd.size = sizeof(buf); - - buf.item.size = sizeof(buf.item); - buf.item.type = KDBUS_ITEM_BLOOM_MASK; - buf.item.data_gen0[0] = 0x55; - buf.item.data_gen0[63] = 0x80; - - buf.item.data_gen1[1] = 0xaa; - buf.item.data_gen1[9] = 0x02; - - ret = kdbus_cmd_match_add(env->conn->fd, &buf.cmd); - ASSERT_RETURN(ret == 0); - - /* create a 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - /* a message with a 0'ed out filter must not reach the other peer */ - memset(filter, 0, sizeof(filter)); - ret = send_bloom_filter(conn, ++cookie, filter, sizeof(filter), 0); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - /* now set the filter to the connection's mask and expect success */ - filter[0] = 0x55; - filter[63] = 0x80; - ret = send_bloom_filter(conn, ++cookie, filter, sizeof(filter), 0); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - /* broaden the filter and try again. this should also succeed. */ - filter[0] = 0xff; - filter[8] = 0xff; - filter[63] = 0xff; - ret = send_bloom_filter(conn, ++cookie, filter, sizeof(filter), 0); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - /* the same filter must not match against bloom generation 1 */ - ret = send_bloom_filter(conn, ++cookie, filter, sizeof(filter), 1); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - /* set a different filter and try again */ - filter[1] = 0xaa; - filter[9] = 0x02; - ret = send_bloom_filter(conn, ++cookie, filter, sizeof(filter), 1); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(env->conn, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - kdbus_conn_free(conn); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-message.c b/tools/testing/selftests/kdbus/test-message.c deleted file mode 100644 index 33d349bb2..000000000 --- a/tools/testing/selftests/kdbus/test-message.c +++ /dev/null @@ -1,736 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <time.h> -#include <stdbool.h> -#include <sys/eventfd.h> -#include <sys/types.h> -#include <sys/wait.h> - -#include "kdbus-api.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -/* maximum number of queued messages from the same individual user */ -#define KDBUS_CONN_MAX_MSGS 256 - -/* maximum number of queued requests waiting for a reply */ -#define KDBUS_CONN_MAX_REQUESTS_PENDING 128 - -/* maximum message payload size */ -#define KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE (2 * 1024UL * 1024UL) - -int kdbus_test_message_basic(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn; - struct kdbus_conn *sender; - struct kdbus_msg *msg; - uint64_t cookie = 0x1234abcd5678eeff; - uint64_t offset; - int ret; - - sender = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(sender != NULL); - - /* create a 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - ret = kdbus_add_match_empty(conn); - ASSERT_RETURN(ret == 0); - - ret = kdbus_add_match_empty(sender); - ASSERT_RETURN(ret == 0); - - /* send over 1st connection */ - ret = kdbus_msg_send(sender, NULL, cookie, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - /* Make sure that we do get our own broadcasts */ - ret = kdbus_msg_recv(sender, &msg, &offset); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - kdbus_msg_free(msg); - - /* ... and receive on the 2nd */ - ret = kdbus_msg_recv_poll(conn, 100, &msg, &offset); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - kdbus_msg_free(msg); - - /* Msgs that expect a reply must have timeout and cookie */ - ret = kdbus_msg_send(sender, NULL, 0, KDBUS_MSG_EXPECT_REPLY, - 0, 0, conn->id); - ASSERT_RETURN(ret == -EINVAL); - - /* Faked replies with a valid reply cookie are rejected */ - ret = kdbus_msg_send_reply(conn, time(NULL) ^ cookie, sender->id); - ASSERT_RETURN(ret == -EBADSLT); - - ret = kdbus_free(conn, offset); - ASSERT_RETURN(ret == 0); - - kdbus_conn_free(sender); - kdbus_conn_free(conn); - - return TEST_OK; -} - -static int msg_recv_prio(struct kdbus_conn *conn, - int64_t requested_prio, - int64_t expected_prio) -{ - struct kdbus_cmd_recv recv = { - .size = sizeof(recv), - .flags = KDBUS_RECV_USE_PRIORITY, - .priority = requested_prio, - }; - struct kdbus_msg *msg; - int ret; - - ret = kdbus_cmd_recv(conn->fd, &recv); - if (ret < 0) { - kdbus_printf("error receiving message: %d (%m)\n", -errno); - return ret; - } - - msg = (struct kdbus_msg *)(conn->buf + recv.msg.offset); - kdbus_msg_dump(conn, msg); - - if (msg->priority != expected_prio) { - kdbus_printf("expected message prio %lld, got %lld\n", - (unsigned long long) expected_prio, - (unsigned long long) msg->priority); - return -EINVAL; - } - - kdbus_msg_free(msg); - ret = kdbus_free(conn, recv.msg.offset); - if (ret < 0) - return ret; - - return 0; -} - -int kdbus_test_message_prio(struct kdbus_test_env *env) -{ - struct kdbus_conn *a, *b; - uint64_t cookie = 0; - - a = kdbus_hello(env->buspath, 0, NULL, 0); - b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(a && b); - - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, 25, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -600, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, 10, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -35, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -100, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, 20, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -15, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -800, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -150, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, 10, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -800, a->id) == 0); - ASSERT_RETURN(kdbus_msg_send(b, NULL, ++cookie, 0, 0, -10, a->id) == 0); - - ASSERT_RETURN(msg_recv_prio(a, -200, -800) == 0); - ASSERT_RETURN(msg_recv_prio(a, -100, -800) == 0); - ASSERT_RETURN(msg_recv_prio(a, -400, -600) == 0); - ASSERT_RETURN(msg_recv_prio(a, -400, -600) == -EAGAIN); - ASSERT_RETURN(msg_recv_prio(a, 10, -150) == 0); - ASSERT_RETURN(msg_recv_prio(a, 10, -100) == 0); - - kdbus_printf("--- get priority (all)\n"); - ASSERT_RETURN(kdbus_msg_recv(a, NULL, NULL) == 0); - - kdbus_conn_free(a); - kdbus_conn_free(b); - - return TEST_OK; -} - -static int kdbus_test_notify_kernel_quota(struct kdbus_test_env *env) -{ - int ret; - unsigned int i; - struct kdbus_conn *conn; - struct kdbus_conn *reader; - struct kdbus_msg *msg = NULL; - struct kdbus_cmd_recv recv = { .size = sizeof(recv) }; - - reader = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(reader); - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - /* Register for ID signals */ - ret = kdbus_add_match_id(reader, 0x1, KDBUS_ITEM_ID_ADD, - KDBUS_MATCH_ID_ANY); - ASSERT_RETURN(ret == 0); - - ret = kdbus_add_match_id(reader, 0x2, KDBUS_ITEM_ID_REMOVE, - KDBUS_MATCH_ID_ANY); - ASSERT_RETURN(ret == 0); - - /* Each iteration two notifications: add and remove ID */ - for (i = 0; i < KDBUS_CONN_MAX_MSGS / 2; i++) { - struct kdbus_conn *notifier; - - notifier = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(notifier); - - kdbus_conn_free(notifier); - } - - /* - * Now the reader queue is full with kernel notfications, - * but as a user we still have room to push our messages. - */ - ret = kdbus_msg_send(conn, NULL, 0xdeadbeef, 0, 0, 0, reader->id); - ASSERT_RETURN(ret == 0); - - /* More ID kernel notifications that will be lost */ - kdbus_conn_free(conn); - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - kdbus_conn_free(conn); - - /* - * We lost only 3 packets since only signal msgs are - * accounted. The connection ID add/remove notification - */ - ret = kdbus_cmd_recv(reader->fd, &recv); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS); - ASSERT_RETURN(recv.dropped_msgs == 3); - - msg = (struct kdbus_msg *)(reader->buf + recv.msg.offset); - kdbus_msg_free(msg); - - /* Read our queue */ - for (i = 0; i < KDBUS_CONN_MAX_MSGS - 1; i++) { - memset(&recv, 0, sizeof(recv)); - recv.size = sizeof(recv); - - ret = kdbus_cmd_recv(reader->fd, &recv); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(!(recv.return_flags & - KDBUS_RECV_RETURN_DROPPED_MSGS)); - - msg = (struct kdbus_msg *)(reader->buf + recv.msg.offset); - kdbus_msg_free(msg); - } - - ret = kdbus_msg_recv(reader, NULL, NULL); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(reader, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - kdbus_conn_free(reader); - - return 0; -} - -/* Return the number of message successfully sent */ -static int kdbus_fill_conn_queue(struct kdbus_conn *conn_src, - uint64_t dst_id, - unsigned int max_msgs) -{ - unsigned int i; - uint64_t cookie = 0; - size_t size; - struct kdbus_cmd_send cmd = {}; - struct kdbus_msg *msg; - int ret; - - size = sizeof(struct kdbus_msg); - msg = malloc(size); - ASSERT_RETURN_VAL(msg, -ENOMEM); - - memset(msg, 0, size); - msg->size = size; - msg->src_id = conn_src->id; - msg->dst_id = dst_id; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg; - - for (i = 0; i < max_msgs; i++) { - msg->cookie = cookie++; - ret = kdbus_cmd_send(conn_src->fd, &cmd); - if (ret < 0) - break; - } - - free(msg); - - return i; -} - -static int kdbus_test_activator_quota(struct kdbus_test_env *env) -{ - int ret; - unsigned int i; - unsigned int activator_msgs_count = 0; - uint64_t cookie = time(NULL); - struct kdbus_conn *conn; - struct kdbus_conn *sender; - struct kdbus_conn *activator; - struct kdbus_msg *msg; - uint64_t flags; - struct kdbus_cmd_recv recv = { .size = sizeof(recv) }; - struct kdbus_policy_access access = { - .type = KDBUS_POLICY_ACCESS_USER, - .id = geteuid(), - .access = KDBUS_POLICY_OWN, - }; - - activator = kdbus_hello_activator(env->buspath, "foo.test.activator", - &access, 1); - ASSERT_RETURN(activator); - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - sender = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn || sender); - - ret = kdbus_list(sender, KDBUS_LIST_NAMES | - KDBUS_LIST_UNIQUE | - KDBUS_LIST_ACTIVATORS | - KDBUS_LIST_QUEUED); - ASSERT_RETURN(ret == 0); - - for (i = 0; i < KDBUS_CONN_MAX_MSGS; i++) { - ret = kdbus_msg_send(sender, "foo.test.activator", - cookie++, 0, 0, 0, - KDBUS_DST_ID_NAME); - if (ret < 0) - break; - activator_msgs_count++; - } - - /* we must have at least sent one message */ - ASSERT_RETURN_VAL(i > 0, -errno); - ASSERT_RETURN(ret == -ENOBUFS); - - /* Good, activator queue is full now */ - - /* ENXIO on direct send (activators can never be addressed by ID) */ - ret = kdbus_msg_send(conn, NULL, cookie++, 0, 0, 0, activator->id); - ASSERT_RETURN(ret == -ENXIO); - - /* can't queue more */ - ret = kdbus_msg_send(conn, "foo.test.activator", cookie++, - 0, 0, 0, KDBUS_DST_ID_NAME); - ASSERT_RETURN(ret == -ENOBUFS); - - /* no match installed, so the broadcast will not inc dropped_msgs */ - ret = kdbus_msg_send(sender, NULL, cookie++, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - /* Check activator queue */ - ret = kdbus_cmd_recv(activator->fd, &recv); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(recv.dropped_msgs == 0); - - activator_msgs_count--; - - msg = (struct kdbus_msg *)(activator->buf + recv.msg.offset); - kdbus_msg_free(msg); - - - /* Stage 1) of test check the pool memory quota */ - - /* Consume the connection pool memory */ - for (i = 0; i < KDBUS_CONN_MAX_MSGS; i++) { - ret = kdbus_msg_send(sender, NULL, - cookie++, 0, 0, 0, conn->id); - if (ret < 0) - break; - } - - /* consume one message, so later at least one can be moved */ - memset(&recv, 0, sizeof(recv)); - recv.size = sizeof(recv); - ret = kdbus_cmd_recv(conn->fd, &recv); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(recv.dropped_msgs == 0); - msg = (struct kdbus_msg *)(conn->buf + recv.msg.offset); - kdbus_msg_free(msg); - - /* Try to acquire the name now */ - flags = KDBUS_NAME_REPLACE_EXISTING; - ret = kdbus_name_acquire(conn, "foo.test.activator", &flags); - ASSERT_RETURN(ret == 0); - - /* try to read messages and see if we have lost some */ - memset(&recv, 0, sizeof(recv)); - recv.size = sizeof(recv); - ret = kdbus_cmd_recv(conn->fd, &recv); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(recv.dropped_msgs != 0); - - /* number of dropped msgs < received ones (at least one was moved) */ - ASSERT_RETURN(recv.dropped_msgs < activator_msgs_count); - - /* Deduct the number of dropped msgs from the activator msgs */ - activator_msgs_count -= recv.dropped_msgs; - - msg = (struct kdbus_msg *)(activator->buf + recv.msg.offset); - kdbus_msg_free(msg); - - /* - * Release the name and hand it back to activator, now - * we should have 'activator_msgs_count' msgs again in - * the activator queue - */ - ret = kdbus_name_release(conn, "foo.test.activator"); - ASSERT_RETURN(ret == 0); - - /* make sure that we got our previous activator msgs */ - ret = kdbus_msg_recv(activator, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->src_id == sender->id); - - activator_msgs_count--; - - kdbus_msg_free(msg); - - - /* Stage 2) of test check max message quota */ - - /* Empty conn queue */ - for (i = 0; i < KDBUS_CONN_MAX_MSGS; i++) { - ret = kdbus_msg_recv(conn, NULL, NULL); - if (ret == -EAGAIN) - break; - } - - /* fill queue with max msgs quota */ - ret = kdbus_fill_conn_queue(sender, conn->id, KDBUS_CONN_MAX_MSGS); - ASSERT_RETURN(ret == KDBUS_CONN_MAX_MSGS); - - /* This one is lost but it is not accounted */ - ret = kdbus_msg_send(sender, NULL, - cookie++, 0, 0, 0, conn->id); - ASSERT_RETURN(ret == -ENOBUFS); - - /* Acquire the name again */ - flags = KDBUS_NAME_REPLACE_EXISTING; - ret = kdbus_name_acquire(conn, "foo.test.activator", &flags); - ASSERT_RETURN(ret == 0); - - memset(&recv, 0, sizeof(recv)); - recv.size = sizeof(recv); - - /* - * Try to read messages and make sure that we have lost all - * the activator messages due to quota checks. Our queue is - * already full. - */ - ret = kdbus_cmd_recv(conn->fd, &recv); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(recv.dropped_msgs == activator_msgs_count); - - msg = (struct kdbus_msg *)(activator->buf + recv.msg.offset); - kdbus_msg_free(msg); - - kdbus_conn_free(sender); - kdbus_conn_free(conn); - kdbus_conn_free(activator); - - return 0; -} - -static int kdbus_test_expected_reply_quota(struct kdbus_test_env *env) -{ - int ret; - unsigned int i, n; - unsigned int count; - uint64_t cookie = 0x1234abcd5678eeff; - struct kdbus_conn *conn; - struct kdbus_conn *connections[9]; - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - for (i = 0; i < 9; i++) { - connections[i] = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(connections[i]); - } - - count = 0; - /* Send 16 messages to 8 different connections */ - for (i = 0; i < 8; i++) { - for (n = 0; n < 16; n++) { - ret = kdbus_msg_send(conn, NULL, cookie++, - KDBUS_MSG_EXPECT_REPLY, - 100000000ULL, 0, - connections[i]->id); - if (ret < 0) - break; - - count++; - } - } - - /* - * We should have queued at least - * KDBUS_CONN_MAX_REQUESTS_PENDING method call - */ - ASSERT_RETURN(count == KDBUS_CONN_MAX_REQUESTS_PENDING); - - /* - * Now try to send a message to the last connection, - * if we have reached KDBUS_CONN_MAX_REQUESTS_PENDING - * no further requests are allowed - */ - ret = kdbus_msg_send(conn, NULL, cookie++, KDBUS_MSG_EXPECT_REPLY, - 1000000000ULL, 0, connections[8]->id); - ASSERT_RETURN(ret == -EMLINK); - - for (i = 0; i < 9; i++) - kdbus_conn_free(connections[i]); - - kdbus_conn_free(conn); - - return 0; -} - -int kdbus_test_pool_quota(struct kdbus_test_env *env) -{ - struct kdbus_conn *a, *b, *c; - struct kdbus_cmd_send cmd = {}; - struct kdbus_item *item; - struct kdbus_msg *recv_msg; - struct kdbus_msg *msg; - uint64_t cookie = time(NULL); - uint64_t size; - unsigned int i; - char *payload; - int ret; - - /* just a guard */ - if (POOL_SIZE <= KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE || - POOL_SIZE % KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE != 0) - return 0; - - payload = calloc(KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE, sizeof(char)); - ASSERT_RETURN_VAL(payload, -ENOMEM); - - a = kdbus_hello(env->buspath, 0, NULL, 0); - b = kdbus_hello(env->buspath, 0, NULL, 0); - c = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(a && b && c); - - size = sizeof(struct kdbus_msg); - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec)); - - msg = malloc(size); - ASSERT_RETURN_VAL(msg, -ENOMEM); - - memset(msg, 0, size); - msg->size = size; - msg->src_id = a->id; - msg->dst_id = c->id; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - - item = msg->items; - item->type = KDBUS_ITEM_PAYLOAD_VEC; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); - item->vec.address = (uintptr_t)payload; - item->vec.size = KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE; - item = KDBUS_ITEM_NEXT(item); - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg; - - /* - * Send 2097248 bytes, a user is only allowed to get 33% of half of - * the free space of the pool, the already used space is - * accounted as free space - */ - size += KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE; - for (i = size; i < (POOL_SIZE / 2 / 3); i += size) { - msg->cookie = cookie++; - - ret = kdbus_cmd_send(a->fd, &cmd); - ASSERT_RETURN_VAL(ret == 0, ret); - } - - /* Try to get more than 33% */ - msg->cookie = cookie++; - ret = kdbus_cmd_send(a->fd, &cmd); - ASSERT_RETURN(ret == -ENOBUFS); - - /* We still can pass small messages */ - ret = kdbus_msg_send(b, NULL, cookie++, 0, 0, 0, c->id); - ASSERT_RETURN(ret == 0); - - for (i = size; i < (POOL_SIZE / 2 / 3); i += size) { - ret = kdbus_msg_recv(c, &recv_msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(recv_msg->src_id == a->id); - - kdbus_msg_free(recv_msg); - } - - ret = kdbus_msg_recv(c, &recv_msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(recv_msg->src_id == b->id); - - kdbus_msg_free(recv_msg); - - ret = kdbus_msg_recv(c, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - free(msg); - free(payload); - - kdbus_conn_free(c); - kdbus_conn_free(b); - kdbus_conn_free(a); - - return 0; -} - -int kdbus_test_message_quota(struct kdbus_test_env *env) -{ - struct kdbus_conn *a, *b; - uint64_t cookie = 0; - int ret; - int i; - - ret = kdbus_test_activator_quota(env); - ASSERT_RETURN(ret == 0); - - ret = kdbus_test_notify_kernel_quota(env); - ASSERT_RETURN(ret == 0); - - ret = kdbus_test_pool_quota(env); - ASSERT_RETURN(ret == 0); - - ret = kdbus_test_expected_reply_quota(env); - ASSERT_RETURN(ret == 0); - - a = kdbus_hello(env->buspath, 0, NULL, 0); - b = kdbus_hello(env->buspath, 0, NULL, 0); - - ret = kdbus_fill_conn_queue(b, a->id, KDBUS_CONN_MAX_MSGS); - ASSERT_RETURN(ret == KDBUS_CONN_MAX_MSGS); - - ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, 0, a->id); - ASSERT_RETURN(ret == -ENOBUFS); - - for (i = 0; i < KDBUS_CONN_MAX_MSGS; ++i) { - ret = kdbus_msg_recv(a, NULL, NULL); - ASSERT_RETURN(ret == 0); - } - - ret = kdbus_msg_recv(a, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - ret = kdbus_fill_conn_queue(b, a->id, KDBUS_CONN_MAX_MSGS + 1); - ASSERT_RETURN(ret == KDBUS_CONN_MAX_MSGS); - - ret = kdbus_msg_send(b, NULL, ++cookie, 0, 0, 0, a->id); - ASSERT_RETURN(ret == -ENOBUFS); - - kdbus_conn_free(a); - kdbus_conn_free(b); - - return TEST_OK; -} - -int kdbus_test_memory_access(struct kdbus_test_env *env) -{ - struct kdbus_conn *a, *b; - struct kdbus_cmd_send cmd = {}; - struct kdbus_item *item; - struct kdbus_msg *msg; - uint64_t test_addr = 0; - char line[256]; - uint64_t size; - FILE *f; - int ret; - - /* - * Search in /proc/kallsyms for the address of a kernel symbol that - * should always be there, regardless of the config. Use that address - * in a PAYLOAD_VEC item and make sure it's inaccessible. - */ - - f = fopen("/proc/kallsyms", "r"); - if (!f) - return TEST_SKIP; - - while (fgets(line, sizeof(line), f)) { - char *s = line; - - if (!strsep(&s, " ")) - continue; - - if (!strsep(&s, " ")) - continue; - - if (!strncmp(s, "mutex_lock", 10)) { - test_addr = strtoull(line, NULL, 16); - break; - } - } - - fclose(f); - - if (!test_addr) - return TEST_SKIP; - - a = kdbus_hello(env->buspath, 0, NULL, 0); - b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(a && b); - - size = sizeof(struct kdbus_msg); - size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec)); - - msg = alloca(size); - ASSERT_RETURN_VAL(msg, -ENOMEM); - - memset(msg, 0, size); - msg->size = size; - msg->src_id = a->id; - msg->dst_id = b->id; - msg->payload_type = KDBUS_PAYLOAD_DBUS; - - item = msg->items; - item->type = KDBUS_ITEM_PAYLOAD_VEC; - item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); - item->vec.address = test_addr; - item->vec.size = sizeof(void*); - item = KDBUS_ITEM_NEXT(item); - - cmd.size = sizeof(cmd); - cmd.msg_address = (uintptr_t)msg; - - ret = kdbus_cmd_send(a->fd, &cmd); - ASSERT_RETURN(ret == -EFAULT); - - kdbus_conn_free(b); - kdbus_conn_free(a); - - return 0; -} diff --git a/tools/testing/selftests/kdbus/test-metadata-ns.c b/tools/testing/selftests/kdbus/test-metadata-ns.c deleted file mode 100644 index 1f6edc090..000000000 --- a/tools/testing/selftests/kdbus/test-metadata-ns.c +++ /dev/null @@ -1,500 +0,0 @@ -/* - * Test metadata in new namespaces. Even if our tests can run - * in a namespaced setup, this test is necessary so we can inspect - * metadata on the same kdbusfs but between multiple namespaces - */ - -#include <stdio.h> -#include <string.h> -#include <sched.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <signal.h> -#include <sys/wait.h> -#include <sys/prctl.h> -#include <sys/eventfd.h> -#include <sys/syscall.h> -#include <sys/capability.h> -#include <linux/sched.h> - -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -static const struct kdbus_creds privileged_creds = {}; - -static const struct kdbus_creds unmapped_creds = { - .uid = UNPRIV_UID, - .euid = UNPRIV_UID, - .suid = UNPRIV_UID, - .fsuid = UNPRIV_UID, - .gid = UNPRIV_GID, - .egid = UNPRIV_GID, - .sgid = UNPRIV_GID, - .fsgid = UNPRIV_GID, -}; - -static const struct kdbus_pids unmapped_pids = {}; - -/* Get only the first item */ -static struct kdbus_item *kdbus_get_item(struct kdbus_msg *msg, - uint64_t type) -{ - struct kdbus_item *item; - - KDBUS_ITEM_FOREACH(item, msg, items) - if (item->type == type) - return item; - - return NULL; -} - -static int kdbus_match_kdbus_creds(struct kdbus_msg *msg, - const struct kdbus_creds *expected_creds) -{ - struct kdbus_item *item; - - item = kdbus_get_item(msg, KDBUS_ITEM_CREDS); - ASSERT_RETURN(item); - - ASSERT_RETURN(memcmp(&item->creds, expected_creds, - sizeof(struct kdbus_creds)) == 0); - - return 0; -} - -static int kdbus_match_kdbus_pids(struct kdbus_msg *msg, - const struct kdbus_pids *expected_pids) -{ - struct kdbus_item *item; - - item = kdbus_get_item(msg, KDBUS_ITEM_PIDS); - ASSERT_RETURN(item); - - ASSERT_RETURN(memcmp(&item->pids, expected_pids, - sizeof(struct kdbus_pids)) == 0); - - return 0; -} - -static int __kdbus_clone_userns_test(const char *bus, - struct kdbus_conn *conn, - uint64_t grandpa_pid, - int signal_fd) -{ - int clone_ret; - int ret; - struct kdbus_msg *msg = NULL; - const struct kdbus_item *item; - uint64_t cookie = time(NULL) ^ 0xdeadbeef; - struct kdbus_conn *unpriv_conn = NULL; - struct kdbus_pids parent_pids = { - .pid = getppid(), - .tid = getppid(), - .ppid = grandpa_pid, - }; - - ret = drop_privileges(UNPRIV_UID, UNPRIV_GID); - ASSERT_EXIT(ret == 0); - - unpriv_conn = kdbus_hello(bus, 0, NULL, 0); - ASSERT_EXIT(unpriv_conn); - - ret = kdbus_add_match_empty(unpriv_conn); - ASSERT_EXIT(ret == 0); - - /* - * ping privileged connection from this new unprivileged - * one - */ - - ret = kdbus_msg_send(unpriv_conn, NULL, cookie, 0, 0, - 0, conn->id); - ASSERT_EXIT(ret == 0); - - /* - * Since we just dropped privileges, the dumpable flag - * was just cleared which makes the /proc/$clone_child/uid_map - * to be owned by root, hence any userns uid mapping will fail - * with -EPERM since the mapping will be done by uid 65534. - * - * To avoid this set the dumpable flag again which makes - * procfs update the /proc/$clone_child/ inodes owner to 65534. - * - * Using this we will be able write to /proc/$clone_child/uid_map - * as uid 65534 and map the uid 65534 to 0 inside the user namespace. - */ - ret = prctl(PR_SET_DUMPABLE, SUID_DUMP_USER); - ASSERT_EXIT(ret == 0); - - /* Make child privileged in its new userns and run tests */ - - ret = RUN_CLONE_CHILD(&clone_ret, - SIGCHLD | CLONE_NEWUSER | CLONE_NEWPID, - ({ 0; /* Clone setup, nothing */ }), - ({ - eventfd_t event_status = 0; - struct kdbus_conn *userns_conn; - - /* ping connection from the new user namespace */ - userns_conn = kdbus_hello(bus, 0, NULL, 0); - ASSERT_EXIT(userns_conn); - - ret = kdbus_add_match_empty(userns_conn); - ASSERT_EXIT(ret == 0); - - cookie++; - ret = kdbus_msg_send(userns_conn, NULL, cookie, - 0, 0, 0, conn->id); - ASSERT_EXIT(ret == 0); - - /* Parent did send */ - ret = eventfd_read(signal_fd, &event_status); - ASSERT_RETURN(ret >= 0 && event_status == 1); - - /* - * Receive from privileged connection - */ - kdbus_printf("Privileged → unprivileged/privileged " - "in its userns " - "(different userns and pidns):\n"); - ret = kdbus_msg_recv_poll(userns_conn, 300, &msg, NULL); - ASSERT_EXIT(ret == 0); - ASSERT_EXIT(msg->dst_id == userns_conn->id); - - item = kdbus_get_item(msg, KDBUS_ITEM_CAPS); - ASSERT_EXIT(item); - - /* uid/gid not mapped, so we have unpriv cached creds */ - ret = kdbus_match_kdbus_creds(msg, &unmapped_creds); - ASSERT_EXIT(ret == 0); - - /* - * Diffent pid namepsaces. This is the child pidns - * so it should not see its parent kdbus_pids - */ - ret = kdbus_match_kdbus_pids(msg, &unmapped_pids); - ASSERT_EXIT(ret == 0); - - kdbus_msg_free(msg); - - - /* - * Receive broadcast from privileged connection - */ - kdbus_printf("Privileged → unprivileged/privileged " - "in its userns " - "(different userns and pidns):\n"); - ret = kdbus_msg_recv_poll(userns_conn, 300, &msg, NULL); - ASSERT_EXIT(ret == 0); - ASSERT_EXIT(msg->dst_id == KDBUS_DST_ID_BROADCAST); - - item = kdbus_get_item(msg, KDBUS_ITEM_CAPS); - ASSERT_EXIT(item); - - /* uid/gid not mapped, so we have unpriv cached creds */ - ret = kdbus_match_kdbus_creds(msg, &unmapped_creds); - ASSERT_EXIT(ret == 0); - - /* - * Diffent pid namepsaces. This is the child pidns - * so it should not see its parent kdbus_pids - */ - ret = kdbus_match_kdbus_pids(msg, &unmapped_pids); - ASSERT_EXIT(ret == 0); - - kdbus_msg_free(msg); - - kdbus_conn_free(userns_conn); - }), - ({ - /* Parent setup map child uid/gid */ - ret = userns_map_uid_gid(pid, "0 65534 1", "0 65534 1"); - ASSERT_EXIT(ret == 0); - }), - ({ 0; })); - /* Unprivileged was not able to create user namespace */ - if (clone_ret == -EPERM) { - kdbus_printf("-- CLONE_NEWUSER TEST Failed for " - "uid: %u\n -- Make sure that your kernel " - "do not allow CLONE_NEWUSER for " - "unprivileged users\n", UNPRIV_UID); - ret = 0; - goto out; - } - - ASSERT_EXIT(ret == 0); - - - /* - * Receive from privileged connection - */ - kdbus_printf("\nPrivileged → unprivileged (same namespaces):\n"); - ret = kdbus_msg_recv_poll(unpriv_conn, 300, &msg, NULL); - - ASSERT_EXIT(ret == 0); - ASSERT_EXIT(msg->dst_id == unpriv_conn->id); - - /* will get the privileged creds */ - ret = kdbus_match_kdbus_creds(msg, &privileged_creds); - ASSERT_EXIT(ret == 0); - - /* Same pidns so will get the kdbus_pids */ - ret = kdbus_match_kdbus_pids(msg, &parent_pids); - ASSERT_RETURN(ret == 0); - - kdbus_msg_free(msg); - - - /* - * Receive broadcast from privileged connection - */ - kdbus_printf("\nPrivileged → unprivileged (same namespaces):\n"); - ret = kdbus_msg_recv_poll(unpriv_conn, 300, &msg, NULL); - - ASSERT_EXIT(ret == 0); - ASSERT_EXIT(msg->dst_id == KDBUS_DST_ID_BROADCAST); - - /* will get the privileged creds */ - ret = kdbus_match_kdbus_creds(msg, &privileged_creds); - ASSERT_EXIT(ret == 0); - - ret = kdbus_match_kdbus_pids(msg, &parent_pids); - ASSERT_RETURN(ret == 0); - - kdbus_msg_free(msg); - -out: - kdbus_conn_free(unpriv_conn); - - return ret; -} - -static int kdbus_clone_userns_test(const char *bus, - struct kdbus_conn *conn) -{ - int ret, status, efd; - pid_t pid, ppid; - uint64_t unpriv_conn_id, userns_conn_id; - struct kdbus_msg *msg; - const struct kdbus_item *item; - struct kdbus_pids expected_pids; - struct kdbus_conn *monitor; - - kdbus_printf("STARTING TEST 'metadata-ns'.\n"); - - monitor = kdbus_hello(bus, KDBUS_HELLO_MONITOR, NULL, 0); - ASSERT_EXIT(monitor); - - /* - * parent will signal to child that is in its - * userns to read its queue - */ - efd = eventfd(0, EFD_CLOEXEC); - ASSERT_RETURN_VAL(efd >= 0, efd); - - ppid = getppid(); - - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, -errno); - - if (pid == 0) { - ret = prctl(PR_SET_PDEATHSIG, SIGKILL); - ASSERT_EXIT_VAL(ret == 0, -errno); - - ret = __kdbus_clone_userns_test(bus, conn, ppid, efd); - _exit(ret); - } - - - /* Phase 1) privileged receives from unprivileged */ - - /* - * Receive from the unprivileged child - */ - kdbus_printf("\nUnprivileged → privileged (same namespaces):\n"); - ret = kdbus_msg_recv_poll(conn, 300, &msg, NULL); - ASSERT_RETURN(ret == 0); - - unpriv_conn_id = msg->src_id; - - /* Unprivileged user */ - ret = kdbus_match_kdbus_creds(msg, &unmapped_creds); - ASSERT_RETURN(ret == 0); - - /* Set the expected creds_pids */ - expected_pids = (struct kdbus_pids) { - .pid = pid, - .tid = pid, - .ppid = getpid(), - }; - ret = kdbus_match_kdbus_pids(msg, &expected_pids); - ASSERT_RETURN(ret == 0); - - kdbus_msg_free(msg); - - - /* - * Receive from the unprivileged that is in his own - * userns and pidns - */ - - kdbus_printf("\nUnprivileged/privileged in its userns → privileged " - "(different userns and pidns)\n"); - ret = kdbus_msg_recv_poll(conn, 300, &msg, NULL); - if (ret == -ETIMEDOUT) - /* perhaps unprivileged userns is not allowed */ - goto wait; - - ASSERT_RETURN(ret == 0); - - userns_conn_id = msg->src_id; - - item = kdbus_get_item(msg, KDBUS_ITEM_CAPS); - ASSERT_RETURN(item); - - /* - * Compare received items, creds must be translated into - * the receiver user namespace, so the user is unprivileged - */ - ret = kdbus_match_kdbus_creds(msg, &unmapped_creds); - ASSERT_RETURN(ret == 0); - - /* - * We should have the kdbus_pids since we are the parent - * pidns - */ - item = kdbus_get_item(msg, KDBUS_ITEM_PIDS); - ASSERT_RETURN(item); - - ASSERT_RETURN(memcmp(&item->pids, &unmapped_pids, - sizeof(struct kdbus_pids)) != 0); - - /* - * Parent pid of the unprivileged/privileged in its userns - * is the unprivileged child pid that was forked here. - */ - ASSERT_RETURN((uint64_t)pid == item->pids.ppid); - - kdbus_msg_free(msg); - - - /* Phase 2) Privileged connection sends now 3 packets */ - - /* - * Sending to unprivileged connections a unicast - */ - ret = kdbus_msg_send(conn, NULL, 0xdeadbeef, 0, 0, - 0, unpriv_conn_id); - ASSERT_RETURN(ret == 0); - - /* signal to child that is in its userns */ - ret = eventfd_write(efd, 1); - ASSERT_EXIT(ret == 0); - - /* - * Sending to unprivileged/privilged in its userns - * connections a unicast - */ - ret = kdbus_msg_send(conn, NULL, 0xdeadbeef, 0, 0, - 0, userns_conn_id); - ASSERT_RETURN(ret == 0); - - /* - * Sending to unprivileged connections a broadcast - */ - ret = kdbus_msg_send(conn, NULL, 0xdeadbeef, 0, 0, - 0, KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - -wait: - ret = waitpid(pid, &status, 0); - ASSERT_RETURN(ret >= 0); - - ASSERT_RETURN(WIFEXITED(status)) - ASSERT_RETURN(!WEXITSTATUS(status)); - - /* Dump monitor queue */ - kdbus_printf("\n\nMonitor queue:\n"); - for (;;) { - ret = kdbus_msg_recv_poll(monitor, 100, &msg, NULL); - if (ret < 0) - break; - - if (msg->payload_type == KDBUS_PAYLOAD_DBUS) { - /* - * Parent pidns should see all the - * pids - */ - item = kdbus_get_item(msg, KDBUS_ITEM_PIDS); - ASSERT_RETURN(item); - - ASSERT_RETURN(item->pids.pid != 0 && - item->pids.tid != 0 && - item->pids.ppid != 0); - } - - kdbus_msg_free(msg); - } - - kdbus_conn_free(monitor); - close(efd); - - return 0; -} - -int kdbus_test_metadata_ns(struct kdbus_test_env *env) -{ - int ret; - struct kdbus_conn *holder, *conn; - struct kdbus_policy_access policy_access = { - /* Allow world so we can inspect metadata in namespace */ - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = geteuid(), - .access = KDBUS_POLICY_TALK, - }; - - /* - * We require user-namespaces and all uids/gids - * should be mapped (we can just require the necessary ones) - */ - if (!config_user_ns_is_enabled() || - !all_uids_gids_are_mapped()) - return TEST_SKIP; - - ret = test_is_capable(CAP_SETUID, CAP_SETGID, CAP_SYS_ADMIN, -1); - ASSERT_RETURN(ret >= 0); - - /* no enough privileges, SKIP test */ - if (!ret) - return TEST_SKIP; - - holder = kdbus_hello_registrar(env->buspath, "com.example.metadata", - &policy_access, 1, - KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(holder); - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - ret = kdbus_add_match_empty(conn); - ASSERT_RETURN(ret == 0); - - ret = kdbus_name_acquire(conn, "com.example.metadata", NULL); - ASSERT_EXIT(ret >= 0); - - ret = kdbus_clone_userns_test(env->buspath, conn); - ASSERT_RETURN(ret == 0); - - kdbus_conn_free(holder); - kdbus_conn_free(conn); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-monitor.c b/tools/testing/selftests/kdbus/test-monitor.c deleted file mode 100644 index e00d738a3..000000000 --- a/tools/testing/selftests/kdbus/test-monitor.c +++ /dev/null @@ -1,176 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <stdbool.h> -#include <errno.h> -#include <assert.h> -#include <signal.h> -#include <sys/time.h> -#include <sys/mman.h> -#include <sys/capability.h> -#include <sys/wait.h> - -#include "kdbus-util.h" -#include "kdbus-enum.h" - -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -int kdbus_test_monitor(struct kdbus_test_env *env) -{ - struct kdbus_conn *monitor, *conn; - unsigned int cookie = 0xdeadbeef; - struct kdbus_msg *msg; - uint64_t offset = 0; - int ret; - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - /* add matches to make sure the monitor do not trigger an item add or - * remove on connect and disconnect, respectively. - */ - ret = kdbus_add_match_id(conn, 0x1, KDBUS_ITEM_ID_ADD, - KDBUS_MATCH_ID_ANY); - ASSERT_RETURN(ret == 0); - - ret = kdbus_add_match_id(conn, 0x2, KDBUS_ITEM_ID_REMOVE, - KDBUS_MATCH_ID_ANY); - ASSERT_RETURN(ret == 0); - - /* register a monitor */ - monitor = kdbus_hello(env->buspath, KDBUS_HELLO_MONITOR, NULL, 0); - ASSERT_RETURN(monitor); - - /* make sure we did not receive a monitor connect notification */ - ret = kdbus_msg_recv(conn, &msg, &offset); - ASSERT_RETURN(ret == -EAGAIN); - - /* check that a monitor cannot acquire a name */ - ret = kdbus_name_acquire(monitor, "foo.bar.baz", NULL); - ASSERT_RETURN(ret == -EOPNOTSUPP); - - ret = kdbus_msg_send(env->conn, NULL, cookie, 0, 0, 0, conn->id); - ASSERT_RETURN(ret == 0); - - /* the recipient should have gotten the message */ - ret = kdbus_msg_recv(conn, &msg, &offset); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - kdbus_msg_free(msg); - kdbus_free(conn, offset); - - /* and so should the monitor */ - ret = kdbus_msg_recv(monitor, &msg, &offset); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - kdbus_msg_free(msg); - kdbus_free(monitor, offset); - - /* Installing matches for monitors must fais must fail */ - ret = kdbus_add_match_empty(monitor); - ASSERT_RETURN(ret == -EOPNOTSUPP); - - cookie++; - ret = kdbus_msg_send(env->conn, NULL, cookie, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - /* The monitor should get the message. */ - ret = kdbus_msg_recv_poll(monitor, 100, &msg, &offset); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - kdbus_msg_free(msg); - kdbus_free(monitor, offset); - - /* - * Since we are the only monitor, update the attach flags - * and tell we are not interessted in attach flags recv - */ - - ret = kdbus_conn_update_attach_flags(monitor, - _KDBUS_ATTACH_ALL, - 0); - ASSERT_RETURN(ret == 0); - - cookie++; - ret = kdbus_msg_send(env->conn, NULL, cookie, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv_poll(monitor, 100, &msg, &offset); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - ret = kdbus_item_in_message(msg, KDBUS_ITEM_TIMESTAMP); - ASSERT_RETURN(ret == 0); - - kdbus_msg_free(msg); - kdbus_free(monitor, offset); - - /* - * Now we are interested in KDBUS_ITEM_TIMESTAMP and - * KDBUS_ITEM_CREDS - */ - ret = kdbus_conn_update_attach_flags(monitor, - _KDBUS_ATTACH_ALL, - KDBUS_ATTACH_TIMESTAMP | - KDBUS_ATTACH_CREDS); - ASSERT_RETURN(ret == 0); - - cookie++; - ret = kdbus_msg_send(env->conn, NULL, cookie, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv_poll(monitor, 100, &msg, &offset); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == cookie); - - ret = kdbus_item_in_message(msg, KDBUS_ITEM_TIMESTAMP); - ASSERT_RETURN(ret == 1); - - ret = kdbus_item_in_message(msg, KDBUS_ITEM_CREDS); - ASSERT_RETURN(ret == 1); - - /* the KDBUS_ITEM_PID_COMM was not requested */ - ret = kdbus_item_in_message(msg, KDBUS_ITEM_PID_COMM); - ASSERT_RETURN(ret == 0); - - kdbus_msg_free(msg); - kdbus_free(monitor, offset); - - kdbus_conn_free(monitor); - /* make sure we did not receive a monitor disconnect notification */ - ret = kdbus_msg_recv(conn, &msg, &offset); - ASSERT_RETURN(ret == -EAGAIN); - - kdbus_conn_free(conn); - - /* Make sure that monitor as unprivileged is not allowed */ - ret = test_is_capable(CAP_SETUID, CAP_SETGID, -1); - ASSERT_RETURN(ret >= 0); - - if (ret && all_uids_gids_are_mapped()) { - ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_UID, ({ - monitor = kdbus_hello(env->buspath, - KDBUS_HELLO_MONITOR, - NULL, 0); - ASSERT_EXIT(!monitor && errno == EPERM); - - _exit(EXIT_SUCCESS); - }), - ({ 0; })); - ASSERT_RETURN(ret == 0); - } - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-names.c b/tools/testing/selftests/kdbus/test-names.c deleted file mode 100644 index e400dc86a..000000000 --- a/tools/testing/selftests/kdbus/test-names.c +++ /dev/null @@ -1,272 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <limits.h> -#include <getopt.h> -#include <stdbool.h> - -#include "kdbus-api.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" -#include "kdbus-test.h" - -struct test_name { - const char *name; - __u64 owner_id; - __u64 flags; -}; - -static bool conn_test_names(const struct kdbus_conn *conn, - const struct test_name *tests, - unsigned int n_tests) -{ - struct kdbus_cmd_list cmd_list = {}; - struct kdbus_info *name, *list; - unsigned int i; - int ret; - - cmd_list.size = sizeof(cmd_list); - cmd_list.flags = KDBUS_LIST_NAMES | - KDBUS_LIST_ACTIVATORS | - KDBUS_LIST_QUEUED; - - ret = kdbus_cmd_list(conn->fd, &cmd_list); - ASSERT_RETURN(ret == 0); - - list = (struct kdbus_info *)(conn->buf + cmd_list.offset); - - for (i = 0; i < n_tests; i++) { - const struct test_name *t = tests + i; - bool found = false; - - KDBUS_FOREACH(name, list, cmd_list.list_size) { - struct kdbus_item *item; - - KDBUS_ITEM_FOREACH(item, name, items) { - if (item->type != KDBUS_ITEM_OWNED_NAME || - strcmp(item->name.name, t->name) != 0) - continue; - - if (t->owner_id == name->id && - t->flags == item->name.flags) { - found = true; - break; - } - } - } - - if (!found) - return false; - } - - return true; -} - -static bool conn_is_name_primary_owner(const struct kdbus_conn *conn, - const char *needle) -{ - struct test_name t = { - .name = needle, - .owner_id = conn->id, - .flags = KDBUS_NAME_PRIMARY, - }; - - return conn_test_names(conn, &t, 1); -} - -int kdbus_test_name_basic(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn; - char *name, *dot_name, *invalid_name, *wildcard_name; - int ret; - - name = "foo.bla.blaz"; - dot_name = ".bla.blaz"; - invalid_name = "foo"; - wildcard_name = "foo.bla.bl.*"; - - /* create a 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - /* acquire name "foo.bar.xxx" name */ - ret = kdbus_name_acquire(conn, "foo.bar.xxx", NULL); - ASSERT_RETURN(ret == 0); - - /* Name is not valid, must fail */ - ret = kdbus_name_acquire(env->conn, dot_name, NULL); - ASSERT_RETURN(ret == -EINVAL); - - ret = kdbus_name_acquire(env->conn, invalid_name, NULL); - ASSERT_RETURN(ret == -EINVAL); - - ret = kdbus_name_acquire(env->conn, wildcard_name, NULL); - ASSERT_RETURN(ret == -EINVAL); - - /* check that we can acquire a name */ - ret = kdbus_name_acquire(env->conn, name, NULL); - ASSERT_RETURN(ret == 0); - - ret = conn_is_name_primary_owner(env->conn, name); - ASSERT_RETURN(ret == true); - - /* ... and release it again */ - ret = kdbus_name_release(env->conn, name); - ASSERT_RETURN(ret == 0); - - ret = conn_is_name_primary_owner(env->conn, name); - ASSERT_RETURN(ret == false); - - /* check that we can't release it again */ - ret = kdbus_name_release(env->conn, name); - ASSERT_RETURN(ret == -ESRCH); - - /* check that we can't release a name that we don't own */ - ret = kdbus_name_release(env->conn, "foo.bar.xxx"); - ASSERT_RETURN(ret == -EADDRINUSE); - - /* Name is not valid, must fail */ - ret = kdbus_name_release(env->conn, dot_name); - ASSERT_RETURN(ret == -ESRCH); - - ret = kdbus_name_release(env->conn, invalid_name); - ASSERT_RETURN(ret == -ESRCH); - - ret = kdbus_name_release(env->conn, wildcard_name); - ASSERT_RETURN(ret == -ESRCH); - - kdbus_conn_free(conn); - - return TEST_OK; -} - -int kdbus_test_name_conflict(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn; - char *name; - int ret; - - name = "foo.bla.blaz"; - - /* create a 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - /* allow the new connection to own the same name */ - /* acquire name from the 1st connection */ - ret = kdbus_name_acquire(env->conn, name, NULL); - ASSERT_RETURN(ret == 0); - - ret = conn_is_name_primary_owner(env->conn, name); - ASSERT_RETURN(ret == true); - - /* check that we also can't acquire it again from the 2nd connection */ - ret = kdbus_name_acquire(conn, name, NULL); - ASSERT_RETURN(ret == -EEXIST); - - kdbus_conn_free(conn); - - return TEST_OK; -} - -int kdbus_test_name_queue(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn; - struct test_name t[2]; - const char *name; - uint64_t flags; - int ret; - - name = "foo.bla.blaz"; - - flags = 0; - - /* create a 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - /* allow the new connection to own the same name */ - /* acquire name from the 1st connection */ - ret = kdbus_name_acquire(env->conn, name, &flags); - ASSERT_RETURN(ret == 0); - - ret = conn_is_name_primary_owner(env->conn, name); - ASSERT_RETURN(ret == true); - - /* queue the 2nd connection as waiting owner */ - flags = KDBUS_NAME_QUEUE; - ret = kdbus_name_acquire(conn, name, &flags); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(flags & KDBUS_NAME_IN_QUEUE); - - t[0].name = name; - t[0].owner_id = env->conn->id; - t[0].flags = KDBUS_NAME_PRIMARY; - t[1].name = name; - t[1].owner_id = conn->id; - t[1].flags = KDBUS_NAME_QUEUE | KDBUS_NAME_IN_QUEUE; - ret = conn_test_names(conn, t, 2); - ASSERT_RETURN(ret == true); - - /* release name from 1st connection */ - ret = kdbus_name_release(env->conn, name); - ASSERT_RETURN(ret == 0); - - /* now the name should be owned by the 2nd connection */ - t[0].name = name; - t[0].owner_id = conn->id; - t[0].flags = KDBUS_NAME_PRIMARY | KDBUS_NAME_QUEUE; - ret = conn_test_names(conn, t, 1); - ASSERT_RETURN(ret == true); - - kdbus_conn_free(conn); - - return TEST_OK; -} - -int kdbus_test_name_takeover(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn; - struct test_name t; - const char *name; - uint64_t flags; - int ret; - - name = "foo.bla.blaz"; - - flags = KDBUS_NAME_ALLOW_REPLACEMENT; - - /* create a 2nd connection */ - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn != NULL); - - /* acquire name for 1st connection */ - ret = kdbus_name_acquire(env->conn, name, &flags); - ASSERT_RETURN(ret == 0); - - t.name = name; - t.owner_id = env->conn->id; - t.flags = KDBUS_NAME_ALLOW_REPLACEMENT | KDBUS_NAME_PRIMARY; - ret = conn_test_names(conn, &t, 1); - ASSERT_RETURN(ret == true); - - /* now steal name with 2nd connection */ - flags = KDBUS_NAME_REPLACE_EXISTING; - ret = kdbus_name_acquire(conn, name, &flags); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(flags & KDBUS_NAME_ACQUIRED); - - ret = conn_is_name_primary_owner(conn, name); - ASSERT_RETURN(ret == true); - - kdbus_conn_free(conn); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-policy-ns.c b/tools/testing/selftests/kdbus/test-policy-ns.c deleted file mode 100644 index 3437012f9..000000000 --- a/tools/testing/selftests/kdbus/test-policy-ns.c +++ /dev/null @@ -1,632 +0,0 @@ -/* - * Test metadata and policies in new namespaces. Even if our tests - * can run in a namespaced setup, this test is necessary so we can - * inspect policies on the same kdbusfs but between multiple - * namespaces. - * - * Copyright (C) 2014-2015 Djalal Harouni - * - * kdbus is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation; either version 2.1 of the License, or (at - * your option) any later version. - */ - -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <pthread.h> -#include <sched.h> -#include <stdlib.h> -#include <stddef.h> -#include <stdint.h> -#include <stdbool.h> -#include <unistd.h> -#include <errno.h> -#include <signal.h> -#include <sys/wait.h> -#include <sys/prctl.h> -#include <sys/eventfd.h> -#include <sys/syscall.h> -#include <sys/capability.h> -#include <linux/sched.h> - -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -#define MAX_CONN 64 -#define POLICY_NAME "foo.test.policy-test" - -#define KDBUS_CONN_MAX_MSGS_PER_USER 16 - -/** - * Note: this test can be used to inspect policy_db->talk_access_hash - * - * The purpose of these tests: - * 1) Check KDBUS_POLICY_TALK - * 2) Check the cache state: kdbus_policy_db->talk_access_hash - * Should be extended - */ - -/** - * Check a list of connections against conn_db[0] - * conn_db[0] will own the name "foo.test.policy-test" and the - * policy holder connection for this name will update the policy - * entries, so different use cases can be tested. - */ -static struct kdbus_conn **conn_db; - -static void *kdbus_recv_echo(void *ptr) -{ - int ret; - struct kdbus_conn *conn = ptr; - - ret = kdbus_msg_recv_poll(conn, 200, NULL, NULL); - - return (void *)(long)ret; -} - -/* Trigger kdbus_policy_set() */ -static int kdbus_set_policy_talk(struct kdbus_conn *conn, - const char *name, - uid_t id, unsigned int type) -{ - int ret; - struct kdbus_policy_access access = { - .type = type, - .id = id, - .access = KDBUS_POLICY_TALK, - }; - - ret = kdbus_conn_update_policy(conn, name, &access, 1); - ASSERT_RETURN(ret == 0); - - return TEST_OK; -} - -/* return TEST_OK or TEST_ERR on failure */ -static int kdbus_register_same_activator(char *bus, const char *name, - struct kdbus_conn **c) -{ - int ret; - struct kdbus_conn *activator; - - activator = kdbus_hello_activator(bus, name, NULL, 0); - if (activator) { - *c = activator; - fprintf(stderr, "--- error was able to register name twice '%s'.\n", - name); - return TEST_ERR; - } - - ret = -errno; - /* -EEXIST means test succeeded */ - if (ret == -EEXIST) - return TEST_OK; - - return TEST_ERR; -} - -/* return TEST_OK or TEST_ERR on failure */ -static int kdbus_register_policy_holder(char *bus, const char *name, - struct kdbus_conn **conn) -{ - struct kdbus_conn *c; - struct kdbus_policy_access access[2]; - - access[0].type = KDBUS_POLICY_ACCESS_USER; - access[0].access = KDBUS_POLICY_OWN; - access[0].id = geteuid(); - - access[1].type = KDBUS_POLICY_ACCESS_WORLD; - access[1].access = KDBUS_POLICY_TALK; - access[1].id = geteuid(); - - c = kdbus_hello_registrar(bus, name, access, 2, - KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(c); - - *conn = c; - - return TEST_OK; -} - -/** - * Create new threads for receiving from multiple senders, - * The 'conn_db' will be populated by newly created connections. - * Caller should free all allocated connections. - * - * return 0 on success, negative errno on failure. - */ -static int kdbus_recv_in_threads(const char *bus, const char *name, - struct kdbus_conn **conn_db) -{ - int ret; - bool pool_full = false; - unsigned int sent_packets = 0; - unsigned int lost_packets = 0; - unsigned int i, tid; - unsigned long dst_id; - unsigned long cookie = 1; - unsigned int thread_nr = MAX_CONN - 1; - pthread_t thread_id[MAX_CONN - 1] = {'\0'}; - - dst_id = name ? KDBUS_DST_ID_NAME : conn_db[0]->id; - - for (tid = 0, i = 1; tid < thread_nr; tid++, i++) { - ret = pthread_create(&thread_id[tid], NULL, - kdbus_recv_echo, (void *)conn_db[0]); - if (ret < 0) { - ret = -errno; - kdbus_printf("error pthread_create: %d (%m)\n", - ret); - break; - } - - /* just free before re-using */ - kdbus_conn_free(conn_db[i]); - conn_db[i] = NULL; - - /* We need to create connections here */ - conn_db[i] = kdbus_hello(bus, 0, NULL, 0); - if (!conn_db[i]) { - ret = -errno; - break; - } - - ret = kdbus_add_match_empty(conn_db[i]); - if (ret < 0) - break; - - ret = kdbus_msg_send(conn_db[i], name, cookie++, - 0, 0, 0, dst_id); - if (ret < 0) { - /* - * Receivers are not reading their messages, - * not scheduled ?! - * - * So set the pool full here, perhaps the - * connection pool or queue was full, later - * recheck receivers errors - */ - if (ret == -ENOBUFS || ret == -EXFULL) - pool_full = true; - break; - } - - sent_packets++; - } - - for (tid = 0; tid < thread_nr; tid++) { - int thread_ret = 0; - - if (thread_id[tid]) { - pthread_join(thread_id[tid], (void *)&thread_ret); - if (thread_ret < 0) { - /* Update only if send did not fail */ - if (ret == 0) - ret = thread_ret; - - lost_packets++; - } - } - } - - /* - * When sending if we did fail with -ENOBUFS or -EXFULL - * then we should have set lost_packet and we should at - * least have sent_packets set to KDBUS_CONN_MAX_MSGS_PER_USER - */ - if (pool_full) { - ASSERT_RETURN(lost_packets > 0); - - /* - * We should at least send KDBUS_CONN_MAX_MSGS_PER_USER - * - * For every send operation we create a thread to - * recv the packet, so we keep the queue clean - */ - ASSERT_RETURN(sent_packets >= KDBUS_CONN_MAX_MSGS_PER_USER); - - /* - * Set ret to zero since we only failed due to - * the receiving threads that have not been - * scheduled - */ - ret = 0; - } - - return ret; -} - -/* Return: TEST_OK or TEST_ERR on failure */ -static int kdbus_normal_test(const char *bus, const char *name, - struct kdbus_conn **conn_db) -{ - int ret; - - ret = kdbus_recv_in_threads(bus, name, conn_db); - ASSERT_RETURN(ret >= 0); - - return TEST_OK; -} - -static int kdbus_fork_test_by_id(const char *bus, - struct kdbus_conn **conn_db, - int parent_status, int child_status) -{ - int ret; - pid_t pid; - uint64_t cookie = 0x9876ecba; - struct kdbus_msg *msg = NULL; - uint64_t offset = 0; - int status = 0; - - /* - * If the child_status is not EXIT_SUCCESS, then we expect - * that sending from the child will fail, thus receiving - * from parent must error with -ETIMEDOUT, and vice versa. - */ - bool parent_timedout = !!child_status; - bool child_timedout = !!parent_status; - - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, pid); - - if (pid == 0) { - struct kdbus_conn *conn_src; - - ret = prctl(PR_SET_PDEATHSIG, SIGKILL); - ASSERT_EXIT(ret == 0); - - ret = drop_privileges(65534, 65534); - ASSERT_EXIT(ret == 0); - - conn_src = kdbus_hello(bus, 0, NULL, 0); - ASSERT_EXIT(conn_src); - - ret = kdbus_add_match_empty(conn_src); - ASSERT_EXIT(ret == 0); - - /* - * child_status is always checked against send - * operations, in case it fails always return - * EXIT_FAILURE. - */ - ret = kdbus_msg_send(conn_src, NULL, cookie, - 0, 0, 0, conn_db[0]->id); - ASSERT_EXIT(ret == child_status); - - ret = kdbus_msg_recv_poll(conn_src, 100, NULL, NULL); - - kdbus_conn_free(conn_src); - - /* - * Child kdbus_msg_recv_poll() should timeout since - * the parent_status was set to a non EXIT_SUCCESS - * value. - */ - if (child_timedout) - _exit(ret == -ETIMEDOUT ? EXIT_SUCCESS : EXIT_FAILURE); - - _exit(ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE); - } - - ret = kdbus_msg_recv_poll(conn_db[0], 100, &msg, &offset); - /* - * If parent_timedout is set then this should fail with - * -ETIMEDOUT since the child_status was set to a non - * EXIT_SUCCESS value. Otherwise, assume - * that kdbus_msg_recv_poll() has succeeded. - */ - if (parent_timedout) { - ASSERT_RETURN_VAL(ret == -ETIMEDOUT, TEST_ERR); - - /* timedout no need to continue, we don't have the - * child connection ID, so just terminate. */ - goto out; - } else { - ASSERT_RETURN_VAL(ret == 0, ret); - } - - ret = kdbus_msg_send(conn_db[0], NULL, ++cookie, - 0, 0, 0, msg->src_id); - /* - * parent_status is checked against send operations, - * on failures always return TEST_ERR. - */ - ASSERT_RETURN_VAL(ret == parent_status, TEST_ERR); - - kdbus_msg_free(msg); - kdbus_free(conn_db[0], offset); - -out: - ret = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(ret >= 0, ret); - - return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR; -} - -/* - * Return: TEST_OK, TEST_ERR or TEST_SKIP - * we return TEST_OK only if the children return with the expected - * 'expected_status' that is specified as an argument. - */ -static int kdbus_fork_test(const char *bus, const char *name, - struct kdbus_conn **conn_db, int expected_status) -{ - pid_t pid; - int ret = 0; - int status = 0; - - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, pid); - - if (pid == 0) { - ret = prctl(PR_SET_PDEATHSIG, SIGKILL); - ASSERT_EXIT(ret == 0); - - ret = drop_privileges(65534, 65534); - ASSERT_EXIT(ret == 0); - - ret = kdbus_recv_in_threads(bus, name, conn_db); - _exit(ret == expected_status ? EXIT_SUCCESS : EXIT_FAILURE); - } - - ret = waitpid(pid, &status, 0); - ASSERT_RETURN(ret >= 0); - - return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR; -} - -/* Return EXIT_SUCCESS, EXIT_FAILURE or negative errno */ -static int __kdbus_clone_userns_test(const char *bus, - const char *name, - struct kdbus_conn **conn_db, - int expected_status) -{ - int efd; - pid_t pid; - int ret = 0; - unsigned int uid = 65534; - int status; - - ret = drop_privileges(uid, uid); - ASSERT_RETURN_VAL(ret == 0, ret); - - /* - * Since we just dropped privileges, the dumpable flag was just - * cleared which makes the /proc/$clone_child/uid_map to be - * owned by root, hence any userns uid mapping will fail with - * -EPERM since the mapping will be done by uid 65534. - * - * To avoid this set the dumpable flag again which makes procfs - * update the /proc/$clone_child/ inodes owner to 65534. - * - * Using this we will be able write to /proc/$clone_child/uid_map - * as uid 65534 and map the uid 65534 to 0 inside the user - * namespace. - */ - ret = prctl(PR_SET_DUMPABLE, SUID_DUMP_USER); - ASSERT_RETURN_VAL(ret == 0, ret); - - /* sync parent/child */ - efd = eventfd(0, EFD_CLOEXEC); - ASSERT_RETURN_VAL(efd >= 0, efd); - - pid = syscall(__NR_clone, SIGCHLD|CLONE_NEWUSER, NULL); - if (pid < 0) { - ret = -errno; - kdbus_printf("error clone: %d (%m)\n", ret); - /* - * Normal user not allowed to create userns, - * so nothing to worry about ? - */ - if (ret == -EPERM) { - kdbus_printf("-- CLONE_NEWUSER TEST Failed for uid: %u\n" - "-- Make sure that your kernel do not allow " - "CLONE_NEWUSER for unprivileged users\n" - "-- Upstream Commit: " - "https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=5eaf563e\n", - uid); - ret = 0; - } - - return ret; - } - - if (pid == 0) { - struct kdbus_conn *conn_src; - eventfd_t event_status = 0; - - ret = prctl(PR_SET_PDEATHSIG, SIGKILL); - ASSERT_EXIT(ret == 0); - - ret = eventfd_read(efd, &event_status); - ASSERT_EXIT(ret >= 0 && event_status == 1); - - /* ping connection from the new user namespace */ - conn_src = kdbus_hello(bus, 0, NULL, 0); - ASSERT_EXIT(conn_src); - - ret = kdbus_add_match_empty(conn_src); - ASSERT_EXIT(ret == 0); - - ret = kdbus_msg_send(conn_src, name, 0xabcd1234, - 0, 0, 0, KDBUS_DST_ID_NAME); - kdbus_conn_free(conn_src); - - _exit(ret == expected_status ? EXIT_SUCCESS : EXIT_FAILURE); - } - - ret = userns_map_uid_gid(pid, "0 65534 1", "0 65534 1"); - ASSERT_RETURN_VAL(ret == 0, ret); - - /* Tell child we are ready */ - ret = eventfd_write(efd, 1); - ASSERT_RETURN_VAL(ret == 0, ret); - - ret = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(ret >= 0, ret); - - close(efd); - - return status == EXIT_SUCCESS ? TEST_OK : TEST_ERR; -} - -static int kdbus_clone_userns_test(const char *bus, - const char *name, - struct kdbus_conn **conn_db, - int expected_status) -{ - pid_t pid; - int ret = 0; - int status; - - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, -errno); - - if (pid == 0) { - ret = prctl(PR_SET_PDEATHSIG, SIGKILL); - if (ret < 0) - _exit(EXIT_FAILURE); - - ret = __kdbus_clone_userns_test(bus, name, conn_db, - expected_status); - _exit(ret); - } - - /* - * Receive in the original (root privileged) user namespace, - * must fail with -ETIMEDOUT. - */ - ret = kdbus_msg_recv_poll(conn_db[0], 100, NULL, NULL); - ASSERT_RETURN_VAL(ret == -ETIMEDOUT, ret); - - ret = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(ret >= 0, ret); - - return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR; -} - -int kdbus_test_policy_ns(struct kdbus_test_env *env) -{ - int i; - int ret; - struct kdbus_conn *activator = NULL; - struct kdbus_conn *policy_holder = NULL; - char *bus = env->buspath; - - ret = test_is_capable(CAP_SETUID, CAP_SETGID, -1); - ASSERT_RETURN(ret >= 0); - - /* no enough privileges, SKIP test */ - if (!ret) - return TEST_SKIP; - - /* we require user-namespaces */ - if (access("/proc/self/uid_map", F_OK) != 0) - return TEST_SKIP; - - /* uids/gids must be mapped */ - if (!all_uids_gids_are_mapped()) - return TEST_SKIP; - - conn_db = calloc(MAX_CONN, sizeof(struct kdbus_conn *)); - ASSERT_RETURN(conn_db); - - memset(conn_db, 0, MAX_CONN * sizeof(struct kdbus_conn *)); - - conn_db[0] = kdbus_hello(bus, 0, NULL, 0); - ASSERT_RETURN(conn_db[0]); - - ret = kdbus_add_match_empty(conn_db[0]); - ASSERT_RETURN(ret == 0); - - ret = kdbus_fork_test_by_id(bus, conn_db, -EPERM, -EPERM); - ASSERT_EXIT(ret == 0); - - ret = kdbus_register_policy_holder(bus, POLICY_NAME, - &policy_holder); - ASSERT_RETURN(ret == 0); - - /* Try to register the same name with an activator */ - ret = kdbus_register_same_activator(bus, POLICY_NAME, - &activator); - ASSERT_RETURN(ret == 0); - - /* Acquire POLICY_NAME */ - ret = kdbus_name_acquire(conn_db[0], POLICY_NAME, NULL); - ASSERT_RETURN(ret == 0); - - ret = kdbus_normal_test(bus, POLICY_NAME, conn_db); - ASSERT_RETURN(ret == 0); - - ret = kdbus_list(conn_db[0], KDBUS_LIST_NAMES | - KDBUS_LIST_UNIQUE | - KDBUS_LIST_ACTIVATORS | - KDBUS_LIST_QUEUED); - ASSERT_RETURN(ret == 0); - - ret = kdbus_fork_test(bus, POLICY_NAME, conn_db, EXIT_SUCCESS); - ASSERT_RETURN(ret == 0); - - /* - * children connections are able to talk to conn_db[0] since - * current POLICY_NAME TALK type is KDBUS_POLICY_ACCESS_WORLD, - * so expect EXIT_SUCCESS when sending from child. However, - * since the child's connection does not own any well-known - * name, The parent connection conn_db[0] should fail with - * -EPERM but since it is a privileged bus user the TALK is - * allowed. - */ - ret = kdbus_fork_test_by_id(bus, conn_db, - EXIT_SUCCESS, EXIT_SUCCESS); - ASSERT_EXIT(ret == 0); - - /* - * Connections that can talk are perhaps being destroyed now. - * Restrict the policy and purge cache entries where the - * conn_db[0] is the destination. - * - * Now only connections with uid == 0 are allowed to talk. - */ - ret = kdbus_set_policy_talk(policy_holder, POLICY_NAME, - geteuid(), KDBUS_POLICY_ACCESS_USER); - ASSERT_RETURN(ret == 0); - - /* - * Testing connections (FORK+DROP) again: - * After setting the policy re-check connections - * we expect the children to fail with -EPERM - */ - ret = kdbus_fork_test(bus, POLICY_NAME, conn_db, -EPERM); - ASSERT_RETURN(ret == 0); - - /* - * Now expect that both parent and child to fail. - * - * Child should fail with -EPERM since we just restricted - * the POLICY_NAME TALK to uid 0 and its uid is 65534. - * - * Since the parent's connection will timeout when receiving - * from the child, we never continue. FWIW just put -EPERM. - */ - ret = kdbus_fork_test_by_id(bus, conn_db, -EPERM, -EPERM); - ASSERT_EXIT(ret == 0); - - /* Check if the name can be reached in a new userns */ - ret = kdbus_clone_userns_test(bus, POLICY_NAME, conn_db, -EPERM); - ASSERT_RETURN(ret == 0); - - for (i = 0; i < MAX_CONN; i++) - kdbus_conn_free(conn_db[i]); - - kdbus_conn_free(activator); - kdbus_conn_free(policy_holder); - - free(conn_db); - - return ret; -} diff --git a/tools/testing/selftests/kdbus/test-policy-priv.c b/tools/testing/selftests/kdbus/test-policy-priv.c deleted file mode 100644 index 0208638a7..000000000 --- a/tools/testing/selftests/kdbus/test-policy-priv.c +++ /dev/null @@ -1,1285 +0,0 @@ -#include <errno.h> -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stdint.h> -#include <stdbool.h> -#include <unistd.h> -#include <time.h> -#include <sys/capability.h> -#include <sys/eventfd.h> -#include <sys/wait.h> - -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -static int test_policy_priv_by_id(const char *bus, - struct kdbus_conn *conn_dst, - bool drop_second_user, - int parent_status, - int child_status) -{ - int ret = 0; - uint64_t expected_cookie = time(NULL) ^ 0xdeadbeef; - - ASSERT_RETURN(conn_dst); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, bus, ({ - ret = kdbus_msg_send(unpriv, NULL, - expected_cookie, 0, 0, 0, - conn_dst->id); - ASSERT_EXIT(ret == child_status); - })); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_msg_recv_poll(conn_dst, 300, NULL, NULL); - ASSERT_RETURN(ret == parent_status); - - return 0; -} - -static int test_policy_priv_by_broadcast(const char *bus, - struct kdbus_conn *conn_dst, - int drop_second_user, - int parent_status, - int child_status) -{ - int efd; - int ret = 0; - eventfd_t event_status = 0; - struct kdbus_msg *msg = NULL; - uid_t second_uid = UNPRIV_UID; - gid_t second_gid = UNPRIV_GID; - struct kdbus_conn *child_2 = conn_dst; - uint64_t expected_cookie = time(NULL) ^ 0xdeadbeef; - - /* Drop to another unprivileged user other than UNPRIV_UID */ - if (drop_second_user == DROP_OTHER_UNPRIV) { - second_uid = UNPRIV_UID - 1; - second_gid = UNPRIV_GID - 1; - } - - /* child will signal parent to send broadcast */ - efd = eventfd(0, EFD_CLOEXEC); - ASSERT_RETURN_VAL(efd >= 0, efd); - - ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_GID, ({ - struct kdbus_conn *child; - - child = kdbus_hello(bus, 0, NULL, 0); - ASSERT_EXIT(child); - - ret = kdbus_add_match_empty(child); - ASSERT_EXIT(ret == 0); - - /* signal parent */ - ret = eventfd_write(efd, 1); - ASSERT_EXIT(ret == 0); - - /* Use a little bit high time */ - ret = kdbus_msg_recv_poll(child, 500, &msg, NULL); - ASSERT_EXIT(ret == child_status); - - /* - * If we expect the child to get the broadcast - * message, then check the received cookie. - */ - if (ret == 0) { - ASSERT_EXIT(expected_cookie == msg->cookie); - } - - /* Use expected_cookie since 'msg' might be NULL */ - ret = kdbus_msg_send(child, NULL, expected_cookie + 1, - 0, 0, 0, KDBUS_DST_ID_BROADCAST); - ASSERT_EXIT(ret == 0); - - kdbus_msg_free(msg); - kdbus_conn_free(child); - }), - ({ - if (drop_second_user == DO_NOT_DROP) { - ASSERT_RETURN(child_2); - - ret = eventfd_read(efd, &event_status); - ASSERT_RETURN(ret >= 0 && event_status == 1); - - ret = kdbus_msg_send(child_2, NULL, - expected_cookie, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - /* drop own broadcast */ - ret = kdbus_msg_recv(child_2, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->src_id == child_2->id); - kdbus_msg_free(msg); - - /* Use a little bit high time */ - ret = kdbus_msg_recv_poll(child_2, 1000, - &msg, NULL); - ASSERT_RETURN(ret == parent_status); - - /* - * Check returned cookie in case we expect - * success. - */ - if (ret == 0) { - ASSERT_RETURN(msg->cookie == - expected_cookie + 1); - } - - kdbus_msg_free(msg); - } else { - /* - * Two unprivileged users will try to - * communicate using broadcast. - */ - ret = RUN_UNPRIVILEGED(second_uid, second_gid, ({ - child_2 = kdbus_hello(bus, 0, NULL, 0); - ASSERT_EXIT(child_2); - - ret = kdbus_add_match_empty(child_2); - ASSERT_EXIT(ret == 0); - - ret = eventfd_read(efd, &event_status); - ASSERT_EXIT(ret >= 0 && event_status == 1); - - ret = kdbus_msg_send(child_2, NULL, - expected_cookie, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_EXIT(ret == 0); - - /* drop own broadcast */ - ret = kdbus_msg_recv(child_2, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->src_id == child_2->id); - kdbus_msg_free(msg); - - /* Use a little bit high time */ - ret = kdbus_msg_recv_poll(child_2, 1000, - &msg, NULL); - ASSERT_EXIT(ret == parent_status); - - /* - * Check returned cookie in case we expect - * success. - */ - if (ret == 0) { - ASSERT_EXIT(msg->cookie == - expected_cookie + 1); - } - - kdbus_msg_free(msg); - kdbus_conn_free(child_2); - }), - ({ 0; })); - ASSERT_RETURN(ret == 0); - } - })); - ASSERT_RETURN(ret == 0); - - close(efd); - - return ret; -} - -static void nosig(int sig) -{ -} - -static int test_priv_before_policy_upload(struct kdbus_test_env *env) -{ - int ret = 0; - struct kdbus_conn *conn; - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - /* - * Make sure unprivileged bus user cannot acquire names - * before registring any policy holder. - */ - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret < 0); - })); - ASSERT_RETURN(ret == 0); - - /* - * Make sure unprivileged bus users cannot talk by default - * to privileged ones, unless a policy holder that allows - * this was uploaded. - */ - - ret = test_policy_priv_by_id(env->buspath, conn, false, - -ETIMEDOUT, -EPERM); - ASSERT_RETURN(ret == 0); - - /* Activate matching for a privileged connection */ - ret = kdbus_add_match_empty(conn); - ASSERT_RETURN(ret == 0); - - /* - * First make sure that BROADCAST with msg flag - * KDBUS_MSG_EXPECT_REPLY will fail with -ENOTUNIQ - */ - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_msg_send(unpriv, NULL, 0xdeadbeef, - KDBUS_MSG_EXPECT_REPLY, - 5000000000ULL, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_EXIT(ret == -ENOTUNIQ); - })); - ASSERT_RETURN(ret == 0); - - /* - * Test broadcast with a privileged connection. - * - * The first unprivileged receiver should not get the - * broadcast message sent by the privileged connection, - * since there is no a TALK policy that allows the - * unprivileged to TALK to the privileged connection. It - * will fail with -ETIMEDOUT - * - * Then second case: - * The privileged connection should get the broadcast - * message from the unprivileged one. Since the receiver is - * a privileged bus user and it has default TALK access to - * all connections it will receive those. - */ - - ret = test_policy_priv_by_broadcast(env->buspath, conn, - DO_NOT_DROP, - 0, -ETIMEDOUT); - ASSERT_RETURN(ret == 0); - - - /* - * Test broadcast with two unprivileged connections running - * under the same user. - * - * Both connections should succeed. - */ - - ret = test_policy_priv_by_broadcast(env->buspath, NULL, - DROP_SAME_UNPRIV, 0, 0); - ASSERT_RETURN(ret == 0); - - /* - * Test broadcast with two unprivileged connections running - * under different users. - * - * Both connections will fail with -ETIMEDOUT. - */ - - ret = test_policy_priv_by_broadcast(env->buspath, NULL, - DROP_OTHER_UNPRIV, - -ETIMEDOUT, -ETIMEDOUT); - ASSERT_RETURN(ret == 0); - - kdbus_conn_free(conn); - - return ret; -} - -static int test_broadcast_after_policy_upload(struct kdbus_test_env *env) -{ - int ret; - int efd; - eventfd_t event_status = 0; - struct kdbus_msg *msg = NULL; - struct kdbus_conn *owner_a, *owner_b; - struct kdbus_conn *holder_a, *holder_b; - struct kdbus_policy_access access = {}; - uint64_t expected_cookie = time(NULL) ^ 0xdeadbeef; - - owner_a = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(owner_a); - - ret = kdbus_name_acquire(owner_a, "com.example.broadcastA", NULL); - ASSERT_EXIT(ret >= 0); - - /* - * Make sure unprivileged bus users cannot talk by default - * to privileged ones, unless a policy holder that allows - * this was uploaded. - */ - - ++expected_cookie; - ret = test_policy_priv_by_id(env->buspath, owner_a, false, - -ETIMEDOUT, -EPERM); - ASSERT_RETURN(ret == 0); - - /* - * Make sure that privileged won't receive broadcasts unless - * it installs a match. It will fail with -ETIMEDOUT - * - * At same time check that the unprivileged connection will - * not receive the broadcast message from the privileged one - * since the privileged one owns a name with a restricted - * policy TALK (actually the TALK policy is still not - * registered so we fail by default), thus the unprivileged - * receiver is not able to TALK to that name. - */ - - /* Activate matching for a privileged connection */ - ret = kdbus_add_match_empty(owner_a); - ASSERT_RETURN(ret == 0); - - /* - * Redo the previous test. The privileged conn owner_a is - * able to TALK to any connection so it will receive the - * broadcast message now. - */ - - ret = test_policy_priv_by_broadcast(env->buspath, owner_a, - DO_NOT_DROP, - 0, -ETIMEDOUT); - ASSERT_RETURN(ret == 0); - - /* - * Test that broadcast between two unprivileged users running - * under the same user still succeed. - */ - - ret = test_policy_priv_by_broadcast(env->buspath, NULL, - DROP_SAME_UNPRIV, 0, 0); - ASSERT_RETURN(ret == 0); - - /* - * Test broadcast with two unprivileged connections running - * under different users. - * - * Both connections will fail with -ETIMEDOUT. - */ - - ret = test_policy_priv_by_broadcast(env->buspath, NULL, - DROP_OTHER_UNPRIV, - -ETIMEDOUT, -ETIMEDOUT); - ASSERT_RETURN(ret == 0); - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_USER, - .id = geteuid(), - .access = KDBUS_POLICY_OWN, - }; - - holder_a = kdbus_hello_registrar(env->buspath, - "com.example.broadcastA", - &access, 1, - KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(holder_a); - - holder_b = kdbus_hello_registrar(env->buspath, - "com.example.broadcastB", - &access, 1, - KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(holder_b); - - /* Free connections and their received messages and restart */ - kdbus_conn_free(owner_a); - - owner_a = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(owner_a); - - /* Activate matching for a privileged connection */ - ret = kdbus_add_match_empty(owner_a); - ASSERT_RETURN(ret == 0); - - ret = kdbus_name_acquire(owner_a, "com.example.broadcastA", NULL); - ASSERT_EXIT(ret >= 0); - - owner_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(owner_b); - - ret = kdbus_name_acquire(owner_b, "com.example.broadcastB", NULL); - ASSERT_EXIT(ret >= 0); - - /* Activate matching for a privileged connection */ - ret = kdbus_add_match_empty(owner_b); - ASSERT_RETURN(ret == 0); - - /* - * Test that even if "com.example.broadcastA" and - * "com.example.broadcastB" do have a TALK access by default - * they are able to signal each other using broadcast due to - * the fact they are privileged connections, they receive - * all broadcasts if the match allows it. - */ - - ++expected_cookie; - ret = kdbus_msg_send(owner_a, NULL, expected_cookie, 0, - 0, 0, KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv_poll(owner_a, 100, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == expected_cookie); - - /* Check src ID */ - ASSERT_RETURN(msg->src_id == owner_a->id); - - kdbus_msg_free(msg); - - ret = kdbus_msg_recv_poll(owner_b, 100, &msg, NULL); - ASSERT_RETURN(ret == 0); - ASSERT_RETURN(msg->cookie == expected_cookie); - - /* Check src ID */ - ASSERT_RETURN(msg->src_id == owner_a->id); - - kdbus_msg_free(msg); - - /* Release name "com.example.broadcastB" */ - - ret = kdbus_name_release(owner_b, "com.example.broadcastB"); - ASSERT_EXIT(ret >= 0); - - /* KDBUS_POLICY_OWN for unprivileged connections */ - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = geteuid(), - .access = KDBUS_POLICY_OWN, - }; - - /* Update the policy so unprivileged will own the name */ - - ret = kdbus_conn_update_policy(holder_b, - "com.example.broadcastB", - &access, 1); - ASSERT_RETURN(ret == 0); - - /* - * Send broadcasts from an unprivileged connection that - * owns a name "com.example.broadcastB". - * - * We'll have four destinations here: - * - * 1) destination owner_a: privileged connection that owns - * "com.example.broadcastA". It will receive the broadcast - * since it is a privileged has default TALK access to all - * connections, and it is subscribed to the match. - * Will succeed. - * - * owner_b: privileged connection (running under a different - * uid) that do not own names, but with an empty broadcast - * match, so it will receive broadcasts since it has default - * TALK access to all connection. - * - * unpriv_a: unpriv connection that do not own any name. - * It will receive the broadcast since it is running under - * the same user of the one broadcasting and did install - * matches. It should get the message. - * - * unpriv_b: unpriv connection is not interested in broadcast - * messages, so it did not install broadcast matches. Should - * fail with -ETIMEDOUT - */ - - ++expected_cookie; - efd = eventfd(0, EFD_CLOEXEC); - ASSERT_RETURN_VAL(efd >= 0, efd); - - ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_UID, ({ - struct kdbus_conn *unpriv_owner; - struct kdbus_conn *unpriv_a, *unpriv_b; - - unpriv_owner = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_EXIT(unpriv_owner); - - unpriv_a = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_EXIT(unpriv_a); - - unpriv_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_EXIT(unpriv_b); - - ret = kdbus_name_acquire(unpriv_owner, - "com.example.broadcastB", - NULL); - ASSERT_EXIT(ret >= 0); - - ret = kdbus_add_match_empty(unpriv_a); - ASSERT_EXIT(ret == 0); - - /* Signal that we are doing broadcasts */ - ret = eventfd_write(efd, 1); - ASSERT_EXIT(ret == 0); - - /* - * Do broadcast from a connection that owns the - * names "com.example.broadcastB". - */ - ret = kdbus_msg_send(unpriv_owner, NULL, - expected_cookie, - 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_EXIT(ret == 0); - - /* - * Unprivileged connection running under the same - * user. It should succeed. - */ - ret = kdbus_msg_recv_poll(unpriv_a, 300, &msg, NULL); - ASSERT_EXIT(ret == 0 && msg->cookie == expected_cookie); - - /* - * Did not install matches, not interested in - * broadcasts - */ - ret = kdbus_msg_recv_poll(unpriv_b, 300, NULL, NULL); - ASSERT_EXIT(ret == -ETIMEDOUT); - }), - ({ - ret = eventfd_read(efd, &event_status); - ASSERT_RETURN(ret >= 0 && event_status == 1); - - /* - * owner_a must fail with -ETIMEDOUT, since it owns - * name "com.example.broadcastA" and its TALK - * access is restriced. - */ - ret = kdbus_msg_recv_poll(owner_a, 300, &msg, NULL); - ASSERT_RETURN(ret == 0); - - /* confirm the received cookie */ - ASSERT_RETURN(msg->cookie == expected_cookie); - - kdbus_msg_free(msg); - - /* - * owner_b got the broadcast from an unprivileged - * connection. - */ - ret = kdbus_msg_recv_poll(owner_b, 300, &msg, NULL); - ASSERT_RETURN(ret == 0); - - /* confirm the received cookie */ - ASSERT_RETURN(msg->cookie == expected_cookie); - - kdbus_msg_free(msg); - - })); - ASSERT_RETURN(ret == 0); - - close(efd); - - /* - * Test broadcast with two unprivileged connections running - * under different users. - * - * Both connections will fail with -ETIMEDOUT. - */ - - ret = test_policy_priv_by_broadcast(env->buspath, NULL, - DROP_OTHER_UNPRIV, - -ETIMEDOUT, -ETIMEDOUT); - ASSERT_RETURN(ret == 0); - - /* Drop received broadcasts by privileged */ - ret = kdbus_msg_recv_poll(owner_a, 100, NULL, NULL); - ret = kdbus_msg_recv_poll(owner_a, 100, NULL, NULL); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(owner_a, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - ret = kdbus_msg_recv_poll(owner_b, 100, NULL, NULL); - ret = kdbus_msg_recv_poll(owner_b, 100, NULL, NULL); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_recv(owner_b, NULL, NULL); - ASSERT_RETURN(ret == -EAGAIN); - - /* - * Perform last tests, allow others to talk to name - * "com.example.broadcastA". So now receiving broadcasts - * from it should succeed since the TALK policy allow it. - */ - - /* KDBUS_POLICY_OWN for unprivileged connections */ - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = geteuid(), - .access = KDBUS_POLICY_TALK, - }; - - ret = kdbus_conn_update_policy(holder_a, - "com.example.broadcastA", - &access, 1); - ASSERT_RETURN(ret == 0); - - /* - * Unprivileged is able to TALK to "com.example.broadcastA" - * now so it will receive its broadcasts - */ - ret = test_policy_priv_by_broadcast(env->buspath, owner_a, - DO_NOT_DROP, 0, 0); - ASSERT_RETURN(ret == 0); - - ++expected_cookie; - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.broadcastB", - NULL); - ASSERT_EXIT(ret >= 0); - ret = kdbus_msg_send(unpriv, NULL, expected_cookie, - 0, 0, 0, KDBUS_DST_ID_BROADCAST); - ASSERT_EXIT(ret == 0); - })); - ASSERT_RETURN(ret == 0); - - /* owner_a is privileged it will get the broadcast now. */ - ret = kdbus_msg_recv_poll(owner_a, 300, &msg, NULL); - ASSERT_RETURN(ret == 0); - - /* confirm the received cookie */ - ASSERT_RETURN(msg->cookie == expected_cookie); - - kdbus_msg_free(msg); - - /* - * owner_a released name "com.example.broadcastA". It should - * receive broadcasts since it is still privileged and has - * the right match. - * - * Unprivileged connection will own a name and will try to - * signal to the privileged connection. - */ - - ret = kdbus_name_release(owner_a, "com.example.broadcastA"); - ASSERT_EXIT(ret >= 0); - - ++expected_cookie; - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.broadcastB", - NULL); - ASSERT_EXIT(ret >= 0); - ret = kdbus_msg_send(unpriv, NULL, expected_cookie, - 0, 0, 0, KDBUS_DST_ID_BROADCAST); - ASSERT_EXIT(ret == 0); - })); - ASSERT_RETURN(ret == 0); - - /* owner_a will get the broadcast now. */ - ret = kdbus_msg_recv_poll(owner_a, 300, &msg, NULL); - ASSERT_RETURN(ret == 0); - - /* confirm the received cookie */ - ASSERT_RETURN(msg->cookie == expected_cookie); - - kdbus_msg_free(msg); - - kdbus_conn_free(owner_a); - kdbus_conn_free(owner_b); - kdbus_conn_free(holder_a); - kdbus_conn_free(holder_b); - - return 0; -} - -static int test_policy_priv(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn_a, *conn_b, *conn, *owner; - struct kdbus_policy_access access, *acc; - sigset_t sset; - size_t num; - int ret; - - /* - * Make sure we have CAP_SETUID/SETGID so we can drop privileges - */ - - ret = test_is_capable(CAP_SETUID, CAP_SETGID, -1); - ASSERT_RETURN(ret >= 0); - - if (!ret) - return TEST_SKIP; - - /* make sure that uids and gids are mapped */ - if (!all_uids_gids_are_mapped()) - return TEST_SKIP; - - /* - * Setup: - * conn_a: policy holder for com.example.a - * conn_b: name holder of com.example.b - */ - - signal(SIGUSR1, nosig); - sigemptyset(&sset); - sigaddset(&sset, SIGUSR1); - sigprocmask(SIG_BLOCK, &sset, NULL); - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - /* - * Before registering any policy holder, make sure that the - * bus is secure by default. This test is necessary, it catches - * several cases where old D-Bus was vulnerable. - */ - - ret = test_priv_before_policy_upload(env); - ASSERT_RETURN(ret == 0); - - /* - * Make sure unprivileged are not able to register policy - * holders - */ - - ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_GID, ({ - struct kdbus_conn *holder; - - holder = kdbus_hello_registrar(env->buspath, - "com.example.a", NULL, 0, - KDBUS_HELLO_POLICY_HOLDER); - ASSERT_EXIT(holder == NULL && errno == EPERM); - }), - ({ 0; })); - ASSERT_RETURN(ret == 0); - - - /* Register policy holder */ - - conn_a = kdbus_hello_registrar(env->buspath, "com.example.a", - NULL, 0, KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(conn_a); - - conn_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_b); - - ret = kdbus_name_acquire(conn_b, "com.example.b", NULL); - ASSERT_EXIT(ret >= 0); - - /* - * Make sure bus-owners can always acquire names. - */ - ret = kdbus_name_acquire(conn, "com.example.a", NULL); - ASSERT_EXIT(ret >= 0); - - kdbus_conn_free(conn); - - /* - * Make sure unprivileged users cannot acquire names with default - * policy assigned. - */ - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret < 0); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure unprivileged users can acquire names if we make them - * world-accessible. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = 0, - .access = KDBUS_POLICY_OWN, - }; - - /* - * Make sure unprivileged/normal connections are not able - * to update policies - */ - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_conn_update_policy(unpriv, "com.example.a", - &access, 1); - ASSERT_EXIT(ret == -EOPNOTSUPP); - })); - ASSERT_RETURN(ret == 0); - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret >= 0); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure unprivileged users can acquire names if we make them - * gid-accessible. But only if the gid matches. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_GROUP, - .id = UNPRIV_GID, - .access = KDBUS_POLICY_OWN, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret >= 0); - })); - ASSERT_RETURN(ret >= 0); - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_GROUP, - .id = 1, - .access = KDBUS_POLICY_OWN, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret < 0); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure unprivileged users can acquire names if we make them - * uid-accessible. But only if the uid matches. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_USER, - .id = UNPRIV_UID, - .access = KDBUS_POLICY_OWN, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret >= 0); - })); - ASSERT_RETURN(ret >= 0); - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_USER, - .id = 1, - .access = KDBUS_POLICY_OWN, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret < 0); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure unprivileged users cannot acquire names if no owner-policy - * matches, even if SEE/TALK policies match. - */ - - num = 4; - acc = (struct kdbus_policy_access[]){ - { - .type = KDBUS_POLICY_ACCESS_GROUP, - .id = UNPRIV_GID, - .access = KDBUS_POLICY_SEE, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = UNPRIV_UID, - .access = KDBUS_POLICY_TALK, - }, - { - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = 0, - .access = KDBUS_POLICY_TALK, - }, - { - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = 0, - .access = KDBUS_POLICY_SEE, - }, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", acc, num); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret < 0); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure unprivileged users can acquire names if the only matching - * policy is somewhere in the middle. - */ - - num = 5; - acc = (struct kdbus_policy_access[]){ - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = 1, - .access = KDBUS_POLICY_OWN, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = 2, - .access = KDBUS_POLICY_OWN, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = UNPRIV_UID, - .access = KDBUS_POLICY_OWN, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = 3, - .access = KDBUS_POLICY_OWN, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = 4, - .access = KDBUS_POLICY_OWN, - }, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", acc, num); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_name_acquire(unpriv, "com.example.a", NULL); - ASSERT_EXIT(ret >= 0); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Clear policies - */ - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", NULL, 0); - ASSERT_RETURN(ret == 0); - - /* - * Make sure privileged bus users can _always_ talk to others. - */ - - conn = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn); - - ret = kdbus_msg_send(conn, "com.example.b", 0xdeadbeef, 0, 0, 0, 0); - ASSERT_EXIT(ret >= 0); - - ret = kdbus_msg_recv_poll(conn_b, 300, NULL, NULL); - ASSERT_EXIT(ret >= 0); - - kdbus_conn_free(conn); - - /* - * Make sure unprivileged bus users cannot talk by default. - */ - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_msg_send(unpriv, "com.example.b", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret == -EPERM); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure unprivileged bus users can talk to equals, even without - * policy. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_USER, - .id = UNPRIV_UID, - .access = KDBUS_POLICY_OWN, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.c", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - struct kdbus_conn *owner; - - owner = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(owner); - - ret = kdbus_name_acquire(owner, "com.example.c", NULL); - ASSERT_EXIT(ret >= 0); - - ret = kdbus_msg_send(unpriv, "com.example.c", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret >= 0); - ret = kdbus_msg_recv_poll(owner, 100, NULL, NULL); - ASSERT_EXIT(ret >= 0); - - kdbus_conn_free(owner); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure unprivileged bus users can talk to privileged users if a - * suitable UID policy is set. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_USER, - .id = UNPRIV_UID, - .access = KDBUS_POLICY_TALK, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.b", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_msg_send(unpriv, "com.example.b", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret >= 0); - })); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_msg_recv_poll(conn_b, 100, NULL, NULL); - ASSERT_EXIT(ret >= 0); - - /* - * Make sure unprivileged bus users can talk to privileged users if a - * suitable GID policy is set. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_GROUP, - .id = UNPRIV_GID, - .access = KDBUS_POLICY_TALK, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.b", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_msg_send(unpriv, "com.example.b", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret >= 0); - })); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_msg_recv_poll(conn_b, 100, NULL, NULL); - ASSERT_EXIT(ret >= 0); - - /* - * Make sure unprivileged bus users can talk to privileged users if a - * suitable WORLD policy is set. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = 0, - .access = KDBUS_POLICY_TALK, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.b", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_msg_send(unpriv, "com.example.b", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret >= 0); - })); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_msg_recv_poll(conn_b, 100, NULL, NULL); - ASSERT_EXIT(ret >= 0); - - /* - * Make sure unprivileged bus users cannot talk to privileged users if - * no suitable policy is set. - */ - - num = 5; - acc = (struct kdbus_policy_access[]){ - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = 0, - .access = KDBUS_POLICY_OWN, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = 1, - .access = KDBUS_POLICY_TALK, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = UNPRIV_UID, - .access = KDBUS_POLICY_SEE, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = 3, - .access = KDBUS_POLICY_TALK, - }, - { - .type = KDBUS_POLICY_ACCESS_USER, - .id = 4, - .access = KDBUS_POLICY_TALK, - }, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.b", acc, num); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_msg_send(unpriv, "com.example.b", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret == -EPERM); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure unprivileged bus users can talk to privileged users if a - * suitable OWN privilege overwrites TALK. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = 0, - .access = KDBUS_POLICY_OWN, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.b", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_msg_send(unpriv, "com.example.b", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret >= 0); - })); - ASSERT_RETURN(ret >= 0); - - ret = kdbus_msg_recv_poll(conn_b, 100, NULL, NULL); - ASSERT_EXIT(ret >= 0); - - /* - * Make sure the TALK cache is reset correctly when policies are - * updated. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = 0, - .access = KDBUS_POLICY_TALK, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.b", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = RUN_UNPRIVILEGED_CONN(unpriv, env->buspath, ({ - ret = kdbus_msg_send(unpriv, "com.example.b", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret >= 0); - - ret = kdbus_msg_recv_poll(conn_b, 100, NULL, NULL); - ASSERT_EXIT(ret >= 0); - - ret = kdbus_conn_update_policy(conn_a, "com.example.b", - NULL, 0); - ASSERT_RETURN(ret == 0); - - ret = kdbus_msg_send(unpriv, "com.example.b", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret == -EPERM); - })); - ASSERT_RETURN(ret >= 0); - - /* - * Make sure the TALK cache is reset correctly when policy holders - * disconnect. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_WORLD, - .id = 0, - .access = KDBUS_POLICY_OWN, - }; - - conn = kdbus_hello_registrar(env->buspath, "com.example.c", - NULL, 0, KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(conn); - - ret = kdbus_conn_update_policy(conn, "com.example.c", &access, 1); - ASSERT_RETURN(ret == 0); - - owner = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(owner); - - ret = kdbus_name_acquire(owner, "com.example.c", NULL); - ASSERT_RETURN(ret >= 0); - - ret = RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_GID, ({ - struct kdbus_conn *unpriv; - - /* wait for parent to be finished */ - sigemptyset(&sset); - ret = sigsuspend(&sset); - ASSERT_RETURN(ret == -1 && errno == EINTR); - - unpriv = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(unpriv); - - ret = kdbus_msg_send(unpriv, "com.example.c", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret >= 0); - - ret = kdbus_msg_recv_poll(owner, 100, NULL, NULL); - ASSERT_EXIT(ret >= 0); - - /* free policy holder */ - kdbus_conn_free(conn); - - ret = kdbus_msg_send(unpriv, "com.example.c", 0xdeadbeef, 0, 0, - 0, 0); - ASSERT_EXIT(ret == -EPERM); - - kdbus_conn_free(unpriv); - }), ({ - /* make sure policy holder is only valid in child */ - kdbus_conn_free(conn); - kill(pid, SIGUSR1); - })); - ASSERT_RETURN(ret >= 0); - - - /* - * The following tests are necessary. - */ - - ret = test_broadcast_after_policy_upload(env); - ASSERT_RETURN(ret == 0); - - kdbus_conn_free(owner); - - /* - * cleanup resources - */ - - kdbus_conn_free(conn_b); - kdbus_conn_free(conn_a); - - return TEST_OK; -} - -int kdbus_test_policy_priv(struct kdbus_test_env *env) -{ - pid_t pid; - int ret; - - /* make sure to exit() if a child returns from fork() */ - pid = getpid(); - ret = test_policy_priv(env); - if (pid != getpid()) - exit(1); - - return ret; -} diff --git a/tools/testing/selftests/kdbus/test-policy.c b/tools/testing/selftests/kdbus/test-policy.c deleted file mode 100644 index 96d20d5e9..000000000 --- a/tools/testing/selftests/kdbus/test-policy.c +++ /dev/null @@ -1,80 +0,0 @@ -#include <errno.h> -#include <stdio.h> -#include <string.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stdint.h> -#include <stdbool.h> -#include <unistd.h> - -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -int kdbus_test_policy(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn_a, *conn_b; - struct kdbus_policy_access access; - int ret; - - /* Invalid name */ - conn_a = kdbus_hello_registrar(env->buspath, ".example.a", - NULL, 0, KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(conn_a == NULL); - - conn_a = kdbus_hello_registrar(env->buspath, "example", - NULL, 0, KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(conn_a == NULL); - - conn_a = kdbus_hello_registrar(env->buspath, "com.example.a", - NULL, 0, KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(conn_a); - - conn_b = kdbus_hello_registrar(env->buspath, "com.example.b", - NULL, 0, KDBUS_HELLO_POLICY_HOLDER); - ASSERT_RETURN(conn_b); - - /* - * Verify there cannot be any duplicate entries, except for specific vs. - * wildcard entries. - */ - - access = (struct kdbus_policy_access){ - .type = KDBUS_POLICY_ACCESS_USER, - .id = geteuid(), - .access = KDBUS_POLICY_SEE, - }; - - ret = kdbus_conn_update_policy(conn_a, "com.example.a", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = kdbus_conn_update_policy(conn_b, "com.example.a", &access, 1); - ASSERT_RETURN(ret == -EEXIST); - - ret = kdbus_conn_update_policy(conn_b, "com.example.a.*", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = kdbus_conn_update_policy(conn_a, "com.example.a.*", &access, 1); - ASSERT_RETURN(ret == -EEXIST); - - ret = kdbus_conn_update_policy(conn_a, "com.example.*", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = kdbus_conn_update_policy(conn_b, "com.example.a", &access, 1); - ASSERT_RETURN(ret == 0); - - ret = kdbus_conn_update_policy(conn_b, "com.example.*", &access, 1); - ASSERT_RETURN(ret == -EEXIST); - - /* Invalid name */ - ret = kdbus_conn_update_policy(conn_b, ".example.*", &access, 1); - ASSERT_RETURN(ret == -EINVAL); - - ret = kdbus_conn_update_policy(conn_b, "example", &access, 1); - ASSERT_RETURN(ret == -EINVAL); - - kdbus_conn_free(conn_b); - kdbus_conn_free(conn_a); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-sync.c b/tools/testing/selftests/kdbus/test-sync.c deleted file mode 100644 index 0655a545f..000000000 --- a/tools/testing/selftests/kdbus/test-sync.c +++ /dev/null @@ -1,369 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <pthread.h> -#include <stdbool.h> -#include <signal.h> -#include <sys/wait.h> -#include <sys/eventfd.h> - -#include "kdbus-api.h" -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -static struct kdbus_conn *conn_a, *conn_b; -static unsigned int cookie = 0xdeadbeef; - -static void nop_handler(int sig) {} - -static int interrupt_sync(struct kdbus_conn *conn_src, - struct kdbus_conn *conn_dst) -{ - pid_t pid; - int ret, status; - struct kdbus_msg *msg = NULL; - struct sigaction sa = { - .sa_handler = nop_handler, - .sa_flags = SA_NOCLDSTOP|SA_RESTART, - }; - - cookie++; - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, pid); - - if (pid == 0) { - ret = sigaction(SIGINT, &sa, NULL); - ASSERT_EXIT(ret == 0); - - ret = kdbus_msg_send_sync(conn_dst, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - 100000000ULL, 0, conn_src->id, -1); - ASSERT_EXIT(ret == -ETIMEDOUT); - - _exit(EXIT_SUCCESS); - } - - ret = kdbus_msg_recv_poll(conn_src, 100, &msg, NULL); - ASSERT_RETURN(ret == 0 && msg->cookie == cookie); - - kdbus_msg_free(msg); - - ret = kill(pid, SIGINT); - ASSERT_RETURN_VAL(ret == 0, ret); - - ret = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(ret >= 0, ret); - - if (WIFSIGNALED(status)) - return TEST_ERR; - - ret = kdbus_msg_recv_poll(conn_src, 100, NULL, NULL); - ASSERT_RETURN(ret == -ETIMEDOUT); - - return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR; -} - -static int close_epipe_sync(const char *bus) -{ - pid_t pid; - int ret, status; - struct kdbus_conn *conn_src; - struct kdbus_conn *conn_dst; - struct kdbus_msg *msg = NULL; - - conn_src = kdbus_hello(bus, 0, NULL, 0); - ASSERT_RETURN(conn_src); - - ret = kdbus_add_match_empty(conn_src); - ASSERT_RETURN(ret == 0); - - conn_dst = kdbus_hello(bus, 0, NULL, 0); - ASSERT_RETURN(conn_dst); - - cookie++; - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, pid); - - if (pid == 0) { - uint64_t dst_id; - - /* close our reference */ - dst_id = conn_dst->id; - kdbus_conn_free(conn_dst); - - ret = kdbus_msg_recv_poll(conn_src, 100, &msg, NULL); - ASSERT_EXIT(ret == 0 && msg->cookie == cookie); - ASSERT_EXIT(msg->src_id == dst_id); - - cookie++; - ret = kdbus_msg_send_sync(conn_src, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - 100000000ULL, 0, dst_id, -1); - ASSERT_EXIT(ret == -EPIPE); - - _exit(EXIT_SUCCESS); - } - - ret = kdbus_msg_send(conn_dst, NULL, cookie, 0, 0, 0, - KDBUS_DST_ID_BROADCAST); - ASSERT_RETURN(ret == 0); - - cookie++; - ret = kdbus_msg_recv_poll(conn_dst, 100, &msg, NULL); - ASSERT_RETURN(ret == 0 && msg->cookie == cookie); - - kdbus_msg_free(msg); - - /* destroy connection */ - kdbus_conn_free(conn_dst); - kdbus_conn_free(conn_src); - - ret = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(ret >= 0, ret); - - if (!WIFEXITED(status)) - return TEST_ERR; - - return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR; -} - -static int cancel_fd_sync(struct kdbus_conn *conn_src, - struct kdbus_conn *conn_dst) -{ - pid_t pid; - int cancel_fd; - int ret, status; - uint64_t counter = 1; - struct kdbus_msg *msg = NULL; - - cancel_fd = eventfd(0, 0); - ASSERT_RETURN_VAL(cancel_fd >= 0, cancel_fd); - - cookie++; - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, pid); - - if (pid == 0) { - ret = kdbus_msg_send_sync(conn_dst, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - 100000000ULL, 0, conn_src->id, - cancel_fd); - ASSERT_EXIT(ret == -ECANCELED); - - _exit(EXIT_SUCCESS); - } - - ret = kdbus_msg_recv_poll(conn_src, 100, &msg, NULL); - ASSERT_RETURN(ret == 0 && msg->cookie == cookie); - - kdbus_msg_free(msg); - - ret = write(cancel_fd, &counter, sizeof(counter)); - ASSERT_RETURN(ret == sizeof(counter)); - - ret = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(ret >= 0, ret); - - if (WIFSIGNALED(status)) - return TEST_ERR; - - return (status == EXIT_SUCCESS) ? TEST_OK : TEST_ERR; -} - -static int no_cancel_sync(struct kdbus_conn *conn_src, - struct kdbus_conn *conn_dst) -{ - pid_t pid; - int cancel_fd; - int ret, status; - struct kdbus_msg *msg = NULL; - - /* pass eventfd, but never signal it so it shouldn't have any effect */ - - cancel_fd = eventfd(0, 0); - ASSERT_RETURN_VAL(cancel_fd >= 0, cancel_fd); - - cookie++; - pid = fork(); - ASSERT_RETURN_VAL(pid >= 0, pid); - - if (pid == 0) { - ret = kdbus_msg_send_sync(conn_dst, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - 100000000ULL, 0, conn_src->id, - cancel_fd); - ASSERT_EXIT(ret == 0); - - _exit(EXIT_SUCCESS); - } - - ret = kdbus_msg_recv_poll(conn_src, 100, &msg, NULL); - ASSERT_RETURN_VAL(ret == 0 && msg->cookie == cookie, -1); - - kdbus_msg_free(msg); - - ret = kdbus_msg_send_reply(conn_src, cookie, conn_dst->id); - ASSERT_RETURN_VAL(ret >= 0, ret); - - ret = waitpid(pid, &status, 0); - ASSERT_RETURN_VAL(ret >= 0, ret); - - if (WIFSIGNALED(status)) - return -1; - - return (status == EXIT_SUCCESS) ? 0 : -1; -} - -static void *run_thread_reply(void *data) -{ - int ret; - unsigned long status = TEST_OK; - - ret = kdbus_msg_recv_poll(conn_a, 3000, NULL, NULL); - if (ret < 0) - goto exit_thread; - - kdbus_printf("Thread received message, sending reply ...\n"); - - /* using an unknown cookie must fail */ - ret = kdbus_msg_send_reply(conn_a, ~cookie, conn_b->id); - if (ret != -EBADSLT) { - status = TEST_ERR; - goto exit_thread; - } - - ret = kdbus_msg_send_reply(conn_a, cookie, conn_b->id); - if (ret != 0) { - status = TEST_ERR; - goto exit_thread; - } - -exit_thread: - pthread_exit(NULL); - return (void *) status; -} - -int kdbus_test_sync_reply(struct kdbus_test_env *env) -{ - unsigned long status; - pthread_t thread; - int ret; - - conn_a = kdbus_hello(env->buspath, 0, NULL, 0); - conn_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_a && conn_b); - - pthread_create(&thread, NULL, run_thread_reply, NULL); - - ret = kdbus_msg_send_sync(conn_b, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - 5000000000ULL, 0, conn_a->id, -1); - - pthread_join(thread, (void *) &status); - ASSERT_RETURN(status == 0); - ASSERT_RETURN(ret == 0); - - ret = interrupt_sync(conn_a, conn_b); - ASSERT_RETURN(ret == 0); - - ret = close_epipe_sync(env->buspath); - ASSERT_RETURN(ret == 0); - - ret = cancel_fd_sync(conn_a, conn_b); - ASSERT_RETURN(ret == 0); - - ret = no_cancel_sync(conn_a, conn_b); - ASSERT_RETURN(ret == 0); - - kdbus_printf("-- closing bus connections\n"); - - kdbus_conn_free(conn_a); - kdbus_conn_free(conn_b); - - return TEST_OK; -} - -#define BYEBYE_ME ((void*)0L) -#define BYEBYE_THEM ((void*)1L) - -static void *run_thread_byebye(void *data) -{ - struct kdbus_cmd cmd_byebye = { .size = sizeof(cmd_byebye) }; - int ret; - - ret = kdbus_msg_recv_poll(conn_a, 3000, NULL, NULL); - if (ret == 0) { - kdbus_printf("Thread received message, invoking BYEBYE ...\n"); - kdbus_msg_recv(conn_a, NULL, NULL); - if (data == BYEBYE_ME) - kdbus_cmd_byebye(conn_b->fd, &cmd_byebye); - else if (data == BYEBYE_THEM) - kdbus_cmd_byebye(conn_a->fd, &cmd_byebye); - } - - pthread_exit(NULL); - return NULL; -} - -int kdbus_test_sync_byebye(struct kdbus_test_env *env) -{ - pthread_t thread; - int ret; - - /* - * This sends a synchronous message to a thread, which waits until it - * received the message and then invokes BYEBYE on the *ORIGINAL* - * connection. That is, on the same connection that synchronously waits - * for an reply. - * This should properly wake the connection up and cause ECONNRESET as - * the connection is disconnected now. - * - * The second time, we do the same but invoke BYEBYE on the *TARGET* - * connection. This should also wake up the synchronous sender as the - * reply cannot be sent by a disconnected target. - */ - - conn_a = kdbus_hello(env->buspath, 0, NULL, 0); - conn_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_a && conn_b); - - pthread_create(&thread, NULL, run_thread_byebye, BYEBYE_ME); - - ret = kdbus_msg_send_sync(conn_b, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - 5000000000ULL, 0, conn_a->id, -1); - - ASSERT_RETURN(ret == -ECONNRESET); - - pthread_join(thread, NULL); - - kdbus_conn_free(conn_a); - kdbus_conn_free(conn_b); - - conn_a = kdbus_hello(env->buspath, 0, NULL, 0); - conn_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_a && conn_b); - - pthread_create(&thread, NULL, run_thread_byebye, BYEBYE_THEM); - - ret = kdbus_msg_send_sync(conn_b, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - 5000000000ULL, 0, conn_a->id, -1); - - ASSERT_RETURN(ret == -EPIPE); - - pthread_join(thread, NULL); - - kdbus_conn_free(conn_a); - kdbus_conn_free(conn_b); - - return TEST_OK; -} diff --git a/tools/testing/selftests/kdbus/test-timeout.c b/tools/testing/selftests/kdbus/test-timeout.c deleted file mode 100644 index cfd193066..000000000 --- a/tools/testing/selftests/kdbus/test-timeout.c +++ /dev/null @@ -1,99 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <time.h> -#include <fcntl.h> -#include <stdlib.h> -#include <stddef.h> -#include <unistd.h> -#include <stdint.h> -#include <errno.h> -#include <assert.h> -#include <poll.h> -#include <stdbool.h> - -#include "kdbus-api.h" -#include "kdbus-test.h" -#include "kdbus-util.h" -#include "kdbus-enum.h" - -int timeout_msg_recv(struct kdbus_conn *conn, uint64_t *expected) -{ - struct kdbus_cmd_recv recv = { .size = sizeof(recv) }; - struct kdbus_msg *msg; - int ret; - - ret = kdbus_cmd_recv(conn->fd, &recv); - if (ret < 0) { - kdbus_printf("error receiving message: %d (%m)\n", ret); - return ret; - } - - msg = (struct kdbus_msg *)(conn->buf + recv.msg.offset); - - ASSERT_RETURN_VAL(msg->payload_type == KDBUS_PAYLOAD_KERNEL, -EINVAL); - ASSERT_RETURN_VAL(msg->src_id == KDBUS_SRC_ID_KERNEL, -EINVAL); - ASSERT_RETURN_VAL(msg->dst_id == conn->id, -EINVAL); - - *expected &= ~(1ULL << msg->cookie_reply); - kdbus_printf("Got message timeout for cookie %llu\n", - msg->cookie_reply); - - ret = kdbus_free(conn, recv.msg.offset); - if (ret < 0) - return ret; - - return 0; -} - -int kdbus_test_timeout(struct kdbus_test_env *env) -{ - struct kdbus_conn *conn_a, *conn_b; - struct pollfd fd; - int ret, i, n_msgs = 4; - uint64_t expected = 0; - uint64_t cookie = 0xdeadbeef; - - conn_a = kdbus_hello(env->buspath, 0, NULL, 0); - conn_b = kdbus_hello(env->buspath, 0, NULL, 0); - ASSERT_RETURN(conn_a && conn_b); - - fd.fd = conn_b->fd; - - /* - * send messages that expect a reply (within 100 msec), - * but never answer it. - */ - for (i = 0; i < n_msgs; i++, cookie++) { - kdbus_printf("Sending message with cookie %llu ...\n", - (unsigned long long)cookie); - ASSERT_RETURN(kdbus_msg_send(conn_b, NULL, cookie, - KDBUS_MSG_EXPECT_REPLY, - (i + 1) * 100ULL * 1000000ULL, 0, - conn_a->id) == 0); - expected |= 1ULL << cookie; - } - - for (;;) { - fd.events = POLLIN | POLLPRI | POLLHUP; - fd.revents = 0; - - ret = poll(&fd, 1, (n_msgs + 1) * 100); - if (ret == 0) - kdbus_printf("--- timeout\n"); - if (ret <= 0) - break; - - if (fd.revents & POLLIN) - ASSERT_RETURN(!timeout_msg_recv(conn_b, &expected)); - - if (expected == 0) - break; - } - - ASSERT_RETURN(expected == 0); - - kdbus_conn_free(conn_a); - kdbus_conn_free(conn_b); - - return TEST_OK; -} |