Debian Codegraph @

src/libsystemd-network/dhcp-server-send.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "sd-event.h"
4
5 #include "dhcp-server-internal.h"
6 #include "dhcp-server-lease-internal.h"
7 #include "dhcp-server-request.h"
8 #include "dhcp-server-send.h"
9 #include "errno-util.h"
10 #include "fd-util.h"
11 #include "in-addr-util.h"
12 #include "random-util.h"
13 #include "set.h"
14 #include "socket-util.h"
15
16 static int server_acquire_raw_socket(sd_dhcp_server *server) {
17 int r;
18
19 assert(server);
20
21 if (server->socket_fd >= 0)
22 /* When a socket fd is given externally, unconditionally use it and do not close the socket. */
23 return server->socket_fd;
24
25 if (server->raw_socket_fd >= 0)
26 /* Already opened. */
27 return server->raw_socket_fd;
28
29 /* This is a send-only socket, hence it is opened with protocol=0, and do not call bind().
30 * The interface binding will be done on send. */
31 _cleanup_close_ int fd = RET_NERRNO(socket(AF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0));
32 if (fd < 0)
33 return fd;
34
35 r = setsockopt_int(fd, SOL_SOCKET, SO_PRIORITY, tos_to_priority(server->ip_service_type));
36 if (r < 0)
37 return r;
38
39 return server->raw_socket_fd = TAKE_FD(fd);
40 }
41
42 static int dhcp_server_send_unicast_raw(
43 sd_dhcp_server *server,
44 const struct hw_addr_data *hw_addr,
45 sd_dhcp_message *message) {
46
47 assert(server);
48 assert(server->ifindex > 0);
49 assert(server->address != 0);
50 assert(hw_addr);
51 assert(message);
52
53 int fd = server_acquire_raw_socket(server);
54 if (fd < 0)
55 return fd;
56
57 return dhcp_message_send_raw(
58 message,
59 fd,
60 server->ifindex,
61 server->address,
62 DHCP_PORT_SERVER,
63 hw_addr,
64 message->header.yiaddr,
65 DHCP_PORT_CLIENT,
66 server->ip_service_type);
67 }
68
69 static int dhcp_server_send_udp(
70 sd_dhcp_server *server,
71 be32_t address,
72 uint16_t port,
73 sd_dhcp_message *message) {
74
75 assert(server);
76 assert(message);
77
78 int fd = sd_event_source_get_io_fd(server->io_event_source);
79 if (fd < 0)
80 return fd;
81
82 return dhcp_message_send_udp(
83 message,
84 fd,
85 server->address,
86 address,
87 port);
88 }
89
90 static int dhcp_server_send_message(
91 sd_dhcp_server *server,
92 uint8_t type,
93 sd_dhcp_message *message) {
94
95 int r;
96
97 assert(server);
98 assert(message);
99
100 /* RFC 2131 Section 4.1 */
101
102 /* If the ’giaddr’ field in a DHCP message from a client is non-zero, the server sends any
103 * return messages to the ’DHCP server’ port on the BOOTP relay agent whose address appears
104 * in ’giaddr’. */
105 if (message->header.giaddr != INADDR_ANY)
106 return dhcp_server_send_udp(
107 server,
108 message->header.giaddr,
109 DHCP_PORT_SERVER,
110 message);
111
112 /* when ’giaddr’ is zero, the server broadcasts any DHCPNAK messages to 0xffffffff. */
113 if (type == DHCP_NAK)
114 return dhcp_server_send_udp(
115 server,
116 INADDR_BROADCAST,
117 DHCP_PORT_CLIENT,
118 message);
119
120 /* If the ’giaddr’ field is zero and the ’ciaddr’ field is nonzero, then the server unicasts
121 * DHCPOFFER and DHCPACK messages to the address in ’ciaddr’. */
122 if (message->header.ciaddr != INADDR_ANY)
123 return dhcp_server_send_udp(
124 server,
125 message->header.ciaddr,
126 DHCP_PORT_CLIENT,
127 message);
128
129 /* If ’giaddr’ is zero and ’ciaddr’ is zero, and the broadcast bit is set, then the server
130 * broadcasts DHCPOFFER and DHCPACK messages to 0xffffffff.
131 *
132 * (Note, even the broadcast flag is unset, we may not know the client hardware address, e.g.
133 * InfiniBand. In that case, we cannot unicast in the below, so need to broadcast. Also, broadcast
134 * the message if 'yiaddr' is zero.) */
135 struct hw_addr_data hw_addr = {};
136 if (!dhcp_message_has_broadcast_flag(message) &&
137 message->header.yiaddr != INADDR_ANY) {
138 r = dhcp_message_get_hw_addr(message, &hw_addr);
139 if (r < 0)
140 return r;
141 }
142
143 if (hw_addr_is_null(&hw_addr))
144 return dhcp_server_send_udp(
145 server,
146 INADDR_BROADCAST,
147 DHCP_PORT_CLIENT,
148 message);
149
150 /* If the broadcast bit is not set and ’giaddr’ is zero and ’ciaddr’ is zero, then the server
151 * unicasts DHCPOFFER and DHCPACK messages to the client’s hardware address and ’yiaddr’ address. */
152 return dhcp_server_send_unicast_raw(
153 server,
154 &hw_addr,
155 message);
156 }
157
158 static int dhcp_server_new_reply(
159 sd_dhcp_server *server,
160 DHCPRequest *req,
161 uint8_t type,
162 sd_dhcp_message **ret) {
163
164 int r;
165
166 assert(server);
167 assert(req);
168 assert(IN_SET(type, DHCP_OFFER, DHCP_ACK, DHCP_NAK));
169 assert(ret);
170
171 _cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *message = NULL;
172 r = dhcp_message_new(&message);
173 if (r < 0)
174 return r;
175
176 r = dhcp_message_init_header(
177 message,
178 BOOTREPLY,
179 be32toh(req->message->header.xid),
180 req->message->header.htype,
181 &req->hw_addr);
182 if (r < 0)
183 return r;
184
185 message->header.giaddr = req->message->header.giaddr;
186
187 /* RFC 2131 Section 4.3.2
188 *
189 * If ’giaddr’ is set in the DHCPREQUEST message, the client is on a different subnet. The server
190 * MUST set the broadcast bit in the DHCPNAK, so that the relay agent will broadcast the DHCPNAK to
191 * the client, because the client may not have a correct network address or subnet mask, and the
192 * client may not be answering ARP requests. */
193 dhcp_message_set_broadcast_flag(
194 message,
195 dhcp_message_has_broadcast_flag(req->message) ||
196 req->message->header.giaddr != INADDR_ANY ||
197 type == DHCP_NAK);
198
199 /* DHCP Message Type (53): Mandatory. */
200 r = dhcp_message_append_option_u8(message, SD_DHCP_OPTION_MESSAGE_TYPE, type);
201 if (r < 0)
202 return r;
203
204 /* Server Identifier */
205 r = dhcp_message_append_option_be32(
206 message,
207 SD_DHCP_OPTION_SERVER_IDENTIFIER,
208 server->address);
209 if (r < 0)
210 return r;
211
212 if (type == DHCP_NAK) {
213 *ret = TAKE_PTR(message);
214 return 0;
215 }
216
217 assert(req->address != INADDR_ANY);
218 message->header.yiaddr = req->address;
219 message->header.siaddr = server->boot_server_address.s_addr;
220
221 if (type == DHCP_ACK)
222 message->header.ciaddr = req->message->header.ciaddr;
223
224 r = dhcp_message_append_option_be32(
225 message,
226 SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME,
227 usec_to_be32_sec(req->lifetime));
228 if (r < 0)
229 return r;
230
231 r = dhcp_message_append_option_be32(
232 message,
233 SD_DHCP_OPTION_SUBNET_MASK,
234 server->netmask);
235 if (r < 0)
236 return r;
237
238 if (server->emit_router) {
239 r = dhcp_message_append_option_be32(
240 message,
241 SD_DHCP_OPTION_ROUTER,
242 in4_addr_is_set(&server->router_address) ?
243 server->router_address.s_addr :
244 server->address);
245 if (r < 0)
246 return r;
247 }
248
249 if (server->boot_server_name) {
250 r = dhcp_message_append_option_string(
251 message,
252 SD_DHCP_OPTION_BOOT_SERVER_NAME,
253 server->boot_server_name);
254 if (r < 0)
255 return r;
256 }
257
258 if (server->boot_filename) {
259 r = dhcp_message_append_option_string(
260 message,
261 SD_DHCP_OPTION_BOOT_FILENAME,
262 server->boot_filename);
263 if (r < 0)
264 return r;
265 }
266
267 static const uint8_t option_map[_SD_DHCP_LEASE_SERVER_TYPE_MAX] = {
268 [SD_DHCP_LEASE_DNS] = SD_DHCP_OPTION_DOMAIN_NAME_SERVER,
269 [SD_DHCP_LEASE_NTP] = SD_DHCP_OPTION_NTP_SERVER,
270 [SD_DHCP_LEASE_SIP] = SD_DHCP_OPTION_SIP_SERVER,
271 [SD_DHCP_LEASE_POP3] = SD_DHCP_OPTION_POP3_SERVER,
272 [SD_DHCP_LEASE_SMTP] = SD_DHCP_OPTION_SMTP_SERVER,
273 [SD_DHCP_LEASE_LPR] = SD_DHCP_OPTION_LPR_SERVER,
274 };
275
276 for (sd_dhcp_lease_server_type_t k = 0; k < _SD_DHCP_LEASE_SERVER_TYPE_MAX; k++) {
277 if (server->servers[k].size <= 0)
278 continue;
279
280 r = dhcp_message_append_option_addresses(
281 message,
282 option_map[k],
283 server->servers[k].size,
284 server->servers[k].addr);
285 if (r < 0)
286 return r;
287 }
288
289 if (server->timezone) {
290 r = dhcp_message_append_option_string(
291 message,
292 SD_DHCP_OPTION_TZDB_TIMEZONE,
293 server->timezone);
294 if (r < 0)
295 return r;
296 }
297
298 if (server->domain_name) {
299 r = dhcp_message_append_option_string(
300 message,
301 SD_DHCP_OPTION_DOMAIN_NAME,
302 server->domain_name);
303 if (r < 0)
304 return r;
305 }
306
307 /* RFC 8925 section 3.3. DHCPv4 Server Behavior
308 * The server MUST NOT include the IPv6-Only Preferred option in the DHCPOFFER or DHCPACK message if
309 * the option was not present in the Parameter Request List sent by the client. */
310 if (set_contains(req->parameter_request_list, UINT_TO_PTR(SD_DHCP_OPTION_IPV6_ONLY_PREFERRED)) &&
311 server->ipv6_only_preferred_usec > 0) {
312 r = dhcp_message_append_option_be32(
313 message,
314 SD_DHCP_OPTION_IPV6_ONLY_PREFERRED,
315 usec_to_be32_sec(server->ipv6_only_preferred_usec));
316 if (r < 0)
317 return r;
318 }
319
320 r = dhcp_message_append_option_sub_tlv(
321 message,
322 SD_DHCP_OPTION_VENDOR_SPECIFIC_INFORMATION,
323 server->vendor_options);
324 if (r < 0)
325 return r;
326
327 if (req->static_lease) {
328 /* Hostname (12) or FQDN (81)
329 * Flags: S=0 (will not update RR), O=1 (are overriding client), N=1 (will not update DNS) */
330 r = dhcp_message_append_option_hostname(
331 message,
332 DHCP_FQDN_FLAG_O | DHCP_FQDN_FLAG_N,
333 /* is_client= */ false,
334 req->static_lease->hostname);
335 if (r < 0)
336 return r;
337 }
338
339 _cleanup_(tlv_unrefp) TLV *agent_info = NULL;
340 r = dhcp_message_get_option_sub_tlv(
341 req->message,
342 SD_DHCP_OPTION_RELAY_AGENT_INFORMATION,
343 TLV_DHCP4_SUBOPTION,
344 &agent_info);
345 if (r < 0 && r != -ENODATA)
346 log_dhcp_server_errno(server, r, "Failed to parse %s option, ignoring: %m",
347 dhcp_option_code_to_string(SD_DHCP_OPTION_RELAY_AGENT_INFORMATION));
348
349 if (agent_info) {
350 r = dhcp_message_append_option_sub_tlv(
351 message,
352 SD_DHCP_OPTION_RELAY_AGENT_INFORMATION,
353 agent_info);
354 if (r < 0)
355 return r;
356 }
357
358 if (type == DHCP_ACK && req->type == DHCP_DISCOVER) {
359 assert(server->rapid_commit);
360 r = dhcp_message_append_option_flag(message, SD_DHCP_OPTION_RAPID_COMMIT);
361 if (r < 0)
362 return r;
363 }
364
365 r = dhcp_message_append_option_tlv(message, server->extra_options);
366 if (r < 0)
367 return r;
368
369 *ret = TAKE_PTR(message);
370 return 0;
371 }
372
373 int dhcp_server_send_reply(
374 sd_dhcp_server *server,
375 DHCPRequest *req,
376 uint8_t type) {
377
378 int r;
379
380 assert(server);
381 assert(req);
382 assert(IN_SET(type, DHCP_OFFER, DHCP_ACK, DHCP_NAK));
383
384 _cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *message = NULL;
385 r = dhcp_server_new_reply(server, req, type, &message);
386 if (r < 0)
387 return r;
388
389 if (dhcp_message_packet_size(message) > req->max_message_size)
390 return -E2BIG;
391
392 r = dhcp_server_send_message(server, type, message);
393 if (r < 0)
394 return r;
395
396 log_dhcp_server(server, "%s (0x%x)", dhcp_message_type_to_string(type), be32toh(message->header.xid));
397 return type; /* Return the sent message type. To make the test easier. */
398 }
399
400 static int dhcp_server_send_forcerenew(
401 sd_dhcp_server *server,
402 sd_dhcp_server_lease *lease) {
403
404 int r;
405
406 assert(server);
407 assert(lease);
408
409 _cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *message = NULL;
410 r = dhcp_message_new(&message);
411 if (r < 0)
412 return r;
413
414 r = dhcp_message_init_header(
415 message,
416 BOOTREPLY,
417 random_u32(),
418 lease->htype,
419 &lease->hw_addr);
420 if (r < 0)
421 return r;
422
423 /* DHCP Message Type (53): Mandatory. */
424 r = dhcp_message_append_option_u8(message, SD_DHCP_OPTION_MESSAGE_TYPE, DHCP_FORCERENEW);
425 if (r < 0)
426 return r;
427
428 /* Server Identifier */
429 r = dhcp_message_append_option_be32(
430 message,
431 SD_DHCP_OPTION_SERVER_IDENTIFIER,
432 server->address);
433 if (r < 0)
434 return r;
435
436 r = dhcp_server_send_udp(server, lease->address, DHCP_PORT_CLIENT, message);
437 if (r < 0)
438 return r;
439
440 log_dhcp_server(server, "%s (0x%x)", dhcp_message_type_to_string(DHCP_FORCERENEW), be32toh(message->header.xid));
441 return 0;
442 }
443
444 int sd_dhcp_server_forcerenew(sd_dhcp_server *server) {
445 sd_dhcp_server_lease *lease;
446 int r = 0;
447
448 assert_return(server, -EINVAL);
449
450 HASHMAP_FOREACH(lease, server->bound_leases_by_client_id)
451 RET_GATHER(r, dhcp_server_send_forcerenew(server, lease));
452 return r;
453 }