1 // SPDX-License-Identifier: GPL-2.0
2 #include <test_progs.h>
3 #include "cgroup_helpers.h"
4 
5 #define SOL_CUSTOM			0xdeadbeef
6 #define CUSTOM_INHERIT1			0
7 #define CUSTOM_INHERIT2			1
8 #define CUSTOM_LISTENER			2
9 
10 static int connect_to_server(int server_fd)
11 {
12 	struct sockaddr_storage addr;
13 	socklen_t len = sizeof(addr);
14 	int fd;
15 
16 	fd = socket(AF_INET, SOCK_STREAM, 0);
17 	if (fd < 0) {
18 		log_err("Failed to create client socket");
19 		return -1;
20 	}
21 
22 	if (getsockname(server_fd, (struct sockaddr *)&addr, &len)) {
23 		log_err("Failed to get server addr");
24 		goto out;
25 	}
26 
27 	if (connect(fd, (const struct sockaddr *)&addr, len) < 0) {
28 		log_err("Fail to connect to server");
29 		goto out;
30 	}
31 
32 	return fd;
33 
34 out:
35 	close(fd);
36 	return -1;
37 }
38 
39 static int verify_sockopt(int fd, int optname, const char *msg, char expected)
40 {
41 	socklen_t optlen = 1;
42 	char buf = 0;
43 	int err;
44 
45 	err = getsockopt(fd, SOL_CUSTOM, optname, &buf, &optlen);
46 	if (err) {
47 		log_err("%s: failed to call getsockopt", msg);
48 		return 1;
49 	}
50 
51 	printf("%s %d: got=0x%x ? expected=0x%x\n", msg, optname, buf, expected);
52 
53 	if (buf != expected) {
54 		log_err("%s: unexpected getsockopt value %d != %d", msg,
55 			buf, expected);
56 		return 1;
57 	}
58 
59 	return 0;
60 }
61 
62 static pthread_mutex_t server_started_mtx = PTHREAD_MUTEX_INITIALIZER;
63 static pthread_cond_t server_started = PTHREAD_COND_INITIALIZER;
64 
65 static void *server_thread(void *arg)
66 {
67 	struct sockaddr_storage addr;
68 	socklen_t len = sizeof(addr);
69 	int fd = *(int *)arg;
70 	int client_fd;
71 	int err = 0;
72 
73 	err = listen(fd, 1);
74 
75 	pthread_mutex_lock(&server_started_mtx);
76 	pthread_cond_signal(&server_started);
77 	pthread_mutex_unlock(&server_started_mtx);
78 
79 	if (CHECK_FAIL(err < 0)) {
80 		perror("Failed to listed on socket");
81 		return NULL;
82 	}
83 
84 	err += verify_sockopt(fd, CUSTOM_INHERIT1, "listen", 1);
85 	err += verify_sockopt(fd, CUSTOM_INHERIT2, "listen", 1);
86 	err += verify_sockopt(fd, CUSTOM_LISTENER, "listen", 1);
87 
88 	client_fd = accept(fd, (struct sockaddr *)&addr, &len);
89 	if (CHECK_FAIL(client_fd < 0)) {
90 		perror("Failed to accept client");
91 		return NULL;
92 	}
93 
94 	err += verify_sockopt(client_fd, CUSTOM_INHERIT1, "accept", 1);
95 	err += verify_sockopt(client_fd, CUSTOM_INHERIT2, "accept", 1);
96 	err += verify_sockopt(client_fd, CUSTOM_LISTENER, "accept", 0);
97 
98 	close(client_fd);
99 
100 	return (void *)(long)err;
101 }
102 
103 static int start_server(void)
104 {
105 	struct sockaddr_in addr = {
106 		.sin_family = AF_INET,
107 		.sin_addr.s_addr = htonl(INADDR_LOOPBACK),
108 	};
109 	char buf;
110 	int err;
111 	int fd;
112 	int i;
113 
114 	fd = socket(AF_INET, SOCK_STREAM, 0);
115 	if (fd < 0) {
116 		log_err("Failed to create server socket");
117 		return -1;
118 	}
119 
120 	for (i = CUSTOM_INHERIT1; i <= CUSTOM_LISTENER; i++) {
121 		buf = 0x01;
122 		err = setsockopt(fd, SOL_CUSTOM, i, &buf, 1);
123 		if (err) {
124 			log_err("Failed to call setsockopt(%d)", i);
125 			close(fd);
126 			return -1;
127 		}
128 	}
129 
130 	if (bind(fd, (const struct sockaddr *)&addr, sizeof(addr)) < 0) {
131 		log_err("Failed to bind socket");
132 		close(fd);
133 		return -1;
134 	}
135 
136 	return fd;
137 }
138 
139 static int prog_attach(struct bpf_object *obj, int cgroup_fd, const char *title)
140 {
141 	enum bpf_attach_type attach_type;
142 	enum bpf_prog_type prog_type;
143 	struct bpf_program *prog;
144 	int err;
145 
146 	err = libbpf_prog_type_by_name(title, &prog_type, &attach_type);
147 	if (err) {
148 		log_err("Failed to deduct types for %s BPF program", title);
149 		return -1;
150 	}
151 
152 	prog = bpf_object__find_program_by_title(obj, title);
153 	if (!prog) {
154 		log_err("Failed to find %s BPF program", title);
155 		return -1;
156 	}
157 
158 	err = bpf_prog_attach(bpf_program__fd(prog), cgroup_fd,
159 			      attach_type, 0);
160 	if (err) {
161 		log_err("Failed to attach %s BPF program", title);
162 		return -1;
163 	}
164 
165 	return 0;
166 }
167 
168 static void run_test(int cgroup_fd)
169 {
170 	struct bpf_prog_load_attr attr = {
171 		.file = "./sockopt_inherit.o",
172 	};
173 	int server_fd = -1, client_fd;
174 	struct bpf_object *obj;
175 	void *server_err;
176 	pthread_t tid;
177 	int ignored;
178 	int err;
179 
180 	err = bpf_prog_load_xattr(&attr, &obj, &ignored);
181 	if (CHECK_FAIL(err))
182 		return;
183 
184 	err = prog_attach(obj, cgroup_fd, "cgroup/getsockopt");
185 	if (CHECK_FAIL(err))
186 		goto close_bpf_object;
187 
188 	err = prog_attach(obj, cgroup_fd, "cgroup/setsockopt");
189 	if (CHECK_FAIL(err))
190 		goto close_bpf_object;
191 
192 	server_fd = start_server();
193 	if (CHECK_FAIL(server_fd < 0))
194 		goto close_bpf_object;
195 
196 	pthread_mutex_lock(&server_started_mtx);
197 	if (CHECK_FAIL(pthread_create(&tid, NULL, server_thread,
198 				      (void *)&server_fd))) {
199 		pthread_mutex_unlock(&server_started_mtx);
200 		goto close_server_fd;
201 	}
202 	pthread_cond_wait(&server_started, &server_started_mtx);
203 	pthread_mutex_unlock(&server_started_mtx);
204 
205 	client_fd = connect_to_server(server_fd);
206 	if (CHECK_FAIL(client_fd < 0))
207 		goto close_server_fd;
208 
209 	CHECK_FAIL(verify_sockopt(client_fd, CUSTOM_INHERIT1, "connect", 0));
210 	CHECK_FAIL(verify_sockopt(client_fd, CUSTOM_INHERIT2, "connect", 0));
211 	CHECK_FAIL(verify_sockopt(client_fd, CUSTOM_LISTENER, "connect", 0));
212 
213 	pthread_join(tid, &server_err);
214 
215 	err = (int)(long)server_err;
216 	CHECK_FAIL(err);
217 
218 	close(client_fd);
219 
220 close_server_fd:
221 	close(server_fd);
222 close_bpf_object:
223 	bpf_object__close(obj);
224 }
225 
226 void test_sockopt_inherit(void)
227 {
228 	int cgroup_fd;
229 
230 	cgroup_fd = test__join_cgroup("/sockopt_inherit");
231 	if (CHECK_FAIL(cgroup_fd < 0))
232 		return;
233 
234 	run_test(cgroup_fd);
235 	close(cgroup_fd);
236 }
237