Debian Codegraph @

src/libsystemd-network/test-dhcp-relay.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <net/if_arp.h>
4 #include <sys/socket.h>
5
6 #include "sd-event.h"
7
8 #include "dhcp-message.h"
9 #include "dhcp-relay-internal.h"
10 #include "ether-addr-util.h"
11 #include "fd-util.h"
12 #include "hashmap.h"
13 #include "in-addr-util.h"
14 #include "iovec-util.h"
15 #include "ip-util.h"
16 #include "socket-util.h"
17 #include "tests.h"
18
19 static uint32_t xid = 12345;
20
21 static const struct hw_addr_data hw_addr = {
22 .length = ETH_ALEN,
23 .ether = {{ 'A', 'B', 'C', '1', '2', '3' }},
24 };
25
26 static unsigned fake_server_message_count = 0;
27 static unsigned fake_client_message_count = 0;
28
29 TEST(sd_dhcp_relay_ref_unref) {
30 _cleanup_(sd_dhcp_relay_unrefp) sd_dhcp_relay *relay = NULL;
31 _cleanup_(sd_dhcp_relay_interface_unrefp) sd_dhcp_relay_interface *upstream = NULL, *downstream = NULL;
32
33 ASSERT_OK(sd_dhcp_relay_new(&relay));
34 ASSERT_NOT_NULL(relay);
35
36 ASSERT_OK(sd_dhcp_relay_add_interface(relay, 4242, /* is_upstream= */ true, &upstream));
37 ASSERT_OK(sd_dhcp_relay_add_interface(relay, 4343, /* is_upstream= */ false, &downstream));
38 ASSERT_PTR_EQ(hashmap_get(relay->interfaces, INT_TO_PTR(4242)), upstream);
39 ASSERT_PTR_EQ(hashmap_get(relay->interfaces, INT_TO_PTR(4343)), downstream);
40
41 /* Each interface holds a reference to the sd_dhcp_relay object, so we can safely drop our reference. */
42 relay = sd_dhcp_relay_unref(relay);
43 ASSERT_PTR_EQ(hashmap_get(upstream->relay->interfaces, INT_TO_PTR(4242)), upstream);
44 ASSERT_PTR_EQ(hashmap_get(downstream->relay->interfaces, INT_TO_PTR(4343)), downstream);
45
46 /* Still upstream interface has the reference. */
47 downstream = sd_dhcp_relay_interface_unref(downstream);
48 ASSERT_PTR_EQ(hashmap_get(upstream->relay->interfaces, INT_TO_PTR(4242)), upstream);
49 ASSERT_FALSE(hashmap_contains(upstream->relay->interfaces, INT_TO_PTR(4343)));
50
51 /* Everything should be freed with this. */
52 upstream = sd_dhcp_relay_interface_unref(upstream);
53
54 /* Let's check the inverse order. */
55 ASSERT_OK(sd_dhcp_relay_new(&relay));
56 ASSERT_OK(sd_dhcp_relay_add_interface(relay, 4242, /* is_upstream= */ true, &upstream));
57 ASSERT_OK(sd_dhcp_relay_add_interface(relay, 4343, /* is_upstream= */ false, &downstream));
58 ASSERT_PTR_EQ(hashmap_get(relay->interfaces, INT_TO_PTR(4242)), upstream);
59 ASSERT_PTR_EQ(hashmap_get(relay->interfaces, INT_TO_PTR(4343)), downstream);
60
61 downstream = sd_dhcp_relay_interface_unref(downstream);
62 ASSERT_PTR_EQ(hashmap_get(relay->interfaces, INT_TO_PTR(4242)), upstream);
63 ASSERT_FALSE(hashmap_contains(relay->interfaces, INT_TO_PTR(4343)));
64
65 upstream = sd_dhcp_relay_interface_unref(upstream);
66 ASSERT_FALSE(hashmap_contains(relay->interfaces, INT_TO_PTR(4242)));
67 ASSERT_FALSE(hashmap_contains(relay->interfaces, INT_TO_PTR(4343)));
68 }
69
70 static void send_message(int fd, sd_dhcp_message *m) {
71 ASSERT_OK(dhcp_message_send_udp(
72 m,
73 fd,
74 /* src_addr= */ INADDR_ANY,
75 /* dst_addr= */ INADDR_ANY,
76 /* dst_port= */ 0));
77 }
78
79 static int fake_server_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
80 sd_dhcp_relay *relay = ASSERT_PTR(userdata);
81
82 fake_server_message_count++;
83 log_debug("%s: count=%u", __func__, fake_server_message_count);
84
85 ssize_t buflen = ASSERT_OK_POSITIVE(next_datagram_size_fd(fd));
86 _cleanup_free_ void *buf = ASSERT_NOT_NULL(malloc0(buflen));
87
88 struct msghdr msg = {
89 .msg_iov = &IOVEC_MAKE(buf, buflen),
90 .msg_iovlen = 1,
91 };
92 ssize_t len = ASSERT_OK_ERRNO(recvmsg_safe(fd, &msg, MSG_DONTWAIT));
93
94 _cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *m = NULL;
95 ASSERT_OK(dhcp_message_parse(
96 &IOVEC_MAKE(buf, len),
97 BOOTREQUEST,
98 &xid,
99 ARPHRD_ETHER,
100 &hw_addr,
101 &m));
102
103 ASSERT_EQ(m->header.hops, 1u);
104
105 sd_dhcp_relay_interface *downstream;
106 ASSERT_OK(downstream_get(relay, m, &downstream));
107 ASSERT_FALSE(downstream->upstream);
108
109 ASSERT_EQ(m->header.giaddr, downstream->gateway_address.s_addr);
110
111 _cleanup_(tlv_unrefp) TLV *agent_info = NULL;
112 ASSERT_OK(dhcp_message_get_option_sub_tlv(
113 m,
114 SD_DHCP_OPTION_RELAY_AGENT_INFORMATION,
115 TLV_DHCP4_SUBOPTION,
116 &agent_info));
117
118 void *key, *value;
119 HASHMAP_FOREACH_KEY(value, key, agent_info->entries) {
120 uint32_t tag = PTR_TO_UINT32(key);
121 _cleanup_(iovec_done) struct iovec iov = {};
122 ASSERT_OK(tlv_get_alloc(agent_info, tag, &iov));
123
124 switch (tag) {
125 case SD_DHCP_RELAY_AGENT_CIRCUIT_ID:
126 ASSERT_TRUE(iovec_equal(&iov, &downstream->circuit_id));
127 break;
128 case SD_DHCP_RELAY_AGENT_REMOTE_ID:
129 ASSERT_TRUE(iovec_equal(&iov, &relay->remote_id));
130 break;
131 case SD_DHCP_RELAY_AGENT_LINK_SELECTION:
132 ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE(&downstream->address, sizeof(struct in_addr))));
133 break;
134 case SD_DHCP_RELAY_AGENT_FLAGS: {
135 ASSERT_TRUE(relay->server_identifier_override);
136 ASSERT_EQ(iov.iov_len, 1u);
137 uint8_t flags = *(uint8_t*) iov.iov_base;
138 /* In the unit test, we cannot detect if the message is broadcast or unicast because
139 * AF_UNIX is used; therefore, the unicast flag is not set. */
140 ASSERT_FALSE(FLAGS_SET(flags, DHCP_RELAY_AGENT_FLAG_UNICAST));
141 break;
142 }
143 case SD_DHCP_RELAY_AGENT_SERVER_IDENTIFIER_OVERRIDE:
144 ASSERT_TRUE(relay->server_identifier_override);
145 ASSERT_TRUE(iovec_equal(&iov, &IOVEC_MAKE(&downstream->address, sizeof(struct in_addr))));
146 break;
147 case SD_DHCP_RELAY_AGENT_VIRTUAL_SUBNET_SELECTION:
148 ASSERT_TRUE(iovec_equal(&iov, &downstream->vss));
149 break;
150 default:
151 assert_not_reached();
152 }
153 }
154
155 uint8_t t;
156 ASSERT_OK(dhcp_message_get_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, &t));
157
158 switch (fake_server_message_count) {
159 case 1:
160 ASSERT_EQ(t, DHCP_DISCOVER);
161 break;
162 case 2:
163 ASSERT_EQ(t, DHCP_REQUEST);
164 break;
165 case 3:
166 ASSERT_EQ(t, DHCP_RELEASE);
167
168 if (fake_client_message_count == 3)
169 ASSERT_OK(sd_event_exit(sd_event_source_get_event(s), 0));
170 break;
171 default:
172 assert_not_reached();
173 }
174
175 return 0;
176 }
177
178 static void fake_client_verify(int fd, uint8_t type, bool raw) {
179 ssize_t buflen = ASSERT_OK_POSITIVE(next_datagram_size_fd(fd));
180 _cleanup_free_ void *buf = ASSERT_NOT_NULL(malloc0(buflen));
181
182 struct msghdr msg = {
183 .msg_iov = &IOVEC_MAKE(buf, buflen),
184 .msg_iovlen = 1,
185 };
186 ssize_t len = ASSERT_OK_ERRNO(recvmsg_safe(fd, &msg, MSG_DONTWAIT));
187
188 struct iovec payload = IOVEC_MAKE(buf, len);
189 if (raw)
190 ASSERT_OK(udp_packet_verify(&payload, DHCP_PORT_CLIENT, /* checksum= */ true, &payload));
191
192 _cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *m = NULL;
193 ASSERT_OK(dhcp_message_parse(
194 &payload,
195 BOOTREPLY,
196 &xid,
197 ARPHRD_ETHER,
198 &hw_addr,
199 &m));
200
201 ASSERT_EQ(m->header.hops, 0u);
202 ASSERT_FALSE(dhcp_message_has_option(m, SD_DHCP_OPTION_RELAY_AGENT_INFORMATION));
203
204 uint8_t t;
205 ASSERT_OK(dhcp_message_get_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, &t));
206 ASSERT_EQ(t, type);
207 }
208
209 static int fake_client_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
210 fake_client_message_count++;
211 log_debug("%s: count=%u", __func__, fake_client_message_count);
212
213 switch (fake_client_message_count) {
214 case 1:
215 fake_client_verify(fd, DHCP_OFFER, /* raw= */ true);
216 break;
217 case 2:
218 fake_client_verify(fd, DHCP_ACK, /* raw= */ false);
219 break;
220 case 3:
221 fake_client_verify(fd, DHCP_NAK, /* raw= */ false);
222
223 if (fake_server_message_count == 3)
224 ASSERT_OK(sd_event_exit(sd_event_source_get_event(s), 0));
225 break;
226 default:
227 assert_not_reached();
228 }
229
230 return 0;
231 }
232
233 TEST(forwarding) {
234 union in_addr_union a;
235
236 _cleanup_(sd_event_unrefp) sd_event *e = NULL;
237 ASSERT_OK(sd_event_new(&e));
238
239 _cleanup_(sd_dhcp_relay_unrefp) sd_dhcp_relay *relay = NULL;
240 ASSERT_OK(sd_dhcp_relay_new(&relay));
241 ASSERT_OK(sd_dhcp_relay_attach_event(relay, e, SD_EVENT_PRIORITY_NORMAL));
242 ASSERT_OK(in_addr_from_string(AF_INET, "198.51.100.1", &a));
243 ASSERT_OK(sd_dhcp_relay_set_server_address(relay, &a.in));
244 ASSERT_OK(sd_dhcp_relay_set_remote_id(relay, &IOVEC_MAKE_STRING("test-remote-id")));
245 ASSERT_OK(sd_dhcp_relay_set_server_identifier_override(relay, true));
246
247 /* Setting up an upstream interface. */
248 _cleanup_(sd_dhcp_relay_interface_unrefp) sd_dhcp_relay_interface *upstream = NULL;
249 ASSERT_OK(sd_dhcp_relay_add_interface(relay, 4242, /* is_upstream= */ true, &upstream));
250 ASSERT_OK(sd_dhcp_relay_interface_set_ifname(upstream, "test-upstream"));
251 ASSERT_OK_ZERO(sd_dhcp_relay_interface_get_address(upstream, /* ret_address= */ NULL, /* ret_prefixlen= */ NULL));
252 ASSERT_OK(in_addr_from_string(AF_INET, "198.51.100.2", &a));
253 ASSERT_OK(sd_dhcp_relay_interface_set_address(upstream, &a.in, 24));
254 ASSERT_OK_POSITIVE(sd_dhcp_relay_interface_get_address(upstream, /* ret_address= */ NULL, /* ret_prefixlen= */ NULL));
255
256 _cleanup_close_pair_ int upstream_fd[2] = EBADF_PAIR;
257 ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, upstream_fd));
258 upstream->socket_fd = TAKE_FD(upstream_fd[0]);
259 ASSERT_OK(sd_dhcp_relay_interface_start(upstream));
260
261 /* IO event source for the server side. */
262 _cleanup_(sd_event_source_unrefp) sd_event_source *fake_server = NULL;
263 ASSERT_OK(sd_event_add_io(e, &fake_server, upstream_fd[1], EPOLLIN, fake_server_handler, relay));
264 ASSERT_OK(sd_event_source_set_priority(fake_server, SD_EVENT_PRIORITY_IMPORTANT));
265 ASSERT_OK(sd_event_source_set_description(fake_server, "fake-server-io-event-source"));
266
267 /* Setting up a downstream interface. */
268 _cleanup_(sd_dhcp_relay_interface_unrefp) sd_dhcp_relay_interface *downstream = NULL;
269 ASSERT_OK(sd_dhcp_relay_add_interface(relay, 4343, /* is_upstream= */ false, &downstream));
270 ASSERT_OK(sd_dhcp_relay_interface_set_ifname(downstream, "test-downstream"));
271 ASSERT_OK(in_addr_from_string(AF_INET, "192.0.2.1", &a));
272 ASSERT_OK(sd_dhcp_relay_interface_set_address(downstream, &a.in, 24));
273
274 ASSERT_OK(in_addr_from_string(AF_INET, "203.0.113.1", &a));
275 ASSERT_OK(sd_dhcp_relay_downstream_set_gateway_address(downstream, &a.in));
276 ASSERT_OK(sd_dhcp_relay_downstream_set_circuit_id(downstream, &IOVEC_MAKE_STRING("test-circuit-id")));
277 ASSERT_OK(sd_dhcp_relay_downstream_set_virtual_subnet_selection(downstream, &IOVEC_MAKE_STRING("test-virtual-net")));
278
279 _cleanup_close_pair_ int downstream_fd[2] = EBADF_PAIR;
280 ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, downstream_fd));
281 downstream->socket_fd = TAKE_FD(downstream_fd[0]);
282 ASSERT_OK(sd_dhcp_relay_interface_start(downstream));
283
284 /* IO event source for the client side. */
285 _cleanup_(sd_event_source_unrefp) sd_event_source *fake_client = NULL;
286 ASSERT_OK(sd_event_add_io(e, &fake_client, downstream_fd[1], EPOLLIN, fake_client_handler, relay));
287 ASSERT_OK(sd_event_source_set_priority(fake_client, SD_EVENT_PRIORITY_NORMAL));
288 ASSERT_OK(sd_event_source_set_description(fake_client, "fake-client-io-event-source"));
289
290 _cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *m = NULL;
291 ASSERT_OK(dhcp_message_new(&m));
292 ASSERT_OK(dhcp_message_init_header(
293 m,
294 BOOTREQUEST,
295 xid,
296 ARPHRD_ETHER,
297 &hw_addr));
298
299 /* Test: downstream -> upstream */
300 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, DHCP_DISCOVER));
301 send_message(downstream_fd[1], m);
302 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
303
304 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, DHCP_REQUEST));
305 send_message(downstream_fd[1], m);
306 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
307
308 /* Invalid message (unexpected BOOTP operation). */
309 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, 100));
310 m->header.op = BOOTREPLY;
311 send_message(downstream_fd[1], m);
312 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
313 m->header.op = BOOTREQUEST;
314
315 /* Invalid message (too large hops). */
316 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, 101));
317 m->header.hops = 16;
318 send_message(downstream_fd[1], m);
319 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
320 m->header.hops = 0;
321
322 /* Invalid message (invalid giaddr). */
323 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, 102));
324 m->header.giaddr = downstream->address.s_addr;
325 send_message(downstream_fd[1], m);
326 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
327 m->header.giaddr = INADDR_ANY;
328
329 /* Invalid message (unexpected relay agent information). */
330 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, 103));
331 ASSERT_OK(dhcp_message_append_option_flag(m, SD_DHCP_OPTION_RELAY_AGENT_INFORMATION));
332 send_message(downstream_fd[1], m);
333 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
334 dhcp_message_remove_option(m, SD_DHCP_OPTION_RELAY_AGENT_INFORMATION);
335
336 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, DHCP_RELEASE));
337 send_message(downstream_fd[1], m);
338 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
339
340 /* Test: upstream -> downstream */
341 m->header.op = BOOTREPLY;
342 m->header.giaddr = downstream->gateway_address.s_addr;
343 m->header.yiaddr = 0x12345678;
344
345 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, DHCP_OFFER));
346 send_message(upstream_fd[1], m);
347 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
348
349 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, DHCP_ACK));
350 m->header.ciaddr = 0x12345678;
351 send_message(upstream_fd[1], m);
352 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
353 m->header.ciaddr = 0;
354
355 /* Invalid message (unexpected BOOTP operation). */
356 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, 200));
357 m->header.op = BOOTREQUEST;
358 send_message(upstream_fd[1], m);
359 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
360 m->header.op = BOOTREPLY;
361
362 /* Invalid message (NULL giaddr). */
363 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, 201));
364 m->header.giaddr = INADDR_ANY;
365 send_message(upstream_fd[1], m);
366 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
367 m->header.giaddr = downstream->gateway_address.s_addr;
368
369 /* Invalid message (unexpected giaddr). */
370 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, 202));
371 m->header.giaddr = 1234567;
372 send_message(upstream_fd[1], m);
373 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
374 m->header.giaddr = downstream->gateway_address.s_addr;
375
376 ASSERT_OK(dhcp_message_append_option_u8(m, SD_DHCP_OPTION_MESSAGE_TYPE, DHCP_NAK));
377 send_message(upstream_fd[1], m);
378 dhcp_message_remove_option(m, SD_DHCP_OPTION_MESSAGE_TYPE);
379
380 ASSERT_OK(sd_event_loop(e));
381 }
382
383 DEFINE_TEST_MAIN(LOG_DEBUG);