15057632786

Committed 15 May 2025 09:01PM UTC coverage: 72.267% (+0.02%) from 72.244%

Build # 15057632786

Build Type

push

github

Committed by

bluca

Commit Message

man: document how to hook stuff into system wakeup

Fixes: #6364

Run Details

298523 of 413084 relevant lines covered (72.27%)

738132.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

9.68

/src/test/test-socket-bind.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "bpf-socket-bind.h"
#include "load-fragment.h"
#include "manager.h"
#include "process-util.h"
#include "rlimit-util.h"
#include "rm-rf.h"
#include "service.h"
#include "strv.h"
#include "tests.h"
#include "unit.h"
#include "virt.h"

static int find_netcat_executable(char **ret_path) {
        char **candidates = STRV_MAKE("ncat", "nc", "netcat");
        int r = 0;

        STRV_FOREACH(c, candidates) {
                r = find_executable(*c, ret_path);
                if (r == 0)
                        break;
        }

        return r;
}

static int test_socket_bind(
                Manager *m,
                const char *unit_name,
                const char *netcat_path,
                const char *port,
                char **allow_rules,
                char **deny_rules) {
        _cleanup_free_ char *exec_start = NULL;
        _cleanup_(unit_freep) Unit *u = NULL;
        CGroupContext *cc = NULL;
        int cld_code, r;

        assert_se(u = unit_new(m, sizeof(Service)));
        assert_se(unit_add_name(u, unit_name) == 0);
        assert_se(cc = unit_get_cgroup_context(u));

        STRV_FOREACH(rule, allow_rules) {
                r = config_parse_cgroup_socket_bind(
                                u->id, "filename", 1, "Service", 1, "SocketBindAllow", 0,
                                *rule, &cc->socket_bind_allow, u);
                if (r < 0)
                        return log_unit_error_errno(u, r, "Failed to parse SocketBindAllow: %m");
        }

        fprintf(stderr, "SocketBindAllow: ");
        cgroup_context_dump_socket_bind_items(cc->socket_bind_allow, stderr);
        fputc('\n', stderr);

        STRV_FOREACH(rule, deny_rules) {
                r = config_parse_cgroup_socket_bind(
                                u->id, "filename", 1, "Service", 1, "SocketBindDeny", 0,
                                *rule, &cc->socket_bind_deny, u);
                if (r < 0)
                        return log_unit_error_errno(u, r, "Failed to parse SocketBindDeny: %m");
        }

        fprintf(stderr, "SocketBindDeny: ");
        cgroup_context_dump_socket_bind_items(cc->socket_bind_deny, stderr);
        fputc('\n', stderr);

        exec_start = strjoin("-timeout --preserve-status -sSIGTERM 1s ", netcat_path, " -l ", port, " -vv");
        ASSERT_NOT_NULL(exec_start);

        r = config_parse_exec(u->id, "filename", 1, "Service", 1, "ExecStart",
                        SERVICE_EXEC_START, exec_start, SERVICE(u)->exec_command, u);
        if (r < 0)
                return log_error_errno(r, "Failed to parse ExecStart");

        SERVICE(u)->type = SERVICE_ONESHOT;
        u->load_state = UNIT_LOADED;

        ASSERT_OK(unit_patch_contexts(u));
        r = unit_start(u, NULL);
        if (r < 0)
                return log_error_errno(r, "Unit start failed %m");

        while (!IN_SET(SERVICE(u)->state, SERVICE_DEAD, SERVICE_FAILED)) {
                r = sd_event_run(m->event, UINT64_MAX);
                if (r < 0)
                        return log_error_errno(r, "Event run failed %m");
        }

        cld_code = SERVICE(u)->exec_command[SERVICE_EXEC_START]->exec_status.code;
        if (cld_code != CLD_EXITED)
                return log_error_errno(SYNTHETIC_ERRNO(EBUSY), "ExecStart didn't exited, code='%s'", sigchld_code_to_string(cld_code));

        if (SERVICE(u)->state != SERVICE_DEAD)
                return log_error_errno(SYNTHETIC_ERRNO(EBUSY), "Service is not dead");

        return 0;
}

