]>
Commit | Line | Data |
---|---|---|
db9ecf05 | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
8fcf1d61 | 2 | |
5ae0fb7f | 3 | #include <netinet/in.h> |
7b9da386 LP |
4 | #include <linux/if_arp.h> |
5 | #include <linux/if.h> | |
5ae0fb7f | 6 | |
8fcf1d61 YW |
7 | #include "sd-dhcp-server.h" |
8 | ||
34bea0a1 | 9 | #include "dhcp-protocol.h" |
dd1d3060 MAL |
10 | #include "fd-util.h" |
11 | #include "fileio.h" | |
34bea0a1 | 12 | #include "network-common.h" |
093e3533 | 13 | #include "networkd-address.h" |
a95e9306 | 14 | #include "networkd-dhcp-server-bus.h" |
c517a49b | 15 | #include "networkd-dhcp-server-static-lease.h" |
16 | #include "networkd-dhcp-server.h" | |
8fcf1d61 YW |
17 | #include "networkd-link.h" |
18 | #include "networkd-manager.h" | |
19 | #include "networkd-network.h" | |
1d28a3cf | 20 | #include "networkd-queue.h" |
344b3cff | 21 | #include "networkd-route-util.h" |
564ca984 | 22 | #include "parse-util.h" |
dd1d3060 | 23 | #include "socket-netlink.h" |
564ca984 SS |
24 | #include "string-table.h" |
25 | #include "string-util.h" | |
dd1d3060 | 26 | #include "strv.h" |
8fcf1d61 | 27 | |
5ae0fb7f YW |
28 | static bool link_dhcp4_server_enabled(Link *link) { |
29 | assert(link); | |
30 | ||
31 | if (link->flags & IFF_LOOPBACK) | |
32 | return false; | |
33 | ||
34 | if (!link->network) | |
35 | return false; | |
36 | ||
5ae0fb7f YW |
37 | if (link->iftype == ARPHRD_CAN) |
38 | return false; | |
39 | ||
40 | return link->network->dhcp_server; | |
41 | } | |
42 | ||
5459e11d YW |
43 | int network_adjust_dhcp_server(Network *network, Set **addresses) { |
44 | int r; | |
45 | ||
0017ba31 | 46 | assert(network); |
5459e11d | 47 | assert(addresses); |
0017ba31 YW |
48 | |
49 | if (!network->dhcp_server) | |
5459e11d | 50 | return 0; |
0017ba31 YW |
51 | |
52 | if (network->bond) { | |
53 | log_warning("%s: DHCPServer= is enabled for bond slave. Disabling DHCP server.", | |
54 | network->filename); | |
55 | network->dhcp_server = false; | |
5459e11d | 56 | return 0; |
0017ba31 YW |
57 | } |
58 | ||
5459e11d YW |
59 | assert(network->dhcp_server_address_prefixlen <= 32); |
60 | ||
61 | if (network->dhcp_server_address_prefixlen == 0) { | |
0017ba31 | 62 | Address *address; |
5459e11d YW |
63 | |
64 | /* If the server address is not specified, then find suitable static address. */ | |
0017ba31 YW |
65 | |
66 | ORDERED_HASHMAP_FOREACH(address, network->addresses_by_section) { | |
26f88471 | 67 | assert(!section_is_invalid(address->section)); |
bab29f2a YW |
68 | |
69 | if (address->family != AF_INET) | |
70 | continue; | |
71 | ||
72 | if (in4_addr_is_localhost(&address->in_addr.in)) | |
73 | continue; | |
74 | ||
75 | if (in4_addr_is_link_local(&address->in_addr.in)) | |
76 | continue; | |
77 | ||
78 | if (in4_addr_is_set(&address->in_addr_peer.in)) | |
79 | continue; | |
80 | ||
5459e11d YW |
81 | /* TODO: check if the prefix length is small enough for the pool. */ |
82 | ||
83 | network->dhcp_server_address = address; | |
bab29f2a | 84 | break; |
0017ba31 | 85 | } |
5459e11d YW |
86 | if (!network->dhcp_server_address) { |
87 | log_warning("%s: DHCPServer= is enabled, but no suitable static address configured. " | |
0017ba31 YW |
88 | "Disabling DHCP server.", |
89 | network->filename); | |
90 | network->dhcp_server = false; | |
5459e11d | 91 | return 0; |
0017ba31 | 92 | } |
3b6a3bde | 93 | |
5459e11d YW |
94 | } else { |
95 | _cleanup_(address_freep) Address *a = NULL; | |
96 | Address *existing; | |
97 | unsigned line; | |
98 | ||
99 | /* TODO: check if the prefix length is small enough for the pool. */ | |
100 | ||
101 | /* If an address is explicitly specified, then check if the corresponding [Address] section | |
102 | * is configured, and add one if not. */ | |
103 | ||
104 | existing = set_get(*addresses, | |
105 | &(Address) { | |
106 | .family = AF_INET, | |
107 | .in_addr.in = network->dhcp_server_address_in_addr, | |
108 | .prefixlen = network->dhcp_server_address_prefixlen, | |
109 | }); | |
110 | if (existing) { | |
111 | /* Corresponding [Address] section already exists. */ | |
112 | network->dhcp_server_address = existing; | |
113 | return 0; | |
114 | } | |
3b6a3bde | 115 | |
5459e11d YW |
116 | r = ordered_hashmap_by_section_find_unused_line(network->addresses_by_section, network->filename, &line); |
117 | if (r < 0) | |
118 | return log_warning_errno(r, "%s: Failed to find unused line number for DHCP server address: %m", | |
119 | network->filename); | |
3b6a3bde | 120 | |
5459e11d YW |
121 | r = address_new_static(network, network->filename, line, &a); |
122 | if (r < 0) | |
123 | return log_warning_errno(r, "%s: Failed to add new static address object for DHCP server: %m", | |
124 | network->filename); | |
8fcf1d61 | 125 | |
5459e11d YW |
126 | a->family = AF_INET; |
127 | a->prefixlen = network->dhcp_server_address_prefixlen; | |
128 | a->in_addr.in = network->dhcp_server_address_in_addr; | |
129 | a->requested_as_null = !in4_addr_is_set(&network->dhcp_server_address_in_addr); | |
8fcf1d61 | 130 | |
5459e11d YW |
131 | r = address_section_verify(a); |
132 | if (r < 0) | |
133 | return r; | |
8fcf1d61 | 134 | |
5459e11d YW |
135 | r = set_ensure_put(addresses, &address_hash_ops, a); |
136 | if (r < 0) | |
137 | return log_oom(); | |
138 | assert(r > 0); | |
3b6a3bde | 139 | |
5459e11d | 140 | network->dhcp_server_address = TAKE_PTR(a); |
3b6a3bde | 141 | } |
8fcf1d61 | 142 | |
5459e11d | 143 | return 0; |
8fcf1d61 YW |
144 | } |
145 | ||
165d7c5c YW |
146 | static int dhcp_server_find_uplink(Link *link, Link **ret) { |
147 | assert(link); | |
148 | ||
149 | if (link->network->dhcp_server_uplink_name) | |
150 | return link_get_by_name(link->manager, link->network->dhcp_server_uplink_name, ret); | |
151 | ||
152 | if (link->network->dhcp_server_uplink_index > 0) | |
6eab614d | 153 | return link_get_by_index(link->manager, link->network->dhcp_server_uplink_index, ret); |
165d7c5c | 154 | |
63295b42 | 155 | if (link->network->dhcp_server_uplink_index == UPLINK_INDEX_AUTO) { |
165d7c5c YW |
156 | /* It is not necessary to propagate error in automatic selection. */ |
157 | if (manager_find_uplink(link->manager, AF_INET, link, ret) < 0) | |
158 | *ret = NULL; | |
159 | return 0; | |
160 | } | |
161 | ||
162 | *ret = NULL; | |
163 | return 0; | |
164 | } | |
165 | ||
2a71d57f LP |
166 | static int link_push_uplink_to_dhcp_server( |
167 | Link *link, | |
2324fd3a | 168 | sd_dhcp_lease_server_type_t what, |
2a71d57f LP |
169 | sd_dhcp_server *s) { |
170 | ||
8fcf1d61 | 171 | _cleanup_free_ struct in_addr *addresses = NULL; |
2a71d57f | 172 | bool use_dhcp_lease_data = true; |
319a4f4b | 173 | size_t n_addresses = 0; |
8fcf1d61 | 174 | |
2a71d57f | 175 | assert(link); |
8fcf1d61 | 176 | |
2a71d57f LP |
177 | if (!link->network) |
178 | return 0; | |
179 | assert(link->network); | |
8fcf1d61 | 180 | |
2a71d57f | 181 | log_link_debug(link, "Copying %s from link", dhcp_lease_server_type_to_string(what)); |
8fcf1d61 | 182 | |
2a71d57f | 183 | switch (what) { |
8fcf1d61 | 184 | |
2a71d57f LP |
185 | case SD_DHCP_LEASE_DNS: |
186 | /* For DNS we have a special case. We the data configured explicitly locally along with the | |
187 | * data from the DHCP lease. */ | |
8fcf1d61 | 188 | |
2a71d57f LP |
189 | for (unsigned i = 0; i < link->network->n_dns; i++) { |
190 | struct in_addr ia; | |
8fcf1d61 | 191 | |
2a71d57f | 192 | /* Only look for IPv4 addresses */ |
e77bd3fd | 193 | if (link->network->dns[i]->family != AF_INET) |
2a71d57f | 194 | continue; |
8fcf1d61 | 195 | |
e77bd3fd | 196 | ia = link->network->dns[i]->address.in; |
2a71d57f LP |
197 | |
198 | /* Never propagate obviously borked data */ | |
199 | if (in4_addr_is_null(&ia) || in4_addr_is_localhost(&ia)) | |
200 | continue; | |
201 | ||
319a4f4b | 202 | if (!GREEDY_REALLOC(addresses, n_addresses + 1)) |
8fcf1d61 YW |
203 | return log_oom(); |
204 | ||
2a71d57f | 205 | addresses[n_addresses++] = ia; |
8fcf1d61 | 206 | } |
8fcf1d61 | 207 | |
2a71d57f LP |
208 | use_dhcp_lease_data = link->network->dhcp_use_dns; |
209 | break; | |
8fcf1d61 | 210 | |
2a71d57f | 211 | case SD_DHCP_LEASE_NTP: { |
2a71d57f LP |
212 | /* For NTP things are similar, but for NTP hostnames can be configured too, which we cannot |
213 | * propagate via DHCP. Hence let's only propagate those which are IP addresses. */ | |
284e8fd0 | 214 | |
2a71d57f LP |
215 | STRV_FOREACH(i, link->network->ntp) { |
216 | union in_addr_union ia; | |
284e8fd0 | 217 | |
2a71d57f LP |
218 | if (in_addr_from_string(AF_INET, *i, &ia) < 0) |
219 | continue; | |
284e8fd0 | 220 | |
2a71d57f LP |
221 | /* Never propagate obviously borked data */ |
222 | if (in4_addr_is_null(&ia.in) || in4_addr_is_localhost(&ia.in)) | |
223 | continue; | |
284e8fd0 | 224 | |
319a4f4b | 225 | if (!GREEDY_REALLOC(addresses, n_addresses + 1)) |
2a71d57f | 226 | return log_oom(); |
284e8fd0 | 227 | |
2a71d57f LP |
228 | addresses[n_addresses++] = ia.in; |
229 | } | |
284e8fd0 | 230 | |
2a71d57f | 231 | use_dhcp_lease_data = link->network->dhcp_use_ntp; |
24e6f458 | 232 | break; |
2a71d57f | 233 | } |
284e8fd0 | 234 | |
ddb82ec2 | 235 | case SD_DHCP_LEASE_SIP: |
2a71d57f LP |
236 | |
237 | /* For SIP we don't allow explicit, local configuration, but there's control whether to use the data */ | |
238 | use_dhcp_lease_data = link->network->dhcp_use_sip; | |
24e6f458 | 239 | break; |
284e8fd0 | 240 | |
2a71d57f LP |
241 | case SD_DHCP_LEASE_POP3: |
242 | case SD_DHCP_LEASE_SMTP: | |
ddb82ec2 | 243 | case SD_DHCP_LEASE_LPR: |
2a71d57f LP |
244 | /* For the other server types we currently do not allow local configuration of server data, |
245 | * since there are typically no local consumers of the data. */ | |
c4e585a3 | 246 | break; |
d361b373 | 247 | |
24e6f458 | 248 | default: |
04499a70 | 249 | assert_not_reached(); |
f6269fe7 SS |
250 | } |
251 | ||
2a71d57f | 252 | if (use_dhcp_lease_data && link->dhcp_lease) { |
24e6f458 | 253 | const struct in_addr *da; |
f6269fe7 | 254 | |
a2706075 | 255 | int n = sd_dhcp_lease_get_servers(link->dhcp_lease, what, &da); |
f6269fe7 | 256 | if (n > 0) { |
319a4f4b | 257 | if (!GREEDY_REALLOC(addresses, n_addresses + n)) |
f6269fe7 SS |
258 | return log_oom(); |
259 | ||
2a71d57f LP |
260 | for (int j = 0; j < n; j++) |
261 | if (in4_addr_is_non_local(&da[j])) | |
262 | addresses[n_addresses++] = da[j]; | |
f6269fe7 SS |
263 | } |
264 | } | |
265 | ||
266 | if (n_addresses <= 0) | |
267 | return 0; | |
268 | ||
24e6f458 | 269 | return sd_dhcp_server_set_servers(s, what, addresses, n_addresses); |
299d578f SS |
270 | } |
271 | ||
319a4f4b LP |
272 | static int dhcp4_server_parse_dns_server_string_and_warn( |
273 | const char *string, | |
274 | struct in_addr **addresses, | |
275 | size_t *n_addresses) { | |
276 | ||
dd1d3060 MAL |
277 | for (;;) { |
278 | _cleanup_free_ char *word = NULL, *server_name = NULL; | |
279 | union in_addr_union address; | |
280 | int family, r, ifindex = 0; | |
281 | ||
282 | r = extract_first_word(&string, &word, NULL, 0); | |
283 | if (r < 0) | |
284 | return r; | |
285 | if (r == 0) | |
286 | break; | |
287 | ||
288 | r = in_addr_ifindex_name_from_string_auto(word, &family, &address, &ifindex, &server_name); | |
289 | if (r < 0) { | |
290 | log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring: %m", word); | |
291 | continue; | |
292 | } | |
293 | ||
294 | /* Only look for IPv4 addresses */ | |
295 | if (family != AF_INET) | |
296 | continue; | |
297 | ||
298 | /* Never propagate obviously borked data */ | |
299 | if (in4_addr_is_null(&address.in) || in4_addr_is_localhost(&address.in)) | |
300 | continue; | |
301 | ||
319a4f4b | 302 | if (!GREEDY_REALLOC(*addresses, *n_addresses + 1)) |
dd1d3060 MAL |
303 | return log_oom(); |
304 | ||
305 | (*addresses)[(*n_addresses)++] = address.in; | |
306 | } | |
307 | ||
308 | return 0; | |
309 | } | |
310 | ||
311 | static int dhcp4_server_set_dns_from_resolve_conf(Link *link) { | |
312 | _cleanup_free_ struct in_addr *addresses = NULL; | |
dd1d3060 | 313 | _cleanup_fclose_ FILE *f = NULL; |
319a4f4b | 314 | size_t n_addresses = 0; |
f8769631 | 315 | int r; |
dd1d3060 MAL |
316 | |
317 | f = fopen(PRIVATE_UPLINK_RESOLV_CONF, "re"); | |
318 | if (!f) { | |
319 | if (errno == ENOENT) | |
320 | return 0; | |
321 | ||
322 | return log_warning_errno(errno, "Failed to open " PRIVATE_UPLINK_RESOLV_CONF ": %m"); | |
323 | } | |
324 | ||
325 | for (;;) { | |
326 | _cleanup_free_ char *line = NULL; | |
327 | const char *a; | |
dd1d3060 | 328 | |
0ff6ff2b | 329 | r = read_stripped_line(f, LONG_LINE_MAX, &line); |
dd1d3060 MAL |
330 | if (r < 0) |
331 | return log_error_errno(r, "Failed to read " PRIVATE_UPLINK_RESOLV_CONF ": %m"); | |
332 | if (r == 0) | |
333 | break; | |
334 | ||
0ff6ff2b | 335 | if (IN_SET(*line, '#', ';', 0)) |
dd1d3060 MAL |
336 | continue; |
337 | ||
0ff6ff2b | 338 | a = first_word(line, "nameserver"); |
dd1d3060 MAL |
339 | if (!a) |
340 | continue; | |
341 | ||
319a4f4b | 342 | r = dhcp4_server_parse_dns_server_string_and_warn(a, &addresses, &n_addresses); |
dd1d3060 MAL |
343 | if (r < 0) |
344 | log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring.", a); | |
345 | } | |
346 | ||
347 | if (n_addresses <= 0) | |
348 | return 0; | |
349 | ||
350 | return sd_dhcp_server_set_dns(link->dhcp_server, addresses, n_addresses); | |
351 | } | |
352 | ||
1d28a3cf | 353 | static int dhcp4_server_configure(Link *link) { |
8fcf1d61 | 354 | bool acquired_uplink = false; |
461dbb2f | 355 | sd_dhcp_option *p; |
c517a49b | 356 | DHCPStaticLease *static_lease; |
564ca984 SS |
357 | Link *uplink = NULL; |
358 | Address *address; | |
11c38d3e | 359 | bool bind_to_interface; |
8fcf1d61 YW |
360 | int r; |
361 | ||
5ae0fb7f | 362 | assert(link); |
5459e11d YW |
363 | assert(link->network); |
364 | assert(link->network->dhcp_server_address); | |
5ae0fb7f | 365 | |
1d28a3cf | 366 | log_link_debug(link, "Configuring DHCP Server."); |
5ae0fb7f | 367 | |
1d28a3cf YW |
368 | if (link->dhcp_server) |
369 | return -EBUSY; | |
5ae0fb7f | 370 | |
1d28a3cf YW |
371 | r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex); |
372 | if (r < 0) | |
373 | return r; | |
5ae0fb7f | 374 | |
1d28a3cf YW |
375 | r = sd_dhcp_server_attach_event(link->dhcp_server, link->manager->event, 0); |
376 | if (r < 0) | |
377 | return r; | |
5ae0fb7f | 378 | |
a95e9306 LK |
379 | r = sd_dhcp_server_set_callback(link->dhcp_server, dhcp_server_callback, link); |
380 | if (r < 0) | |
381 | return log_link_warning_errno(link, r, "Failed to set callback for DHCPv4 server instance: %m"); | |
382 | ||
5459e11d | 383 | r = address_get(link, link->network->dhcp_server_address, &address); |
0017ba31 YW |
384 | if (r < 0) |
385 | return log_link_error_errno(link, r, "Failed to find suitable address for DHCPv4 server instance: %m"); | |
8fcf1d61 YW |
386 | |
387 | /* use the server address' subnet as the pool */ | |
388 | r = sd_dhcp_server_configure_pool(link->dhcp_server, &address->in_addr.in, address->prefixlen, | |
389 | link->network->dhcp_server_pool_offset, link->network->dhcp_server_pool_size); | |
390 | if (r < 0) | |
c00c3b64 | 391 | return log_link_error_errno(link, r, "Failed to configure address pool for DHCPv4 server instance: %m"); |
8fcf1d61 | 392 | |
8fcf1d61 | 393 | if (link->network->dhcp_server_max_lease_time_usec > 0) { |
a0007611 | 394 | r = sd_dhcp_server_set_max_lease_time(link->dhcp_server, link->network->dhcp_server_max_lease_time_usec); |
8fcf1d61 | 395 | if (r < 0) |
c00c3b64 | 396 | return log_link_error_errno(link, r, "Failed to set maximum lease time for DHCPv4 server instance: %m"); |
8fcf1d61 YW |
397 | } |
398 | ||
399 | if (link->network->dhcp_server_default_lease_time_usec > 0) { | |
a0007611 | 400 | r = sd_dhcp_server_set_default_lease_time(link->dhcp_server, link->network->dhcp_server_default_lease_time_usec); |
8fcf1d61 | 401 | if (r < 0) |
c00c3b64 | 402 | return log_link_error_errno(link, r, "Failed to set default lease time for DHCPv4 server instance: %m"); |
8fcf1d61 YW |
403 | } |
404 | ||
34bea0a1 SS |
405 | r = sd_dhcp_server_set_ipv6_only_preferred_usec(link->dhcp_server, link->network->dhcp_server_ipv6_only_preferred_usec); |
406 | if (r < 0) | |
407 | return log_link_error_errno(link, r, "Failed to set IPv6 only preferred time for DHCPv4 server instance: %m"); | |
408 | ||
6278e428 | 409 | r = sd_dhcp_server_set_boot_server_address(link->dhcp_server, &link->network->dhcp_server_boot_server_address); |
369ac192 | 410 | if (r < 0) |
6278e428 | 411 | return log_link_warning_errno(link, r, "Failed to set boot server address for DHCPv4 server instance: %m"); |
369ac192 | 412 | |
6278e428 | 413 | r = sd_dhcp_server_set_boot_server_name(link->dhcp_server, link->network->dhcp_server_boot_server_name); |
369ac192 | 414 | if (r < 0) |
6278e428 YW |
415 | return log_link_warning_errno(link, r, "Failed to set boot server name for DHCPv4 server instance: %m"); |
416 | ||
417 | r = sd_dhcp_server_set_boot_filename(link->dhcp_server, link->network->dhcp_server_boot_filename); | |
418 | if (r < 0) | |
419 | return log_link_warning_errno(link, r, "Failed to set boot filename for DHCPv4 server instance: %m"); | |
369ac192 | 420 | |
2324fd3a | 421 | for (sd_dhcp_lease_server_type_t type = 0; type < _SD_DHCP_LEASE_SERVER_TYPE_MAX; type ++) { |
2a71d57f LP |
422 | |
423 | if (!link->network->dhcp_server_emit[type].emit) | |
424 | continue; | |
425 | ||
426 | if (link->network->dhcp_server_emit[type].n_addresses > 0) | |
427 | /* Explicitly specified servers to emit */ | |
428 | r = sd_dhcp_server_set_servers( | |
429 | link->dhcp_server, | |
430 | type, | |
431 | link->network->dhcp_server_emit[type].addresses, | |
432 | link->network->dhcp_server_emit[type].n_addresses); | |
433 | else { | |
434 | /* Emission is requested, but nothing explicitly configured. Let's find a suitable upling */ | |
435 | if (!acquired_uplink) { | |
165d7c5c | 436 | (void) dhcp_server_find_uplink(link, &uplink); |
2a71d57f LP |
437 | acquired_uplink = true; |
438 | } | |
439 | ||
440 | if (uplink && uplink->network) | |
441 | r = link_push_uplink_to_dhcp_server(uplink, type, link->dhcp_server); | |
442 | else if (type == SD_DHCP_LEASE_DNS) | |
443 | r = dhcp4_server_set_dns_from_resolve_conf(link); | |
24e6f458 | 444 | else { |
2a71d57f LP |
445 | log_link_debug(link, |
446 | "Not emitting %s on link, couldn't find suitable uplink.", | |
447 | dhcp_lease_server_type_to_string(type)); | |
448 | continue; | |
24e6f458 | 449 | } |
299d578f | 450 | } |
284e8fd0 | 451 | |
2a71d57f LP |
452 | if (r < 0) |
453 | log_link_warning_errno(link, r, | |
454 | "Failed to set %s for DHCP server, ignoring: %m", | |
455 | dhcp_lease_server_type_to_string(type)); | |
456 | } | |
457 | ||
59aa6220 YW |
458 | if (link->network->dhcp_server_emit_router) { |
459 | r = sd_dhcp_server_set_router(link->dhcp_server, &link->network->dhcp_server_router); | |
460 | if (r < 0) | |
461 | return log_link_error_errno(link, r, "Failed to set router address for DHCP server: %m"); | |
462 | } | |
8fcf1d61 | 463 | |
c95df587 YA |
464 | r = sd_dhcp_server_set_relay_target(link->dhcp_server, &link->network->dhcp_server_relay_target); |
465 | if (r < 0) | |
466 | return log_link_error_errno(link, r, "Failed to set relay target for DHCP server: %m"); | |
467 | ||
11c38d3e YA |
468 | bind_to_interface = sd_dhcp_server_is_in_relay_mode(link->dhcp_server) ? false : link->network->dhcp_server_bind_to_interface; |
469 | r = sd_dhcp_server_set_bind_to_interface(link->dhcp_server, bind_to_interface); | |
470 | if (r < 0) | |
471 | return log_link_error_errno(link, r, "Failed to set interface binding for DHCP server: %m"); | |
472 | ||
473 | r = sd_dhcp_server_set_relay_agent_information(link->dhcp_server, link->network->dhcp_server_relay_agent_circuit_id, link->network->dhcp_server_relay_agent_remote_id); | |
474 | if (r < 0) | |
475 | return log_link_error_errno(link, r, "Failed to set agent circuit/remote id for DHCP server: %m"); | |
476 | ||
8fcf1d61 YW |
477 | if (link->network->dhcp_server_emit_timezone) { |
478 | _cleanup_free_ char *buffer = NULL; | |
7b5018ca | 479 | const char *tz = NULL; |
8fcf1d61 YW |
480 | |
481 | if (link->network->dhcp_server_timezone) | |
482 | tz = link->network->dhcp_server_timezone; | |
483 | else { | |
484 | r = get_timezone(&buffer); | |
485 | if (r < 0) | |
7b5018ca | 486 | log_link_warning_errno(link, r, "Failed to determine timezone, not sending timezone: %m"); |
487 | else | |
488 | tz = buffer; | |
8fcf1d61 YW |
489 | } |
490 | ||
7b5018ca | 491 | if (tz) { |
492 | r = sd_dhcp_server_set_timezone(link->dhcp_server, tz); | |
493 | if (r < 0) | |
494 | return log_link_error_errno(link, r, "Failed to set timezone for DHCP server: %m"); | |
495 | } | |
8fcf1d61 | 496 | } |
564ca984 | 497 | |
90e74a66 | 498 | ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_options) { |
461dbb2f | 499 | r = sd_dhcp_server_add_option(link->dhcp_server, p); |
564ca984 SS |
500 | if (r == -EEXIST) |
501 | continue; | |
502 | if (r < 0) | |
c00c3b64 | 503 | return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m"); |
564ca984 SS |
504 | } |
505 | ||
90e74a66 | 506 | ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_vendor_options) { |
7354900d DW |
507 | r = sd_dhcp_server_add_vendor_option(link->dhcp_server, p); |
508 | if (r == -EEXIST) | |
509 | continue; | |
510 | if (r < 0) | |
511 | return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m"); | |
512 | } | |
513 | ||
c517a49b | 514 | HASHMAP_FOREACH(static_lease, link->network->dhcp_static_leases_by_section) { |
515 | r = sd_dhcp_server_set_static_lease(link->dhcp_server, &static_lease->address, static_lease->client_id, static_lease->client_id_size); | |
516 | if (r < 0) | |
517 | return log_link_error_errno(link, r, "Failed to set DHCPv4 static lease for DHCP server: %m"); | |
518 | } | |
519 | ||
ab486ef4 YW |
520 | r = sd_dhcp_server_start(link->dhcp_server); |
521 | if (r < 0) | |
522 | return log_link_error_errno(link, r, "Could not start DHCPv4 server instance: %m"); | |
5ae0fb7f | 523 | |
ab486ef4 | 524 | log_link_debug(link, "Offering DHCPv4 leases"); |
745f0620 | 525 | return 0; |
1d28a3cf YW |
526 | } |
527 | ||
1d28a3cf | 528 | static bool dhcp_server_is_ready_to_configure(Link *link) { |
165d7c5c | 529 | Link *uplink = NULL; |
1d28a3cf YW |
530 | Address *a; |
531 | ||
532 | assert(link); | |
5459e11d YW |
533 | assert(link->network); |
534 | assert(link->network->dhcp_server_address); | |
1d28a3cf | 535 | |
4b482e8b | 536 | if (!link_is_ready_to_configure(link, /* allow_unmanaged = */ false)) |
baa95d22 YW |
537 | return false; |
538 | ||
1d28a3cf YW |
539 | if (!link_has_carrier(link)) |
540 | return false; | |
541 | ||
1d28a3cf YW |
542 | if (!link->static_addresses_configured) |
543 | return false; | |
544 | ||
5459e11d | 545 | if (address_get(link, link->network->dhcp_server_address, &a) < 0) |
1d28a3cf YW |
546 | return false; |
547 | ||
548 | if (!address_is_ready(a)) | |
549 | return false; | |
550 | ||
165d7c5c YW |
551 | if (dhcp_server_find_uplink(link, &uplink) < 0) |
552 | return false; | |
553 | ||
554 | if (uplink && !uplink->network) | |
555 | return false; | |
556 | ||
1d28a3cf YW |
557 | return true; |
558 | } | |
559 | ||
09d09207 | 560 | static int dhcp_server_process_request(Request *req, Link *link, void *userdata) { |
745f0620 YW |
561 | int r; |
562 | ||
ff51134c | 563 | assert(link); |
1d28a3cf | 564 | |
745f0620 | 565 | if (!dhcp_server_is_ready_to_configure(link)) |
1d28a3cf YW |
566 | return 0; |
567 | ||
745f0620 YW |
568 | r = dhcp4_server_configure(link); |
569 | if (r < 0) | |
570 | return log_link_warning_errno(link, r, "Failed to configure DHCP server: %m"); | |
571 | ||
572 | return 1; | |
8fcf1d61 YW |
573 | } |
574 | ||
8bed7c55 | 575 | int link_request_dhcp_server(Link *link) { |
745f0620 YW |
576 | int r; |
577 | ||
8bed7c55 YW |
578 | assert(link); |
579 | ||
580 | if (!link_dhcp4_server_enabled(link)) | |
581 | return 0; | |
582 | ||
583 | if (link->dhcp_server) | |
584 | return 0; | |
585 | ||
586 | log_link_debug(link, "Requesting DHCP server."); | |
09d09207 | 587 | r = link_queue_request(link, REQUEST_TYPE_DHCP_SERVER, dhcp_server_process_request, NULL); |
745f0620 YW |
588 | if (r < 0) |
589 | return log_link_warning_errno(link, r, "Failed to request configuration of DHCP server: %m"); | |
590 | ||
591 | return 0; | |
8bed7c55 YW |
592 | } |
593 | ||
11c38d3e YA |
594 | int config_parse_dhcp_server_relay_agent_suboption( |
595 | const char *unit, | |
596 | const char *filename, | |
597 | unsigned line, | |
598 | const char *section, | |
599 | unsigned section_line, | |
600 | const char *lvalue, | |
601 | int ltype, | |
602 | const char *rvalue, | |
603 | void *data, | |
604 | void *userdata) { | |
605 | ||
606 | char **suboption_value = data; | |
607 | char* p; | |
608 | ||
609 | assert(filename); | |
610 | assert(lvalue); | |
611 | assert(rvalue); | |
612 | ||
11c38d3e YA |
613 | if (isempty(rvalue)) { |
614 | *suboption_value = mfree(*suboption_value); | |
615 | return 0; | |
616 | } | |
617 | ||
618 | p = startswith(rvalue, "string:"); | |
619 | if (!p) { | |
620 | log_syntax(unit, LOG_WARNING, filename, line, 0, | |
621 | "Failed to parse %s=%s'. Invalid format, ignoring.", lvalue, rvalue); | |
622 | return 0; | |
623 | } | |
624 | return free_and_strdup(suboption_value, empty_to_null(p)); | |
625 | } | |
626 | ||
2a71d57f | 627 | int config_parse_dhcp_server_emit( |
8fcf1d61 YW |
628 | const char *unit, |
629 | const char *filename, | |
630 | unsigned line, | |
2a71d57f LP |
631 | const char *section, |
632 | unsigned section_line, | |
8fcf1d61 | 633 | const char *lvalue, |
2a71d57f | 634 | int ltype, |
8fcf1d61 | 635 | const char *rvalue, |
2a71d57f LP |
636 | void *data, |
637 | void *userdata) { | |
8fcf1d61 | 638 | |
99534007 | 639 | NetworkDHCPServerEmitAddress *emit = ASSERT_PTR(data); |
2a71d57f | 640 | |
8fcf1d61 YW |
641 | assert(rvalue); |
642 | ||
faa1b3c6 YW |
643 | if (isempty(rvalue)) { |
644 | emit->addresses = mfree(emit->addresses); | |
645 | emit->n_addresses = 0; | |
646 | return 0; | |
647 | } | |
648 | ||
c1997a5b | 649 | for (const char *p = rvalue;;) { |
8fcf1d61 YW |
650 | _cleanup_free_ char *w = NULL; |
651 | union in_addr_union a; | |
c1997a5b | 652 | int r; |
8fcf1d61 YW |
653 | |
654 | r = extract_first_word(&p, &w, NULL, 0); | |
655 | if (r == -ENOMEM) | |
656 | return log_oom(); | |
657 | if (r < 0) { | |
d96edb2c | 658 | log_syntax(unit, LOG_WARNING, filename, line, r, |
8fcf1d61 YW |
659 | "Failed to extract word, ignoring: %s", rvalue); |
660 | return 0; | |
661 | } | |
662 | if (r == 0) | |
c1997a5b | 663 | return 0; |
8fcf1d61 | 664 | |
5f468b9f YW |
665 | if (streq(w, "_server_address")) |
666 | a = IN_ADDR_NULL; /* null address will be converted to the server address. */ | |
667 | else { | |
668 | r = in_addr_from_string(AF_INET, w, &a); | |
669 | if (r < 0) { | |
670 | log_syntax(unit, LOG_WARNING, filename, line, r, | |
671 | "Failed to parse %s= address '%s', ignoring: %m", lvalue, w); | |
672 | continue; | |
673 | } | |
674 | ||
675 | if (in4_addr_is_null(&a.in)) { | |
676 | log_syntax(unit, LOG_WARNING, filename, line, 0, | |
677 | "Found a null address in %s=, ignoring.", lvalue); | |
678 | continue; | |
679 | } | |
8fcf1d61 YW |
680 | } |
681 | ||
77e73102 | 682 | if (!GREEDY_REALLOC(emit->addresses, emit->n_addresses + 1)) |
8fcf1d61 YW |
683 | return log_oom(); |
684 | ||
2a71d57f | 685 | emit->addresses[emit->n_addresses++] = a.in; |
8fcf1d61 | 686 | } |
8fcf1d61 | 687 | } |
0017ba31 YW |
688 | |
689 | int config_parse_dhcp_server_address( | |
690 | const char *unit, | |
691 | const char *filename, | |
692 | unsigned line, | |
693 | const char *section, | |
694 | unsigned section_line, | |
695 | const char *lvalue, | |
696 | int ltype, | |
697 | const char *rvalue, | |
698 | void *data, | |
699 | void *userdata) { | |
700 | ||
6278e428 | 701 | Network *network = ASSERT_PTR(userdata); |
0017ba31 YW |
702 | union in_addr_union a; |
703 | unsigned char prefixlen; | |
704 | int r; | |
705 | ||
706 | assert(filename); | |
707 | assert(lvalue); | |
708 | assert(rvalue); | |
709 | ||
710 | if (isempty(rvalue)) { | |
5459e11d | 711 | network->dhcp_server_address_in_addr = (struct in_addr) {}; |
0017ba31 YW |
712 | network->dhcp_server_address_prefixlen = 0; |
713 | return 0; | |
714 | } | |
715 | ||
716 | r = in_addr_prefix_from_string(rvalue, AF_INET, &a, &prefixlen); | |
717 | if (r < 0) { | |
718 | log_syntax(unit, LOG_WARNING, filename, line, r, | |
719 | "Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue); | |
720 | return 0; | |
721 | } | |
a0dfce0a | 722 | if (in4_addr_is_localhost(&a.in) || in4_addr_is_link_local(&a.in)) { |
0017ba31 | 723 | log_syntax(unit, LOG_WARNING, filename, line, 0, |
a0dfce0a | 724 | "DHCP server address cannot be a localhost or link-local address, " |
0017ba31 YW |
725 | "ignoring assignment: %s", rvalue); |
726 | return 0; | |
727 | } | |
728 | ||
5459e11d | 729 | network->dhcp_server_address_in_addr = a.in; |
0017ba31 YW |
730 | network->dhcp_server_address_prefixlen = prefixlen; |
731 | return 0; | |
732 | } | |
34bea0a1 SS |
733 | |
734 | int config_parse_dhcp_server_ipv6_only_preferred( | |
735 | const char *unit, | |
736 | const char *filename, | |
737 | unsigned line, | |
738 | const char *section, | |
739 | unsigned section_line, | |
740 | const char *lvalue, | |
741 | int ltype, | |
742 | const char *rvalue, | |
743 | void *data, | |
744 | void *userdata) { | |
745 | ||
746 | usec_t t, *usec = ASSERT_PTR(data); | |
747 | int r; | |
748 | ||
749 | assert(filename); | |
750 | assert(section); | |
751 | assert(lvalue); | |
752 | assert(rvalue); | |
753 | ||
754 | if (isempty(rvalue)) { | |
755 | *usec = 0; | |
756 | return 0; | |
757 | } | |
758 | ||
759 | r = parse_sec(rvalue, &t); | |
760 | if (r < 0) { | |
761 | log_syntax(unit, LOG_WARNING, filename, line, r, | |
762 | "Failed to parse [%s] %s=, ignoring assignment: %s", section, lvalue, rvalue); | |
763 | return 0; | |
764 | } | |
765 | ||
766 | if (t < MIN_V6ONLY_WAIT_USEC && !network_test_mode_enabled()) { | |
767 | log_syntax(unit, LOG_WARNING, filename, line, 0, | |
768 | "Invalid [%s] %s=, ignoring assignment: %s", section, lvalue, rvalue); | |
769 | return 0; | |
770 | } | |
771 | ||
772 | *usec = t; | |
773 | return 0; | |
774 | } |