Debian Codegraph @

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

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <sys/stat.h>
4 #include <unistd.h>
5
6 #include "sd-event.h"
7
8 #include "alloc-util.h"
9 #include "dhcp-server-internal.h"
10 #include "dhcp-server-lease-internal.h"
11 #include "dhcp-server-request.h"
12 #include "dns-domain.h"
13 #include "errno-util.h"
14 #include "fd-util.h"
15 #include "fs-util.h"
16 #include "hashmap.h"
17 #include "in-addr-util.h"
18 #include "iovec-util.h"
19 #include "json-util.h"
20 #include "mkdir.h"
21 #include "tmpfile-util.h"
22
23 static sd_dhcp_server_lease* dhcp_server_lease_free(sd_dhcp_server_lease *lease) {
24 if (!lease)
25 return NULL;
26
27 if (lease->server) {
28 hashmap_remove_value(lease->server->bound_leases_by_address, UINT32_TO_PTR(lease->address), lease);
29 hashmap_remove_value(lease->server->bound_leases_by_client_id, &lease->client_id, lease);
30 hashmap_remove_value(lease->server->static_leases_by_address, UINT32_TO_PTR(lease->address), lease);
31 hashmap_remove_value(lease->server->static_leases_by_client_id, &lease->client_id, lease);
32 }
33
34 free(lease->hostname);
35 return mfree(lease);
36 }
37
38 DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_server_lease, sd_dhcp_server_lease, dhcp_server_lease_free);
39
40 DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
41 dhcp_server_lease_hash_ops,
42 sd_dhcp_client_id,
43 client_id_hash_func,
44 client_id_compare_func,
45 sd_dhcp_server_lease,
46 sd_dhcp_server_lease_unref);
47
48 int dhcp_server_put_lease(sd_dhcp_server *server, sd_dhcp_server_lease *lease, bool is_static) {
49 int r;
50
51 assert(server);
52 assert(lease);
53
54 lease->server = server; /* This must be set before hashmap_put(). */
55
56 r = hashmap_ensure_put(is_static ? &server->static_leases_by_client_id : &server->bound_leases_by_client_id,
57 &dhcp_server_lease_hash_ops, &lease->client_id, lease);
58 if (r < 0)
59 return r;
60
61 r = hashmap_ensure_put(is_static ? &server->static_leases_by_address : &server->bound_leases_by_address,
62 NULL, UINT32_TO_PTR(lease->address), lease);
63 if (r < 0)
64 return r;
65
66 return 0;
67 }
68
69 int dhcp_server_set_lease(sd_dhcp_server *server, DHCPRequest *req) {
70 int r;
71
72 assert(server);
73 assert(req);
74 assert(req->message);
75 assert(req->address != INADDR_ANY);
76
77 usec_t expiration;
78 r = dhcp_request_get_lifetime_timestamp(req, CLOCK_BOOTTIME, &expiration);
79 if (r < 0)
80 return r;
81
82 _cleanup_(sd_dhcp_server_lease_unrefp) sd_dhcp_server_lease *lease =
83 hashmap_get(server->bound_leases_by_client_id, &req->client_id);
84 if (lease) {
85 /* If a lease for the host already exists, update it. */
86 if (lease->address != req->address) {
87 hashmap_remove_value(server->bound_leases_by_address, UINT32_TO_PTR(lease->address), lease);
88 lease->address = req->address;
89
90 r = hashmap_ensure_put(&server->bound_leases_by_address, NULL, UINT32_TO_PTR(lease->address), lease);
91 if (r < 0)
92 return r;
93 }
94
95 lease->htype = req->message->header.htype;
96 lease->hw_addr = req->hw_addr;
97 lease->gateway = req->message->header.giaddr;
98 lease->expiration = expiration;
99 } else {
100 /* Otherwise, add a new lease. */
101 lease = new(sd_dhcp_server_lease, 1);
102 if (!lease)
103 return -ENOMEM;
104
105 *lease = (sd_dhcp_server_lease) {
106 .n_ref = 1,
107 .client_id = req->client_id,
108 .htype = req->message->header.htype,
109 .hw_addr = req->hw_addr,
110 .address = req->address,
111 .gateway = req->message->header.giaddr,
112 .expiration = expiration,
113 };
114
115 r = dhcp_server_put_lease(server, lease, /* is_static= */ false);
116 if (r < 0)
117 return r;
118 }
119
120 char *hostname = NULL;
121 (void) dhcp_message_get_option_hostname(req->message, &hostname);
122 free_and_replace(lease->hostname, hostname);
123
124 TAKE_PTR(lease);
125 return 0;
126 }
127
128 int dhcp_server_cleanup_expired_leases(sd_dhcp_server *server) {
129 sd_dhcp_server_lease *lease;
130 usec_t time_now;
131 int r;
132
133 assert(server);
134
135 r = sd_event_now(server->event, CLOCK_BOOTTIME, &time_now);
136 if (r < 0)
137 return r;
138
139 HASHMAP_FOREACH(lease, server->bound_leases_by_client_id)
140 if (lease->expiration < time_now) {
141 log_dhcp_server(server, "CLEAN (0x%x)", be32toh(lease->address));
142 sd_dhcp_server_lease_unref(lease);
143 }
144
145 return 0;
146 }
147
148 sd_dhcp_server_lease* dhcp_server_get_static_lease(sd_dhcp_server *server, const DHCPRequest *req) {
149 sd_dhcp_server_lease *static_lease;
150
151 assert(server);
152 assert(req);
153
154 static_lease = hashmap_get(server->static_leases_by_client_id, &req->client_id);
155 if (!static_lease && sd_dhcp_client_id_is_set(&req->client_id_by_header))
156 /* when no lease is found, fall back to use the fake client ID generated from the header. */
157 static_lease = hashmap_get(server->static_leases_by_client_id, &req->client_id_by_header);
158 if (!static_lease)
159 return NULL;
160
161 /* Check if the address is in the same subnet. */
162 if ((static_lease->address & server->netmask) != server->subnet)
163 return NULL;
164
165 /* Check if the address is different from the server address. */
166 if (static_lease->address == server->address)
167 return NULL;
168
169 return static_lease;
170 }
171
172 int sd_dhcp_server_set_static_lease(
173 sd_dhcp_server *server,
174 const struct in_addr *address,
175 uint8_t *client_id_raw,
176 size_t client_id_size,
177 const char *hostname) {
178
179 _cleanup_(sd_dhcp_server_lease_unrefp) sd_dhcp_server_lease *lease = NULL;
180 sd_dhcp_client_id client_id;
181 int r;
182
183 assert_return(server, -EINVAL);
184 assert_return(client_id_raw, -EINVAL);
185 assert_return(client_id_size_is_valid(client_id_size), -EINVAL);
186 assert_return(!sd_dhcp_server_is_running(server), -EBUSY);
187
188 r = sd_dhcp_client_id_set_raw(&client_id, client_id_raw, client_id_size);
189 if (r < 0)
190 return r;
191
192 /* Static lease with an empty or omitted address is a valid entry,
193 * the server removes any static lease with the specified mac address. */
194 if (!address || address->s_addr == 0) {
195 sd_dhcp_server_lease_unref(hashmap_get(server->static_leases_by_client_id, &client_id));
196 return 0;
197 }
198
199 if (hostname) {
200 r = dns_name_is_valid_ldh(hostname);
201 if (r < 0)
202 return r;
203 if (r == 0)
204 return -EINVAL;
205 }
206
207 lease = new(sd_dhcp_server_lease, 1);
208 if (!lease)
209 return -ENOMEM;
210
211 *lease = (sd_dhcp_server_lease) {
212 .n_ref = 1,
213 .address = address->s_addr,
214 .client_id = client_id,
215 };
216
217 if (hostname) {
218 lease->hostname = strdup(hostname);
219 if (!lease->hostname)
220 return -ENOMEM;
221 }
222
223 r = dhcp_server_put_lease(server, lease, /* is_static= */ true);
224 if (r < 0)
225 return r;
226
227 TAKE_PTR(lease);
228 return 0;
229 }
230
231 static int dhcp_server_lease_build_json(sd_dhcp_server_lease *lease, sd_json_variant **ret) {
232 assert(lease);
233 assert(ret);
234
235 return sd_json_buildo(
236 ret,
237 SD_JSON_BUILD_PAIR_BYTE_ARRAY("ClientId", lease->client_id.raw, lease->client_id.size),
238 JSON_BUILD_PAIR_IN4_ADDR_WITH_STRING_NON_NULL("Address", &(struct in_addr) { .s_addr = lease->address }),
239 JSON_BUILD_PAIR_STRING_NON_EMPTY("Hostname", lease->hostname),
240 SD_JSON_BUILD_PAIR_UNSIGNED("HardwareAddressType", lease->htype),
241 SD_JSON_BUILD_PAIR_UNSIGNED("HardwareAddressLength", lease->hw_addr.length),
242 SD_JSON_BUILD_PAIR_BYTE_ARRAY("HardwareAddress", lease->hw_addr.bytes, lease->hw_addr.length));
243 }
244
245 int dhcp_server_bound_leases_append_json(sd_dhcp_server *server, sd_json_variant **v) {
246 _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
247 sd_dhcp_server_lease *lease;
248 usec_t now_b, now_r;
249 int r;
250
251 assert(server);
252 assert(v);
253
254 r = sd_event_now(server->event, CLOCK_BOOTTIME, &now_b);
255 if (r < 0)
256 return r;
257
258 r = sd_event_now(server->event, CLOCK_REALTIME, &now_r);
259 if (r < 0)
260 return r;
261
262 HASHMAP_FOREACH(lease, server->bound_leases_by_client_id) {
263 _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
264
265 r = dhcp_server_lease_build_json(lease, &w);
266 if (r < 0)
267 return r;
268
269 usec_t exp_r = map_clock_usec_raw(lease->expiration, now_b, now_r);
270
271 r = sd_json_variant_merge_objectbo(
272 &w,
273 SD_JSON_BUILD_PAIR_UNSIGNED("ExpirationUSec", lease->expiration),
274 SD_JSON_BUILD_PAIR_UNSIGNED("ExpirationRealtimeUSec", exp_r));
275 if (r < 0)
276 return r;
277
278 r = sd_json_variant_append_array(&array, w);
279 if (r < 0)
280 return r;
281 }
282
283 return json_variant_set_field_non_null(v, "Leases", array);
284 }
285
286 int dhcp_server_static_leases_append_json(sd_dhcp_server *server, sd_json_variant **v) {
287 _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
288 sd_dhcp_server_lease *lease;
289 int r;
290
291 assert(server);
292 assert(v);
293
294 HASHMAP_FOREACH(lease, server->static_leases_by_client_id) {
295 _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
296
297 r = dhcp_server_lease_build_json(lease, &w);
298 if (r < 0)
299 return r;
300
301 r = sd_json_variant_append_array(&array, w);
302 if (r < 0)
303 return r;
304 }
305
306 return json_variant_set_field_non_null(v, "StaticLeases", array);
307 }
308
309 int dhcp_server_save_leases(sd_dhcp_server *server) {
310 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
311 sd_id128_t boot_id;
312 int r;
313
314 assert(server);
315
316 if (!server->lease_file)
317 return 0;
318
319 if (hashmap_isempty(server->bound_leases_by_client_id)) {
320 if (unlink(server->lease_file) < 0 && errno != ENOENT)
321 return -errno;
322
323 return 0;
324 }
325
326 r = sd_id128_get_boot(&boot_id);
327 if (r < 0)
328 return r;
329
330 r = sd_json_buildo(
331 &v,
332 SD_JSON_BUILD_PAIR_ID128("BootID", boot_id),
333 JSON_BUILD_PAIR_IN4_ADDR("Address", &(struct in_addr) { .s_addr = server->address }),
334 SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength",
335 in4_addr_netmask_to_prefixlen(&(struct in_addr) { .s_addr = server->netmask })));
336 if (r < 0)
337 return r;
338
339 r = dhcp_server_bound_leases_append_json(server, &v);
340 if (r < 0)
341 return r;
342
343 r = mkdirat_parents(server->lease_dir_fd, server->lease_file, 0755);
344 if (r < 0)
345 return r;
346
347 _cleanup_free_ char *temp_path = NULL;
348 _cleanup_fclose_ FILE *f = NULL;
349
350 r = fopen_temporary_at(server->lease_dir_fd, server->lease_file, &f, &temp_path);
351 if (r < 0)
352 return r;
353
354 CLEANUP_TMPFILE_AT(server->lease_dir_fd, temp_path);
355
356 (void) fchmod(fileno(f), 0644);
357
358 r = sd_json_variant_dump(v, SD_JSON_FORMAT_NEWLINE | SD_JSON_FORMAT_FLUSH, f, /* prefix= */ NULL);
359 if (r < 0)
360 return r;
361
362 r = conservative_renameat(server->lease_dir_fd, temp_path, server->lease_dir_fd, server->lease_file);
363 if (r < 0)
364 return r;
365
366 temp_path = mfree(temp_path); /* disarm CLEANUP_TMPFILE_AT() */
367 return 0;
368 }
369
370 typedef struct LeaseParam {
371 sd_dhcp_client_id client_id;
372 uint8_t htype;
373 uint8_t hlen;
374 struct iovec hw_addr;
375 struct in_addr address;
376 usec_t exp_b;
377 usec_t exp_r;
378 char *hostname;
379 } LeaseParam;
380
381 static void lease_param_done(LeaseParam *p) {
382 assert(p);
383
384 iovec_done(&p->hw_addr);
385 free(p->hostname);
386 }
387
388 static int json_dispatch_dhcp_lease(sd_dhcp_server *server, sd_json_variant *v, bool use_boottime) {
389 static const sd_json_dispatch_field dispatch_table[] = {
390 { "ClientId", SD_JSON_VARIANT_ARRAY, json_dispatch_client_id, offsetof(LeaseParam, client_id), SD_JSON_MANDATORY },
391 { "HardwareAddressType", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8, offsetof(LeaseParam, htype), 0 },
392 { "HardwareAddressLength", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8, offsetof(LeaseParam, hlen), 0 },
393 { "HardwareAddress", SD_JSON_VARIANT_ARRAY, json_dispatch_byte_array_iovec, offsetof(LeaseParam, hw_addr), 0 },
394 { "Address", SD_JSON_VARIANT_ARRAY, json_dispatch_in_addr, offsetof(LeaseParam, address), SD_JSON_MANDATORY },
395 { "AddressString", SD_JSON_VARIANT_STRING, NULL, 0, 0 },
396 { "ExpirationUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(LeaseParam, exp_b), SD_JSON_MANDATORY },
397 { "ExpirationRealtimeUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(LeaseParam, exp_r), SD_JSON_MANDATORY },
398 { "Hostname", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(LeaseParam, hostname), 0 },
399 {}
400 };
401
402 int r;
403
404 assert(server);
405 assert(v);
406
407 _cleanup_(lease_param_done) LeaseParam p = {};
408 r = sd_json_dispatch(v, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &p);
409 if (r < 0)
410 return r;
411
412 if (p.hlen > HW_ADDR_MAX_SIZE)
413 return -EINVAL;
414
415 if (p.hlen > p.hw_addr.iov_len)
416 return -EINVAL;
417
418 if (!in4_addr_is_set(&p.address))
419 return -EINVAL;
420
421 if (!sd_dhcp_client_id_is_set(&p.client_id))
422 return -EINVAL;
423
424 usec_t now_b;
425 r = sd_event_now(server->event, CLOCK_BOOTTIME, &now_b);
426 if (r < 0)
427 return r;
428
429 if (use_boottime) {
430 if (p.exp_b < now_b)
431 return 0; /* already expired */
432 } else {
433 usec_t now_r;
434
435 r = sd_event_now(server->event, CLOCK_REALTIME, &now_r);
436 if (r < 0)
437 return r;
438
439 if (p.exp_r < now_r)
440 return 0; /* already expired */
441
442 p.exp_b = map_clock_usec_raw(p.exp_r, now_r, now_b);
443 }
444
445 _cleanup_(sd_dhcp_server_lease_unrefp) sd_dhcp_server_lease *lease = new(sd_dhcp_server_lease, 1);
446 if (!lease)
447 return -ENOMEM;
448
449 *lease = (sd_dhcp_server_lease) {
450 .n_ref = 1,
451
452 .client_id = p.client_id,
453 .htype = p.htype,
454 .hw_addr.length = p.hlen,
455 .address = p.address.s_addr,
456 .expiration = p.exp_b,
457 .hostname = TAKE_PTR(p.hostname),
458 };
459
460 memcpy_safe(lease->hw_addr.bytes, p.hw_addr.iov_base, p.hlen);
461
462 r = dhcp_server_put_lease(server, lease, /* is_static= */ false);
463 if (r == -EEXIST)
464 return 0;
465 if (r < 0)
466 return r;
467
468 TAKE_PTR(lease);
469 return 0;
470 }
471
472 typedef struct SavedInfo {
473 sd_id128_t boot_id;
474 struct in_addr address;
475 uint8_t prefixlen;
476 sd_json_variant *leases;
477 } SavedInfo;
478
479 static void saved_info_done(SavedInfo *info) {
480 if (!info)
481 return;
482
483 sd_json_variant_unref(info->leases);
484 }
485
486 static int load_leases_file(int dir_fd, const char *path, SavedInfo *ret) {
487 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
488 int r;
489
490 assert(dir_fd >= 0 || dir_fd == AT_FDCWD);
491 assert(path);
492 assert(ret);
493
494 r = sd_json_parse_file_at(
495 /* f= */ NULL,
496 dir_fd,
497 path,
498 /* flags= */ SD_JSON_PARSE_MUST_BE_OBJECT,
499 &v,
500 /* reterr_line= */ NULL,
501 /* ret_column= */ NULL);
502 if (r < 0)
503 return r;
504
505 static const sd_json_dispatch_field dispatch_lease_file_table[] = {
506 { "BootID", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(SavedInfo, boot_id), SD_JSON_MANDATORY },
507 { "Address", SD_JSON_VARIANT_ARRAY, json_dispatch_in_addr, offsetof(SavedInfo, address), SD_JSON_MANDATORY },
508 { "PrefixLength", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8, offsetof(SavedInfo, prefixlen), SD_JSON_MANDATORY },
509 { "Leases", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(SavedInfo, leases), SD_JSON_MANDATORY },
510 {}
511 };
512
513 return sd_json_dispatch(v, dispatch_lease_file_table, SD_JSON_ALLOW_EXTENSIONS, ret);
514 }
515
516 int dhcp_server_load_leases(sd_dhcp_server *server) {
517 _cleanup_(saved_info_done) SavedInfo info = {};
518 sd_id128_t boot_id;
519 size_t n, m;
520 int r;
521
522 assert(server);
523 assert(server->event);
524
525 if (!server->lease_file)
526 return 0;
527
528 r = load_leases_file(server->lease_dir_fd, server->lease_file, &info);
529 if (r == -ENOENT)
530 return 0;
531 if (r < 0)
532 return r;
533
534 r = sd_id128_get_boot(&boot_id);
535 if (r < 0)
536 return r;
537
538 n = hashmap_size(server->bound_leases_by_client_id);
539
540 sd_json_variant *i;
541 JSON_VARIANT_ARRAY_FOREACH(i, info.leases)
542 RET_GATHER(r, json_dispatch_dhcp_lease(server, i, /* use_boottime= */ sd_id128_equal(info.boot_id, boot_id)));
543
544 m = hashmap_size(server->bound_leases_by_client_id);
545 assert(m >= n);
546 log_dhcp_server(server, "Loaded %zu lease(s) from %s.", m - n, server->lease_file);
547
548 return r;
549 }
550
551 int dhcp_server_leases_file_get_server_address(
552 int dir_fd,
553 const char *path,
554 struct in_addr *ret_address,
555 uint8_t *ret_prefixlen) {
556
557 _cleanup_(saved_info_done) SavedInfo info = {};
558 int r;
559
560 if (!ret_address && !ret_prefixlen)
561 return 0;
562
563 r = load_leases_file(dir_fd, path, &info);
564 if (r < 0)
565 return r;
566
567 if (ret_address)
568 *ret_address = info.address;
569 if (ret_prefixlen)
570 *ret_prefixlen = info.prefixlen;
571 return 0;
572 }