int main(int argc, char *argv[]) {
        _cleanup_free_ char *unit_dir = NULL, *netcat_path = NULL;
        _cleanup_(rm_rf_physical_and_freep) char *runtime_dir = NULL;
        _cleanup_(manager_freep) Manager *m = NULL;
        struct rlimit rl;
        int r;

        test_setup_logging(LOG_DEBUG);

        if (detect_container() > 0)
                return log_tests_skipped("test-socket-bind fails inside LXC and Docker containers: https://github.com/systemd/systemd/issues/9666");

        assert_se(getrlimit(RLIMIT_MEMLOCK, &rl) >= 0);
        rl.rlim_cur = rl.rlim_max = MAX(rl.rlim_max, CAN_MEMLOCK_SIZE);
        (void) setrlimit_closest(RLIMIT_MEMLOCK, &rl);

        if (!can_memlock())
                return log_tests_skipped("Can't use mlock()");

        r = bpf_socket_bind_supported();
        if (r <= 0)
                return log_tests_skipped("socket-bind is not supported");

        if (find_netcat_executable(&netcat_path) != 0)
                return log_tests_skipped("Cannot find netcat executable");

        r = enter_cgroup_subroot(NULL);
        if (r == -ENOMEDIUM)
                return log_tests_skipped("cgroupfs not available");

        ASSERT_OK(get_testdata_dir("units", &unit_dir));
        ASSERT_OK(setenv_unit_path(unit_dir));
        assert_se(runtime_dir = setup_fake_runtime_dir());

        assert_se(manager_new(RUNTIME_SCOPE_USER, MANAGER_TEST_RUN_BASIC, &m) >= 0);
        assert_se(manager_startup(m, NULL, NULL, NULL) >= 0);

        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "2000", STRV_MAKE("2000"), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "2000", STRV_MAKE("ipv6:2001-2002"), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("ipv4:6666", "6667"), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("6667", "6668", ""), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "7777", STRV_MAKE_EMPTY, STRV_MAKE_EMPTY) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "8888", STRV_MAKE("any"), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "8888", STRV_MAKE("ipv6:tcp:8888-8889"), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "10000", STRV_MAKE("ipv6:udp:9999-10000"), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("ipv4:tcp:6666"), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("ipv4:udp:6666"), STRV_MAKE("any")) >= 0);
        assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("tcp:6666"), STRV_MAKE("any")) >= 0);

        return 0;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "bpf-socket-bind.h"
