Debian Codegraph @

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

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2 /***
3 Copyright © 2013 Intel Corporation. All rights reserved.
4 ***/
5
6 #include <netinet/ip.h>
7
8 #include "sd-dhcp-server.h"
9 #include "sd-event.h"
10
11 #include "alloc-util.h"
12 #include "dhcp-server-internal.h"
13 #include "dhcp-server-lease-internal.h"
14 #include "dhcp-server-request.h"
15 #include "dns-domain.h"
16 #include "fd-util.h"
17 #include "hashmap.h"
18 #include "in-addr-util.h"
19 #include "network-common.h"
20 #include "path-util.h"
21 #include "socket-util.h"
22 #include "string-util.h"
23
24 #define DHCP_DEFAULT_LEASE_TIME_USEC USEC_PER_HOUR
25 #define DHCP_MAX_LEASE_TIME_USEC (USEC_PER_HOUR*12)
26
27 void dhcp_server_on_lease_change(sd_dhcp_server *server) {
28 int r;
29
30 assert(server);
31
32 r = dhcp_server_save_leases(server);
33 if (r < 0)
34 log_dhcp_server_errno(server, r, "Failed to save leases, ignoring: %m");
35
36 if (server->callback)
37 server->callback(server, SD_DHCP_SERVER_EVENT_LEASE_CHANGED, server->callback_userdata);
38 }
39
40 /* configures the server's address and subnet, and optionally the pool's size and offset into the subnet
41 * the whole pool must fit into the subnet, and may not contain the first (any) nor last (broadcast) address
42 * moreover, the server's own address may be in the pool, and is in that case reserved in order not to
43 * accidentally hand it out */
44 int sd_dhcp_server_configure_pool(
45 sd_dhcp_server *server,
46 const struct in_addr *address,
47 unsigned char prefixlen,
48 uint32_t offset,
49 uint32_t size) {
50
51 struct in_addr netmask_addr;
52 be32_t netmask;
53 uint32_t server_off, broadcast_off, size_max;
54
55 assert_return(server, -EINVAL);
56 assert_return(address, -EINVAL);
57 assert_return(address->s_addr != INADDR_ANY, -EINVAL);
58 assert_return(prefixlen <= 32, -ERANGE);
59
60 assert_se(in4_addr_prefixlen_to_netmask(&netmask_addr, prefixlen));
61 netmask = netmask_addr.s_addr;
62
63 server_off = be32toh(address->s_addr & ~netmask);
64 broadcast_off = be32toh(~netmask);
65
66 /* the server address cannot be the subnet address */
67 assert_return(server_off != 0, -ERANGE);
68
69 /* nor the broadcast address */
70 assert_return(server_off != broadcast_off, -ERANGE);
71
72 /* 0 offset means we should set a default, we skip the first (subnet) address
73 and take the next one */
74 if (offset == 0)
75 offset = 1;
76
77 size_max = (broadcast_off + 1) /* the number of addresses in the subnet */
78 - offset /* exclude the addresses before the offset */
79 - 1; /* exclude the last (broadcast) address */
80
81 /* The pool must contain at least one address */
82 assert_return(size_max >= 1, -ERANGE);
83
84 if (size != 0)
85 assert_return(size <= size_max, -ERANGE);
86 else
87 size = size_max;
88
89 if (server->address != address->s_addr || server->netmask != netmask || server->pool_size != size || server->pool_offset != offset) {
90
91 server->pool_offset = offset;
92 server->pool_size = size;
93
94 server->address = address->s_addr;
95 server->netmask = netmask;
96 server->subnet = address->s_addr & netmask;
97 }
98
99 return 0;
100 }
101
102 int sd_dhcp_server_is_running(sd_dhcp_server *server) {
103 return server && sd_event_source_get_enabled(server->io_event_source, /* ret= */ NULL) > 0;
104 }
105
106 static sd_dhcp_server* dhcp_server_free(sd_dhcp_server *server) {
107 assert(server);
108
109 sd_dhcp_server_stop(server);
110
111 sd_event_unref(server->event);
112 safe_close(server->socket_fd);
113 safe_close(server->raw_socket_fd);
114
115 free(server->boot_server_name);
116 free(server->boot_filename);
117 free(server->timezone);
118 free(server->domain_name);
119
120 for (sd_dhcp_lease_server_type_t i = 0; i < _SD_DHCP_LEASE_SERVER_TYPE_MAX; i++)
121 free(server->servers[i].addr);
122
123 server->bound_leases_by_address = hashmap_free(server->bound_leases_by_address);
124 server->bound_leases_by_client_id = hashmap_free(server->bound_leases_by_client_id);
125 server->static_leases_by_address = hashmap_free(server->static_leases_by_address);
126 server->static_leases_by_client_id = hashmap_free(server->static_leases_by_client_id);
127
128 tlv_unref(server->extra_options);
129 tlv_unref(server->vendor_options);
130
131 safe_close(server->lease_dir_fd);
132 free(server->lease_file);
133
134 free(server->ifname);
135 return mfree(server);
136 }
137
138 DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_server, sd_dhcp_server, dhcp_server_free);
139
140 int sd_dhcp_server_new(sd_dhcp_server **ret, int ifindex) {
141 _cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
142
143 assert_return(ret, -EINVAL);
144 assert_return(ifindex > 0, -EINVAL);
145
146 server = new(sd_dhcp_server, 1);
147 if (!server)
148 return -ENOMEM;
149
150 *server = (sd_dhcp_server) {
151 .n_ref = 1,
152 .ip_service_type = IPTOS_CLASS_CS6,
153 .socket_fd = -EBADF,
154 .raw_socket_fd = -EBADF,
155 .address = htobe32(INADDR_ANY),
156 .netmask = htobe32(INADDR_ANY),
157 .ifindex = ifindex,
158 .default_lease_time = DHCP_DEFAULT_LEASE_TIME_USEC,
159 .max_lease_time = DHCP_MAX_LEASE_TIME_USEC,
160 .rapid_commit = true,
161 .lease_dir_fd = -EBADF,
162 };
163
164 *ret = TAKE_PTR(server);
165
166 return 0;
167 }
168
169 int sd_dhcp_server_set_ifname(sd_dhcp_server *server, const char *ifname) {
170 assert_return(server, -EINVAL);
171 assert_return(ifname, -EINVAL);
172
173 if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
174 return -EINVAL;
175
176 return free_and_strdup(&server->ifname, ifname);
177 }
178
179 int sd_dhcp_server_get_ifname(sd_dhcp_server *server, const char **ret) {
180 int r;
181
182 assert_return(server, -EINVAL);
183
184 r = get_ifname(server->ifindex, &server->ifname);
185 if (r < 0)
186 return r;
187
188 if (ret)
189 *ret = server->ifname;
190
191 return 0;
192 }
193
194 int sd_dhcp_server_attach_event(sd_dhcp_server *server, sd_event *event, int64_t priority) {
195 int r;
196
197 assert_return(server, -EINVAL);
198 assert_return(!server->event, -EBUSY);
199
200 if (event)
201 server->event = sd_event_ref(event);
202 else {
203 r = sd_event_default(&server->event);
204 if (r < 0)
205 return r;
206 }
207
208 server->event_priority = priority;
209
210 return 0;
211 }
212
213 int sd_dhcp_server_detach_event(sd_dhcp_server *server) {
214 assert_return(server, -EINVAL);
215
216 server->event = sd_event_unref(server->event);
217
218 return 0;
219 }
220
221 sd_event* sd_dhcp_server_get_event(sd_dhcp_server *server) {
222 assert_return(server, NULL);
223
224 return server->event;
225 }
226
227 int sd_dhcp_server_set_ip_service_type(sd_dhcp_server *server, uint8_t type) {
228 assert_return(server, -EINVAL);
229 assert_return(!sd_dhcp_server_is_running(server), -EBUSY);
230
231 server->ip_service_type = type;
232 return 0;
233 }
234
235 int sd_dhcp_server_set_boot_server_address(sd_dhcp_server *server, const struct in_addr *address) {
236 assert_return(server, -EINVAL);
237
238 if (address)
239 server->boot_server_address = *address;
240 else
241 server->boot_server_address = (struct in_addr) {};
242
243 return 0;
244 }
245
246 int sd_dhcp_server_set_boot_server_name(sd_dhcp_server *server, const char *name) {
247 int r;
248
249 assert_return(server, -EINVAL);
250
251 if (name) {
252 r = dns_name_is_valid(name);
253 if (r < 0)
254 return r;
255 if (r == 0)
256 return -EINVAL;
257 }
258
259 return free_and_strdup(&server->boot_server_name, name);
260 }
261
262 int sd_dhcp_server_set_boot_filename(sd_dhcp_server *server, const char *filename) {
263 assert_return(server, -EINVAL);
264
265 if (isempty(filename))
266 filename = NULL;
267 else if (!string_is_safe(filename, STRING_ASCII|STRING_ALLOW_GLOBS))
268 return -EINVAL;
269
270 return free_and_strdup(&server->boot_filename, filename);
271 }
272
273 int sd_dhcp_server_stop(sd_dhcp_server *server) {
274 if (!server)
275 return 0;
276
277 bool running = sd_dhcp_server_is_running(server);
278
279 server->raw_socket_fd = safe_close(server->raw_socket_fd);
280 server->io_event_source = sd_event_source_disable_unref(server->io_event_source);
281
282 if (running)
283 log_dhcp_server(server, "STOPPED");
284
285 return 0;
286 }
287
288 bool dhcp_server_address_is_in_pool(sd_dhcp_server *server, be32_t address) {
289 assert(server);
290
291 if (server->pool_size == 0)
292 return false;
293
294 if (address == server->address)
295 return false;
296
297 if (be32toh(address) < (be32toh(server->subnet) | server->pool_offset) ||
298 be32toh(address) >= (be32toh(server->subnet) | (server->pool_offset + server->pool_size)))
299 return false;
300
301 if (hashmap_contains(server->static_leases_by_address, UINT32_TO_PTR(address)))
302 return false;
303
304 return true;
305 }
306
307 bool dhcp_server_address_available(sd_dhcp_server *server, be32_t address) {
308 assert(server);
309
310 if (hashmap_contains(server->bound_leases_by_address, UINT32_TO_PTR(address)) ||
311 hashmap_contains(server->static_leases_by_address, UINT32_TO_PTR(address)) ||
312 address == server->address)
313 return false;
314
315 return true;
316 }
317
318 static void dhcp_server_update_lease_servers(sd_dhcp_server *server) {
319 assert(server);
320 assert(server->address != 0);
321
322 /* Convert null address -> server address */
323
324 for (sd_dhcp_lease_server_type_t k = 0; k < _SD_DHCP_LEASE_SERVER_TYPE_MAX; k++)
325 for (size_t i = 0; i < server->servers[k].size; i++)
326 if (in4_addr_is_null(&server->servers[k].addr[i]))
327 server->servers[k].addr[i].s_addr = server->address;
328 }
329
330 int sd_dhcp_server_start(sd_dhcp_server *server) {
331 int r;
332
333 assert_return(server, -EINVAL);
334 assert_return(server->event, -EINVAL);
335 assert_return(server->address != INADDR_ANY, -EUNATCH);
336
337 if (sd_dhcp_server_is_running(server))
338 return 0;
339
340 dhcp_server_update_lease_servers(server);
341
342 r = dhcp_server_setup_io_event_source(server);
343 if (r < 0)
344 return r;
345
346 r = dhcp_server_load_leases(server);
347 if (r < 0)
348 log_dhcp_server_errno(server, r, "Failed to load lease file %s, ignoring: %m", strna(server->lease_file));
349
350 log_dhcp_server(server, "STARTED");
351 return 0;
352 }
353
354 int sd_dhcp_server_set_timezone(sd_dhcp_server *server, const char *tz) {
355 int r;
356
357 assert_return(server, -EINVAL);
358 assert_return(timezone_is_valid(tz, LOG_DEBUG), -EINVAL);
359
360 if (streq_ptr(tz, server->timezone))
361 return 0;
362
363 r = free_and_strdup(&server->timezone, tz);
364 if (r < 0)
365 return r;
366
367 return 1;
368 }
369
370 int sd_dhcp_server_set_domain_name(sd_dhcp_server *server, const char *domain_name) {
371 int r;
372
373 assert_return(server, -EINVAL);
374
375 if (domain_name) {
376 r = dns_name_is_valid(domain_name);
377 if (r < 0)
378 return r;
379 if (r == 0)
380 return -EINVAL;
381 }
382
383 return free_and_strdup(&server->domain_name, domain_name);
384 }
385
386 int sd_dhcp_server_set_max_lease_time(sd_dhcp_server *server, uint64_t t) {
387 assert_return(server, -EINVAL);
388
389 server->max_lease_time = t;
390 return 0;
391 }
392
393 int sd_dhcp_server_set_default_lease_time(sd_dhcp_server *server, uint64_t t) {
394 assert_return(server, -EINVAL);
395
396 server->default_lease_time = t;
397 return 0;
398 }
399
400 int sd_dhcp_server_set_ipv6_only_preferred_usec(sd_dhcp_server *server, uint64_t t) {
401 assert_return(server, -EINVAL);
402
403 /* When 0 is set, disables the IPv6 only mode. */
404
405 /* Refuse too short timespan unless test mode is enabled. */
406 if (t > 0 && t < MIN_V6ONLY_WAIT_USEC && !network_test_mode_enabled())
407 return -EINVAL;
408
409 server->ipv6_only_preferred_usec = t;
410 return 0;
411 }
412
413 int sd_dhcp_server_set_rapid_commit(sd_dhcp_server *server, int enabled) {
414 assert_return(server, -EINVAL);
415
416 server->rapid_commit = enabled;
417 return 0;
418 }
419
420 int sd_dhcp_server_set_servers(
421 sd_dhcp_server *server,
422 sd_dhcp_lease_server_type_t what,
423 const struct in_addr addresses[],
424 size_t n_addresses) {
425
426 struct in_addr *c = NULL;
427
428 assert_return(server, -EINVAL);
429 assert_return(!sd_dhcp_server_is_running(server), -EBUSY);
430 assert_return(addresses || n_addresses == 0, -EINVAL);
431 assert_return(what >= 0, -EINVAL);
432 assert_return(what < _SD_DHCP_LEASE_SERVER_TYPE_MAX, -EINVAL);
433
434 if (server->servers[what].size == n_addresses &&
435 memcmp(server->servers[what].addr, addresses, sizeof(struct in_addr) * n_addresses) == 0)
436 return 0;
437
438 if (n_addresses > 0) {
439 c = newdup(struct in_addr, addresses, n_addresses);
440 if (!c)
441 return -ENOMEM;
442 }
443
444 free_and_replace(server->servers[what].addr, c);
445 server->servers[what].size = n_addresses;
446 return 1;
447 }
448
449 int sd_dhcp_server_set_dns(sd_dhcp_server *server, const struct in_addr dns[], size_t n) {
450 return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_DNS, dns, n);
451 }
452 int sd_dhcp_server_set_ntp(sd_dhcp_server *server, const struct in_addr ntp[], size_t n) {
453 return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_NTP, ntp, n);
454 }
455 int sd_dhcp_server_set_sip(sd_dhcp_server *server, const struct in_addr sip[], size_t n) {
456 return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SIP, sip, n);
457 }
458 int sd_dhcp_server_set_pop3(sd_dhcp_server *server, const struct in_addr pop3[], size_t n) {
459 return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_POP3, pop3, n);
460 }
461 int sd_dhcp_server_set_smtp(sd_dhcp_server *server, const struct in_addr smtp[], size_t n) {
462 return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SMTP, smtp, n);
463 }
464 int sd_dhcp_server_set_lpr(sd_dhcp_server *server, const struct in_addr lpr[], size_t n) {
465 return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_LPR, lpr, n);
466 }
467
468 int sd_dhcp_server_set_router(sd_dhcp_server *server, const struct in_addr *router) {
469 assert_return(server, -EINVAL);
470
471 /* router is NULL: router option will not be appended.
472 * router is null address (0.0.0.0): the server address will be used as the router address.
473 * otherwise: the specified address will be used as the router address. */
474
475 server->emit_router = router;
476 if (router)
477 server->router_address = *router;
478
479 return 0;
480 }
481
482 int dhcp_server_set_extra_options(sd_dhcp_server *server, TLV *options) {
483 assert(server);
484 return unref_and_replace_new_ref(server->extra_options, options, tlv_ref, tlv_unref);
485 }
486
487 int dhcp_server_set_vendor_options(sd_dhcp_server *server, TLV *options) {
488 assert(server);
489 return unref_and_replace_new_ref(server->vendor_options, options, tlv_ref, tlv_unref);
490 }
491
492 int sd_dhcp_server_set_callback(sd_dhcp_server *server, sd_dhcp_server_callback_t cb, void *userdata) {
493 assert_return(server, -EINVAL);
494
495 server->callback = cb;
496 server->callback_userdata = userdata;
497
498 return 0;
499 }
500
501 int sd_dhcp_server_set_lease_file(sd_dhcp_server *server, int dir_fd, const char *path) {
502 int r;
503
504 assert_return(server, -EINVAL);
505 assert_return(!path || (dir_fd >= 0 || dir_fd == AT_FDCWD), -EBADF);
506 assert_return(!sd_dhcp_server_is_running(server), -EBUSY);
507
508 if (!path) {
509 /* When NULL, clear the previous assignment. */
510 server->lease_file = mfree(server->lease_file);
511 server->lease_dir_fd = safe_close(server->lease_dir_fd);
512 return 0;
513 }
514
515 if (!path_is_safe(path))
516 return -EINVAL;
517
518 _cleanup_close_ int fd = AT_FDCWD; /* Unlike our usual coding style, AT_FDCWD needs to be set,
519 * to pass a 'valid' fd. */
520 if (dir_fd >= 0) {
521 fd = fd_reopen(dir_fd, O_CLOEXEC | O_DIRECTORY | O_PATH);
522 if (fd < 0)
523 return fd;
524 }
525
526 r = free_and_strdup(&server->lease_file, path);
527 if (r < 0)
528 return r;
529
530 close_and_replace(server->lease_dir_fd, fd);
531
532 return 0;
533 }
534
535 static int find_lease_address(Hashmap *h, const char *name, struct in_addr *ret) {
536 int r;
537
538 assert(name);
539
540 sd_dhcp_server_lease *lease;
541 HASHMAP_FOREACH(lease, h) {
542 if (!lease->hostname)
543 continue;
544
545 r = dns_name_equal(lease->hostname, name);
546 if (r <= 0)
547 continue;
548
549 if (ret)
550 ret->s_addr = lease->address;
551 return 1;
552 }
553
554 return -ENOENT;
555 }
556
557 int sd_dhcp_server_get_lease_address_by_name(sd_dhcp_server *server, const char *name, struct in_addr *ret) {
558 int r;
559
560 assert_return(server, -EINVAL);
561 assert_return(dns_name_is_valid(name), -EINVAL);
562
563 r = find_lease_address(server->static_leases_by_address, name, ret);
564 if (r != -ENOENT)
565 return r;
566
567 return find_lease_address(server->bound_leases_by_address, name, ret);
568 }