Debian Codegraph @

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

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <netinet/ip.h>
4
5 #include "sd-event.h"
6
7 #include "alloc-util.h"
8 #include "dhcp-protocol.h"
9 #include "dhcp-relay-internal.h"
10 #include "errno-util.h"
11 #include "fd-util.h"
12 #include "hashmap.h"
13 #include "in-addr-util.h"
14 #include "iovec-util.h"
15 #include "socket-util.h"
16 #include "string-util.h"
17
18 static sd_dhcp_relay_interface* dhcp_relay_interface_free(sd_dhcp_relay_interface *interface) {
19 if (!interface)
20 return NULL;
21
22 assert(interface->relay);
23
24 sd_event_source_disable_unref(interface->io_event_source);
25 safe_close(interface->socket_fd);
26 safe_close(interface->raw_socket_fd);
27
28 if (interface->upstream)
29 upstream_done(interface);
30 else
31 downstream_done(interface);
32
33 hashmap_remove_value(interface->relay->interfaces, INT_TO_PTR(interface->ifindex), interface);
34 sd_dhcp_relay_unref(interface->relay);
35
36 free(interface->ifname);
37 return mfree(interface);
38 }
39
40 DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_relay_interface, sd_dhcp_relay_interface, dhcp_relay_interface_free);
41
42 int sd_dhcp_relay_add_interface(sd_dhcp_relay *relay, int ifindex, int is_upstream, sd_dhcp_relay_interface **ret) {
43 int r;
44
45 assert_return(relay, -EINVAL);
46 assert_return(ifindex > 0 || (ifindex == DHCP_RELAY_IFINDEX_UNBOUND && !!is_upstream), -EINVAL);
47 assert_return(ret, -EINVAL);
48
49 _cleanup_(sd_dhcp_relay_interface_unrefp) sd_dhcp_relay_interface *interface = new(sd_dhcp_relay_interface, 1);
50 if (!interface)
51 return -ENOMEM;
52
53 /* RFC 1542 section 5.4:
54 * The server SHOULD next check the 'giaddr' field. If this field is non-zero, the server SHOULD send
55 * the BOOTREPLY as an IP unicast to the IP address identified in the 'giaddr' field. The UDP
56 * destination port MUST be set to BOOTPS (67).
57 *
58 * Hence, the relay agent needs to use DHCP_PORT_SERVER (67) for both source and destination port. */
59 *interface = (sd_dhcp_relay_interface) {
60 .n_ref = 1,
61 .relay = sd_dhcp_relay_ref(relay),
62 .upstream = !!is_upstream,
63 .ifindex = ifindex,
64 .port = DHCP_PORT_SERVER,
65 .socket_fd = -EBADF,
66 .raw_socket_fd = -EBADF,
67 .ip_service_type = IPTOS_CLASS_CS6, /* Defaults to CS6 (Internetwork Control). */
68 };
69
70 r = hashmap_ensure_put(&relay->interfaces, NULL, INT_TO_PTR(interface->ifindex), interface);
71 if (r < 0)
72 return r;
73
74 *ret = TAKE_PTR(interface);
75 return 0;
76 }
77
78 int sd_dhcp_relay_interface_set_ifname(sd_dhcp_relay_interface *interface, const char *ifname) {
79 assert_return(interface, -EINVAL);
80
81 return free_and_strdup(&interface->ifname, ifname);
82 }
83
84 int sd_dhcp_relay_interface_get_ifname(sd_dhcp_relay_interface *interface, const char **ret) {
85 int r;
86
87 assert_return(interface, -EINVAL);
88
89 r = get_ifname(interface->ifindex, &interface->ifname);
90 if (r < 0)
91 return r;
92
93 if (ret)
94 *ret = interface->ifname;
95
96 return 0;
97 }
98
99 int sd_dhcp_relay_interface_set_address(sd_dhcp_relay_interface *interface, const struct in_addr *address, uint8_t prefixlen) {
100 assert_return(interface, -EINVAL);
101 assert_return(!sd_dhcp_relay_interface_is_running(interface), -EBUSY);
102 assert_return(prefixlen <= sizeof(struct in_addr) * 8, -EINVAL);
103
104 if (address)
105 interface->address = *address;
106 else
107 interface->address = (struct in_addr) {};
108
109 if (in4_addr_is_set(&interface->address)) {
110 interface->address_prefixlen = prefixlen;
111
112 struct in_addr netmask;
113 in4_addr_prefixlen_to_netmask(&netmask, prefixlen);
114 interface->subnet_broadcast.s_addr = (interface->address.s_addr & netmask.s_addr) | ~netmask.s_addr;
115 } else {
116 interface->address_prefixlen = 0;
117 interface->subnet_broadcast = (struct in_addr) {};
118 }
119
120 return 0;
121 }
122
123 int sd_dhcp_relay_interface_get_address(sd_dhcp_relay_interface *interface, struct in_addr *ret_address, uint8_t *ret_prefixlen) {
124 assert_return(interface, -EINVAL);
125
126 if (ret_address)
127 *ret_address = interface->address;
128 if (ret_prefixlen)
129 *ret_prefixlen = interface->address_prefixlen;
130
131 return in4_addr_is_set(&interface->address);
132 }
133
134 int sd_dhcp_relay_interface_set_port(sd_dhcp_relay_interface *interface, uint16_t port) {
135 assert_return(interface, -EINVAL);
136 assert_return(!sd_dhcp_relay_interface_is_running(interface), -EBUSY);
137
138 interface->port = port;
139 return 0;
140 }
141
142 int sd_dhcp_relay_interface_set_ip_service_type(sd_dhcp_relay_interface *interface, uint8_t type) {
143 assert_return(interface, -EINVAL);
144 assert_return(!sd_dhcp_relay_interface_is_running(interface), -EBUSY);
145
146 interface->ip_service_type = type;
147 return 0;
148 }
149
150 int sd_dhcp_relay_interface_is_running(sd_dhcp_relay_interface *interface) {
151 return interface && sd_event_source_get_enabled(interface->io_event_source, /* ret= */ NULL) > 0;
152 }
153
154 static int interface_open_socket(sd_dhcp_relay_interface *interface) {
155 int r;
156
157 assert(interface);
158
159 _cleanup_close_ int fd = RET_NERRNO(socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0));
160 if (fd < 0)
161 return fd;
162
163 if (interface->ifindex > 0) {
164 r = socket_bind_to_ifindex(fd, interface->ifindex);
165 if (r < 0)
166 return r;
167 }
168
169 r = setsockopt_int(fd, SOL_SOCKET, SO_REUSEADDR, true);
170 if (r < 0)
171 return r;
172
173 r = setsockopt_int(fd, SOL_SOCKET, SO_BROADCAST, true);
174 if (r < 0)
175 return r;
176
177 r = setsockopt_int(fd, SOL_SOCKET, SO_PRIORITY, tos_to_priority(interface->ip_service_type));
178 if (r < 0)
179 return r;
180
181 r = setsockopt_int(fd, IPPROTO_IP, IP_TOS, interface->ip_service_type);
182 if (r < 0)
183 return r;
184
185 r = setsockopt_int(fd, IPPROTO_IP, IP_PKTINFO, true);
186 if (r < 0)
187 return r;
188
189 union sockaddr_union sa = {
190 .in.sin_family = AF_INET,
191 .in.sin_port = htobe16(interface->port),
192 .in.sin_addr.s_addr = INADDR_ANY,
193 };
194
195 if (bind(fd, &sa.sa, sizeof(sa.in)) < 0)
196 return -errno;
197
198 return TAKE_FD(fd);
199 }
200
201 static int interface_receive_message(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
202 sd_dhcp_relay_interface *interface = ASSERT_PTR(userdata);
203 int r;
204
205 assert(fd >= 0);
206
207 ssize_t buflen = next_datagram_size_fd(fd);
208 if (ERRNO_IS_NEG_TRANSIENT(buflen) || ERRNO_IS_NEG_DISCONNECT(buflen))
209 return 0;
210 if (buflen < 0) {
211 log_dhcp_relay_interface_errno(
212 interface, buflen,
213 "Failed to determine datagram size to read, ignoring: %m");
214 return 0;
215 }
216
217 _cleanup_free_ void *buf = malloc0(buflen);
218 if (!buf)
219 return log_oom_debug();
220
221 CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct in_pktinfo))) control = {};
222 struct msghdr msg = {
223 .msg_iov = &IOVEC_MAKE(buf, buflen),
224 .msg_iovlen = 1,
225 .msg_control = &control,
226 .msg_controllen = sizeof(control),
227 };
228
229 ssize_t len = recvmsg_safe(fd, &msg, MSG_DONTWAIT);
230 if (ERRNO_IS_NEG_TRANSIENT(len) || ERRNO_IS_NEG_DISCONNECT(len))
231 return 0;
232 if (len < 0) {
233 log_dhcp_relay_interface_errno(
234 interface, len,
235 "Could not receive message, ignoring: %m");
236 return 0;
237 }
238
239 if (interface->upstream)
240 r = upstream_process_message(
241 interface,
242 &IOVEC_MAKE(buf, len),
243 CMSG_FIND_DATA(&msg, IPPROTO_IP, IP_PKTINFO, struct in_pktinfo));
244 else
245 r = downstream_process_message(
246 interface,
247 &IOVEC_MAKE(buf, len),
248 CMSG_FIND_DATA(&msg, IPPROTO_IP, IP_PKTINFO, struct in_pktinfo));
249 if (r < 0)
250 log_dhcp_relay_interface_errno(
251 interface, r,
252 "Could not process message, ignoring: %m");
253
254 return 0;
255 }
256
257 int sd_dhcp_relay_interface_start(sd_dhcp_relay_interface *interface) {
258 int r;
259
260 assert_return(interface, -EINVAL);
261 assert_return(interface->relay, -ESTALE);
262 assert_return(interface->relay->event, -EINVAL);
263
264 if (in4_addr_is_null(&interface->relay->server_address) ||
265 (!interface->upstream && in4_addr_is_null(&interface->address)) ||
266 (!interface->upstream && in4_addr_is_null(&interface->gateway_address)))
267 return -EADDRNOTAVAIL;
268
269 if (sd_event_source_get_enabled(interface->io_event_source, /* ret= */ NULL) > 0)
270 return 0; /* Already started. */
271
272 _cleanup_close_ int fd_close = -EBADF;
273 int fd;
274 if (interface->socket_fd >= 0)
275 /* When a socket fd is given externally, unconditionally use it and do not close the socket
276 * even if we fail to set up the event source. */
277 fd = interface->socket_fd;
278 else {
279 /* Otherwise, open a new socket. */
280 fd = fd_close = interface_open_socket(interface);
281 if (fd < 0)
282 return fd;
283 }
284
285 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
286 r = sd_event_add_io(interface->relay->event, &s, fd, EPOLLIN,
287 interface_receive_message, interface);
288 if (r < 0)
289 return r;
290
291 r = sd_event_source_set_priority(s, interface->relay->event_priority);
292 if (r < 0)
293 return r;
294
295 const char *name, *description;
296 if (sd_dhcp_relay_interface_get_ifname(interface, &name) >= 0)
297 description = strjoina("dhcp-relay-interface-io-event-source-", name);
298 else
299 description = "dhcp-relay-interface-io-event-source";
300 (void) sd_event_source_set_description(s, description);
301
302 if (fd_close >= 0) {
303 r = sd_event_source_set_io_fd_own(s, true);
304 if (r < 0)
305 return r;
306 TAKE_FD(fd_close);
307 }
308
309 /* This may potentially fail, in which case the event source should be discarded. */
310 if (interface->upstream)
311 r = upstream_register(interface);
312 else
313 r = downstream_register(interface);
314 if (r < 0)
315 return r;
316
317 sd_event_source_disable_unref(interface->io_event_source);
318 interface->io_event_source = TAKE_PTR(s);
319 return 0;
320 }
321
322 int sd_dhcp_relay_interface_stop(sd_dhcp_relay_interface *interface) {
323 if (!interface)
324 return 0;
325
326 interface->raw_socket_fd = safe_close(interface->raw_socket_fd);
327 interface->io_event_source = sd_event_source_disable_unref(interface->io_event_source);
328
329 if (interface->upstream)
330 upstream_unregister(interface);
331 else
332 downstream_unregister(interface);
333 return 0;
334 }