4	#include "load-fragment.h"
5	#include "manager.h"
6	#include "process-util.h"
7	#include "rlimit-util.h"
8	#include "rm-rf.h"
9	#include "service.h"
10	#include "strv.h"
11	#include "tests.h"
12	#include "unit.h"
13	#include "virt.h"
14
15	static int find_netcat_executable(char **ret_path) {	×
16	char **candidates = STRV_MAKE("ncat", "nc", "netcat");	×
17	int r = 0;	×
18
19	STRV_FOREACH(c, candidates) {	×
20	r = find_executable(*c, ret_path);	×
21	if (r == 0)	×
22	break;
23	}
24
25	return r;	×
26	}
27
28	static int test_socket_bind(	×
29	Manager *m,
30	const char *unit_name,
31	const char *netcat_path,
32	const char *port,
33	char **allow_rules,
34	char **deny_rules) {
35	_cleanup_free_ char *exec_start = NULL;	×
36	_cleanup_(unit_freep) Unit *u = NULL;	×
37	CGroupContext *cc = NULL;	×
38	int cld_code, r;	×
39
40	assert_se(u = unit_new(m, sizeof(Service)));	×
41	assert_se(unit_add_name(u, unit_name) == 0);	×
42	assert_se(cc = unit_get_cgroup_context(u));	×
43
44	STRV_FOREACH(rule, allow_rules) {	×
45	r = config_parse_cgroup_socket_bind(	×
46	u->id, "filename", 1, "Service", 1, "SocketBindAllow", 0,	×
47	*rule, &cc->socket_bind_allow, u);	×
48	if (r < 0)	×
49	return log_unit_error_errno(u, r, "Failed to parse SocketBindAllow: %m");	×
50	}
51
52	fprintf(stderr, "SocketBindAllow: ");	×
53	cgroup_context_dump_socket_bind_items(cc->socket_bind_allow, stderr);	×
54	fputc('\n', stderr);	×
55
56	STRV_FOREACH(rule, deny_rules) {	×
57	r = config_parse_cgroup_socket_bind(	×
58	u->id, "filename", 1, "Service", 1, "SocketBindDeny", 0,	×
59	*rule, &cc->socket_bind_deny, u);	×
60	if (r < 0)	×
61	return log_unit_error_errno(u, r, "Failed to parse SocketBindDeny: %m");	×
62	}
63
64	fprintf(stderr, "SocketBindDeny: ");	×
65	cgroup_context_dump_socket_bind_items(cc->socket_bind_deny, stderr);	×
66	fputc('\n', stderr);	×
67
68	exec_start = strjoin("-timeout --preserve-status -sSIGTERM 1s ", netcat_path, " -l ", port, " -vv");	×
69	ASSERT_NOT_NULL(exec_start);	×
70
71	r = config_parse_exec(u->id, "filename", 1, "Service", 1, "ExecStart",	×
72	SERVICE_EXEC_START, exec_start, SERVICE(u)->exec_command, u);	×
73	if (r < 0)	×
74	return log_error_errno(r, "Failed to parse ExecStart");	×
75
76	SERVICE(u)->type = SERVICE_ONESHOT;	×
77	u->load_state = UNIT_LOADED;	×
78
79	ASSERT_OK(unit_patch_contexts(u));	×
80	r = unit_start(u, NULL);	×
81	if (r < 0)	×
82	return log_error_errno(r, "Unit start failed %m");	×
83
84	while (!IN_SET(SERVICE(u)->state, SERVICE_DEAD, SERVICE_FAILED)) {	×
85	r = sd_event_run(m->event, UINT64_MAX);	×
86	if (r < 0)	×
87	return log_error_errno(r, "Event run failed %m");	×
88	}
89
90	cld_code = SERVICE(u)->exec_command[SERVICE_EXEC_START]->exec_status.code;	×
91	if (cld_code != CLD_EXITED)	×
92	return log_error_errno(SYNTHETIC_ERRNO(EBUSY), "ExecStart didn't exited, code='%s'", sigchld_code_to_string(cld_code));	×
93
94	if (SERVICE(u)->state != SERVICE_DEAD)	×
95	return log_error_errno(SYNTHETIC_ERRNO(EBUSY), "Service is not dead");	×
96
97	return 0;
98	}
99
100	int main(int argc, char *argv[]) {	1✔
101	_cleanup_free_ char unit_dir = NULL, netcat_path = NULL;	1✔
102	_cleanup_(rm_rf_physical_and_freep) char *runtime_dir = NULL;	1✔
103	_cleanup_(manager_freep) Manager *m = NULL;	1✔
104	struct rlimit rl;	1✔
105	int r;	1✔
106
107	test_setup_logging(LOG_DEBUG);	1✔
108
109	if (detect_container() > 0)	1✔
110	return log_tests_skipped("test-socket-bind fails inside LXC and Docker containers: https://github.com/systemd/systemd/issues/9666");	1✔
111
112	assert_se(getrlimit(RLIMIT_MEMLOCK, &rl) >= 0);	×
113	rl.rlim_cur = rl.rlim_max = MAX(rl.rlim_max, CAN_MEMLOCK_SIZE);	×
114	(void) setrlimit_closest(RLIMIT_MEMLOCK, &rl);	×
115
116	if (!can_memlock())	×
117	return log_tests_skipped("Can't use mlock()");	×
118
119	r = bpf_socket_bind_supported();	×
120	if (r <= 0)	×
121	return log_tests_skipped("socket-bind is not supported");	×
122
123	if (find_netcat_executable(&netcat_path) != 0)	×
124	return log_tests_skipped("Cannot find netcat executable");	×
125
126	r = enter_cgroup_subroot(NULL);	×
127	if (r == -ENOMEDIUM)	×
128	return log_tests_skipped("cgroupfs not available");	×
129
130	ASSERT_OK(get_testdata_dir("units", &unit_dir));	×
131	ASSERT_OK(setenv_unit_path(unit_dir));	×
132	assert_se(runtime_dir = setup_fake_runtime_dir());	×
133
134	assert_se(manager_new(RUNTIME_SCOPE_USER, MANAGER_TEST_RUN_BASIC, &m) >= 0);	×
135	assert_se(manager_startup(m, NULL, NULL, NULL) >= 0);	×
136
137	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "2000", STRV_MAKE("2000"), STRV_MAKE("any")) >= 0);	×
138	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "2000", STRV_MAKE("ipv6:2001-2002"), STRV_MAKE("any")) >= 0);	×
139	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("ipv4:6666", "6667"), STRV_MAKE("any")) >= 0);	×
140	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("6667", "6668", ""), STRV_MAKE("any")) >= 0);	×
141	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "7777", STRV_MAKE_EMPTY, STRV_MAKE_EMPTY) >= 0);	×
142	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "8888", STRV_MAKE("any"), STRV_MAKE("any")) >= 0);	×
143	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "8888", STRV_MAKE("ipv6:tcp:8888-8889"), STRV_MAKE("any")) >= 0);	×
144	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "10000", STRV_MAKE("ipv6:udp:9999-10000"), STRV_MAKE("any")) >= 0);	×
145	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("ipv4:tcp:6666"), STRV_MAKE("any")) >= 0);	×
146	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("ipv4:udp:6666"), STRV_MAKE("any")) >= 0);	×
147	assert_se(test_socket_bind(m, "socket_bind_test.service", netcat_path, "6666", STRV_MAKE("tcp:6666"), STRV_MAKE("any")) >= 0);	×
148
149	return 0;	×
150	}

systemd / systemd / 15057632786

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous