]>
Commit | Line | Data |
---|---|---|
53e1b683 | 1 | /* SPDX-License-Identifier: LGPL-2.1+ */ |
091214b6 PF |
2 | /*** |
3 | This file is part of systemd. | |
4 | ||
5 | Copyright (C) 2017 Intel Corporation. All rights reserved. | |
091214b6 PF |
6 | ***/ |
7 | ||
8 | #include <netinet/icmp6.h> | |
9 | #include <arpa/inet.h> | |
10 | ||
11 | #include "networkd-address.h" | |
c555a358 | 12 | #include "networkd-manager.h" |
091214b6 | 13 | #include "networkd-radv.h" |
6e849e95 | 14 | #include "parse-util.h" |
091214b6 | 15 | #include "sd-radv.h" |
6e849e95 PF |
16 | #include "string-util.h" |
17 | ||
9c3b99fe YW |
18 | int config_parse_router_prefix_delegation( |
19 | const char *unit, | |
20 | const char *filename, | |
21 | unsigned line, | |
22 | const char *section, | |
23 | unsigned section_line, | |
24 | const char *lvalue, | |
25 | int ltype, | |
26 | const char *rvalue, | |
27 | void *data, | |
28 | void *userdata) { | |
29 | ||
56a23cb4 PF |
30 | Network *network = userdata; |
31 | int d; | |
32 | ||
33 | assert(filename); | |
34 | assert(section); | |
35 | assert(lvalue); | |
36 | assert(rvalue); | |
37 | assert(data); | |
38 | ||
39 | if (streq(rvalue, "static")) | |
40 | network->router_prefix_delegation = RADV_PREFIX_DELEGATION_STATIC; | |
41 | else if (streq(rvalue, "dhcpv6")) | |
42 | network->router_prefix_delegation = RADV_PREFIX_DELEGATION_DHCP6; | |
43 | else { | |
44 | d = parse_boolean(rvalue); | |
45 | if (d > 0) | |
46 | network->router_prefix_delegation = RADV_PREFIX_DELEGATION_BOTH; | |
47 | else | |
48 | network->router_prefix_delegation = RADV_PREFIX_DELEGATION_NONE; | |
49 | ||
50 | if (d < 0) | |
51 | log_syntax(unit, LOG_ERR, filename, line, -EINVAL, "Router prefix delegation '%s' is invalid, ignoring assignment: %m", rvalue); | |
52 | } | |
53 | ||
54 | return 0; | |
55 | } | |
56 | ||
6e849e95 PF |
57 | int config_parse_router_preference(const char *unit, |
58 | const char *filename, | |
59 | unsigned line, | |
60 | const char *section, | |
61 | unsigned section_line, | |
62 | const char *lvalue, | |
63 | int ltype, | |
64 | const char *rvalue, | |
65 | void *data, | |
66 | void *userdata) { | |
67 | Network *network = userdata; | |
68 | ||
69 | assert(filename); | |
70 | assert(section); | |
71 | assert(lvalue); | |
72 | assert(rvalue); | |
73 | assert(data); | |
74 | ||
75 | if (streq(rvalue, "high")) | |
76 | network->router_preference = SD_NDISC_PREFERENCE_HIGH; | |
77 | else if (STR_IN_SET(rvalue, "medium", "normal", "default")) | |
78 | network->router_preference = SD_NDISC_PREFERENCE_MEDIUM; | |
79 | else if (streq(rvalue, "low")) | |
80 | network->router_preference = SD_NDISC_PREFERENCE_LOW; | |
81 | else | |
82 | log_syntax(unit, LOG_ERR, filename, line, -EINVAL, "Router preference '%s' is invalid, ignoring assignment: %m", rvalue); | |
83 | ||
84 | return 0; | |
85 | } | |
86 | ||
87 | void prefix_free(Prefix *prefix) { | |
88 | if (!prefix) | |
89 | return; | |
90 | ||
91 | if (prefix->network) { | |
92 | LIST_REMOVE(prefixes, prefix->network->static_prefixes, prefix); | |
93 | assert(prefix->network->n_static_prefixes > 0); | |
94 | prefix->network->n_static_prefixes--; | |
95 | ||
96 | if (prefix->section) | |
97 | hashmap_remove(prefix->network->prefixes_by_section, | |
98 | prefix->section); | |
99 | } | |
100 | ||
101 | prefix->radv_prefix = sd_radv_prefix_unref(prefix->radv_prefix); | |
102 | ||
103 | free(prefix); | |
104 | } | |
105 | ||
106 | int prefix_new(Prefix **ret) { | |
107 | Prefix *prefix = NULL; | |
108 | ||
109 | prefix = new0(Prefix, 1); | |
110 | if (!prefix) | |
111 | return -ENOMEM; | |
112 | ||
113 | if (sd_radv_prefix_new(&prefix->radv_prefix) < 0) | |
114 | return -ENOMEM; | |
115 | ||
ae2a15bc | 116 | *ret = TAKE_PTR(prefix); |
6e849e95 PF |
117 | |
118 | return 0; | |
119 | } | |
120 | ||
121 | int prefix_new_static(Network *network, const char *filename, | |
122 | unsigned section_line, Prefix **ret) { | |
8e766630 LP |
123 | _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL; |
124 | _cleanup_(prefix_freep) Prefix *prefix = NULL; | |
6e849e95 PF |
125 | int r; |
126 | ||
127 | assert(network); | |
128 | assert(ret); | |
129 | assert(!!filename == (section_line > 0)); | |
130 | ||
131 | if (filename) { | |
132 | r = network_config_section_new(filename, section_line, &n); | |
133 | if (r < 0) | |
134 | return r; | |
135 | ||
136 | if (section_line) { | |
137 | prefix = hashmap_get(network->prefixes_by_section, n); | |
138 | if (prefix) { | |
1cc6c93a | 139 | *ret = TAKE_PTR(prefix); |
6e849e95 PF |
140 | |
141 | return 0; | |
142 | } | |
143 | } | |
144 | } | |
145 | ||
146 | r = prefix_new(&prefix); | |
147 | if (r < 0) | |
148 | return r; | |
149 | ||
150 | if (filename) { | |
1cc6c93a | 151 | prefix->section = TAKE_PTR(n); |
6e849e95 PF |
152 | |
153 | r = hashmap_put(network->prefixes_by_section, prefix->section, | |
154 | prefix); | |
155 | if (r < 0) | |
156 | return r; | |
157 | } | |
158 | ||
159 | prefix->network = network; | |
160 | LIST_APPEND(prefixes, network->static_prefixes, prefix); | |
161 | network->n_static_prefixes++; | |
162 | ||
1cc6c93a | 163 | *ret = TAKE_PTR(prefix); |
6e849e95 PF |
164 | |
165 | return 0; | |
166 | } | |
167 | ||
168 | int config_parse_prefix(const char *unit, | |
169 | const char *filename, | |
170 | unsigned line, | |
171 | const char *section, | |
172 | unsigned section_line, | |
173 | const char *lvalue, | |
174 | int ltype, | |
175 | const char *rvalue, | |
176 | void *data, | |
177 | void *userdata) { | |
178 | ||
179 | Network *network = userdata; | |
8e766630 | 180 | _cleanup_(prefix_freep) Prefix *p = NULL; |
6e849e95 PF |
181 | uint8_t prefixlen = 64; |
182 | union in_addr_union in6addr; | |
183 | int r; | |
184 | ||
185 | assert(filename); | |
186 | assert(section); | |
187 | assert(lvalue); | |
188 | assert(rvalue); | |
189 | assert(data); | |
190 | ||
191 | r = prefix_new_static(network, filename, section_line, &p); | |
192 | if (r < 0) | |
193 | return r; | |
194 | ||
195 | r = in_addr_prefix_from_string(rvalue, AF_INET6, &in6addr, &prefixlen); | |
196 | if (r < 0) { | |
197 | log_syntax(unit, LOG_ERR, filename, line, r, "Prefix is invalid, ignoring assignment: %s", rvalue); | |
198 | return 0; | |
199 | } | |
200 | ||
201 | if (sd_radv_prefix_set_prefix(p->radv_prefix, &in6addr.in6, prefixlen) < 0) | |
202 | return -EADDRNOTAVAIL; | |
203 | ||
204 | log_syntax(unit, LOG_INFO, filename, line, r, "Found prefix %s", rvalue); | |
205 | ||
206 | p = NULL; | |
207 | ||
208 | return 0; | |
209 | } | |
210 | ||
211 | int config_parse_prefix_flags(const char *unit, | |
212 | const char *filename, | |
213 | unsigned line, | |
214 | const char *section, | |
215 | unsigned section_line, | |
216 | const char *lvalue, | |
217 | int ltype, | |
218 | const char *rvalue, | |
219 | void *data, | |
220 | void *userdata) { | |
221 | Network *network = userdata; | |
8e766630 | 222 | _cleanup_(prefix_freep) Prefix *p = NULL; |
6e849e95 PF |
223 | int r, val; |
224 | ||
225 | assert(filename); | |
226 | assert(section); | |
227 | assert(lvalue); | |
228 | assert(rvalue); | |
229 | assert(data); | |
230 | ||
231 | r = prefix_new_static(network, filename, section_line, &p); | |
232 | if (r < 0) | |
233 | return r; | |
234 | ||
235 | r = parse_boolean(rvalue); | |
236 | if (r < 0) { | |
237 | log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse address flag, ignoring: %s", rvalue); | |
238 | return 0; | |
239 | } | |
240 | ||
241 | val = r; | |
242 | ||
243 | if (streq(lvalue, "OnLink")) | |
244 | r = sd_radv_prefix_set_onlink(p->radv_prefix, val); | |
245 | else if (streq(lvalue, "AddressAutoconfiguration")) | |
246 | r = sd_radv_prefix_set_address_autoconfiguration(p->radv_prefix, val); | |
247 | if (r < 0) | |
248 | return r; | |
249 | ||
250 | p = NULL; | |
251 | ||
252 | return 0; | |
253 | } | |
254 | ||
255 | int config_parse_prefix_lifetime(const char *unit, | |
256 | const char *filename, | |
257 | unsigned line, | |
258 | const char *section, | |
259 | unsigned section_line, | |
260 | const char *lvalue, | |
261 | int ltype, | |
262 | const char *rvalue, | |
263 | void *data, | |
264 | void *userdata) { | |
265 | Network *network = userdata; | |
8e766630 | 266 | _cleanup_(prefix_freep) Prefix *p = NULL; |
6e849e95 PF |
267 | usec_t usec; |
268 | int r; | |
269 | ||
270 | assert(filename); | |
271 | assert(section); | |
272 | assert(lvalue); | |
273 | assert(rvalue); | |
274 | assert(data); | |
275 | ||
276 | r = prefix_new_static(network, filename, section_line, &p); | |
277 | if (r < 0) | |
278 | return r; | |
279 | ||
280 | r = parse_sec(rvalue, &usec); | |
281 | if (r < 0) { | |
282 | log_syntax(unit, LOG_ERR, filename, line, r, "Lifetime is invalid, ignoring assignment: %s", rvalue); | |
283 | return 0; | |
284 | } | |
285 | ||
286 | /* a value of 0xffffffff represents infinity */ | |
287 | if (streq(lvalue, "PreferredLifetimeSec")) | |
288 | r = sd_radv_prefix_set_preferred_lifetime(p->radv_prefix, | |
289 | DIV_ROUND_UP(usec, USEC_PER_SEC)); | |
290 | else if (streq(lvalue, "ValidLifetimeSec")) | |
291 | r = sd_radv_prefix_set_valid_lifetime(p->radv_prefix, | |
292 | DIV_ROUND_UP(usec, USEC_PER_SEC)); | |
293 | if (r < 0) | |
294 | return r; | |
295 | ||
296 | p = NULL; | |
297 | ||
298 | return 0; | |
299 | } | |
091214b6 | 300 | |
c555a358 PF |
301 | static int radv_get_ip6dns(Network *network, struct in6_addr **dns, |
302 | size_t *n_dns) { | |
303 | _cleanup_free_ struct in6_addr *addresses = NULL; | |
304 | size_t i, n_addresses = 0, n_allocated = 0; | |
305 | ||
306 | assert(network); | |
307 | assert(dns); | |
308 | assert(n_dns); | |
309 | ||
310 | for (i = 0; i < network->n_dns; i++) { | |
311 | union in_addr_union *addr; | |
312 | ||
313 | if (network->dns[i].family != AF_INET6) | |
314 | continue; | |
315 | ||
316 | addr = &network->dns[i].address; | |
317 | ||
318 | if (in_addr_is_null(AF_INET6, addr) || | |
319 | in_addr_is_link_local(AF_INET6, addr) || | |
320 | in_addr_is_localhost(AF_INET6, addr)) | |
321 | continue; | |
322 | ||
323 | if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1)) | |
324 | return -ENOMEM; | |
325 | ||
326 | addresses[n_addresses++] = addr->in6; | |
327 | } | |
328 | ||
329 | if (addresses) { | |
ae2a15bc | 330 | *dns = TAKE_PTR(addresses); |
c555a358 PF |
331 | |
332 | *n_dns = n_addresses; | |
333 | } | |
334 | ||
335 | return n_addresses; | |
336 | } | |
337 | ||
338 | static int radv_set_dns(Link *link, Link *uplink) { | |
339 | _cleanup_free_ struct in6_addr *dns = NULL; | |
340 | size_t n_dns; | |
341 | usec_t lifetime_usec; | |
342 | int r; | |
343 | ||
344 | if (!link->network->router_emit_dns) | |
345 | return 0; | |
346 | ||
347 | if (link->network->router_dns) { | |
348 | dns = newdup(struct in6_addr, link->network->router_dns, | |
349 | link->network->n_router_dns); | |
350 | if (dns == NULL) | |
351 | return -ENOMEM; | |
352 | ||
353 | n_dns = link->network->n_router_dns; | |
354 | lifetime_usec = link->network->router_dns_lifetime_usec; | |
355 | ||
356 | goto set_dns; | |
357 | } | |
358 | ||
359 | lifetime_usec = SD_RADV_DEFAULT_DNS_LIFETIME_USEC; | |
360 | ||
361 | r = radv_get_ip6dns(link->network, &dns, &n_dns); | |
362 | if (r > 0) | |
363 | goto set_dns; | |
364 | ||
365 | if (uplink) { | |
349a981d PF |
366 | if (uplink->network == NULL) { |
367 | log_link_debug(uplink, "Cannot fetch DNS servers as uplink interface is not managed by us"); | |
368 | return 0; | |
369 | } | |
370 | ||
c555a358 PF |
371 | r = radv_get_ip6dns(uplink->network, &dns, &n_dns); |
372 | if (r > 0) | |
373 | goto set_dns; | |
374 | } | |
375 | ||
376 | return 0; | |
377 | ||
378 | set_dns: | |
379 | return sd_radv_set_rdnss(link->radv, | |
380 | DIV_ROUND_UP(lifetime_usec, USEC_PER_SEC), | |
381 | dns, n_dns); | |
382 | } | |
383 | ||
384 | static int radv_set_domains(Link *link, Link *uplink) { | |
385 | char **search_domains; | |
386 | usec_t lifetime_usec; | |
387 | ||
388 | if (!link->network->router_emit_domains) | |
389 | return 0; | |
390 | ||
391 | search_domains = link->network->router_search_domains; | |
392 | lifetime_usec = link->network->router_dns_lifetime_usec; | |
393 | ||
394 | if (search_domains) | |
395 | goto set_domains; | |
396 | ||
397 | lifetime_usec = SD_RADV_DEFAULT_DNS_LIFETIME_USEC; | |
398 | ||
399 | search_domains = link->network->search_domains; | |
400 | if (search_domains) | |
401 | goto set_domains; | |
402 | ||
403 | if (uplink) { | |
349a981d PF |
404 | if (uplink->network == NULL) { |
405 | log_link_debug(uplink, "Cannot fetch DNS search domains as uplink interface is not managed by us"); | |
406 | return 0; | |
407 | } | |
408 | ||
c555a358 PF |
409 | search_domains = uplink->network->search_domains; |
410 | if (search_domains) | |
411 | goto set_domains; | |
412 | } | |
413 | ||
414 | return 0; | |
415 | ||
416 | set_domains: | |
417 | return sd_radv_set_dnssl(link->radv, | |
418 | DIV_ROUND_UP(lifetime_usec, USEC_PER_SEC), | |
419 | search_domains); | |
420 | ||
421 | } | |
422 | ||
423 | int radv_emit_dns(Link *link) { | |
424 | Link *uplink; | |
425 | int r; | |
426 | ||
427 | uplink = manager_find_uplink(link->manager, link); | |
428 | ||
429 | r = radv_set_dns(link, uplink); | |
430 | if (r < 0) | |
431 | log_link_warning_errno(link, r, "Could not set RA DNS: %m"); | |
432 | ||
433 | r = radv_set_domains(link, uplink); | |
434 | if (r < 0) | |
435 | log_link_warning_errno(link, r, "Could not set RA Domains: %m"); | |
436 | ||
437 | return 0; | |
438 | } | |
439 | ||
091214b6 PF |
440 | int radv_configure(Link *link) { |
441 | int r; | |
442 | Prefix *p; | |
443 | ||
444 | assert(link); | |
445 | assert(link->network); | |
446 | ||
447 | r = sd_radv_new(&link->radv); | |
448 | if (r < 0) | |
449 | return r; | |
450 | ||
451 | r = sd_radv_attach_event(link->radv, NULL, 0); | |
452 | if (r < 0) | |
453 | return r; | |
454 | ||
455 | r = sd_radv_set_mac(link->radv, &link->mac); | |
456 | if (r < 0) | |
457 | return r; | |
458 | ||
459 | r = sd_radv_set_ifindex(link->radv, link->ifindex); | |
460 | if (r < 0) | |
461 | return r; | |
462 | ||
463 | r = sd_radv_set_managed_information(link->radv, link->network->router_managed); | |
464 | if (r < 0) | |
465 | return r; | |
466 | ||
467 | r = sd_radv_set_other_information(link->radv, link->network->router_other_information); | |
468 | if (r < 0) | |
469 | return r; | |
470 | ||
301a2fb9 PF |
471 | /* a value of 0xffffffff represents infinity, 0x0 means this host is |
472 | not a router */ | |
091214b6 | 473 | r = sd_radv_set_router_lifetime(link->radv, |
945e3225 | 474 | DIV_ROUND_UP(link->network->router_lifetime_usec, USEC_PER_SEC)); |
091214b6 PF |
475 | if (r < 0) |
476 | return r; | |
477 | ||
478 | if (link->network->router_lifetime_usec > 0) { | |
479 | r = sd_radv_set_preference(link->radv, | |
480 | link->network->router_preference); | |
481 | if (r < 0) | |
482 | return r; | |
483 | } | |
484 | ||
56a23cb4 PF |
485 | if (IN_SET(link->network->router_prefix_delegation, |
486 | RADV_PREFIX_DELEGATION_STATIC, | |
487 | RADV_PREFIX_DELEGATION_BOTH)) { | |
488 | LIST_FOREACH(prefixes, p, link->network->static_prefixes) { | |
d601b566 | 489 | r = sd_radv_add_prefix(link->radv, p->radv_prefix, false); |
56a23cb4 PF |
490 | if (r != -EEXIST && r < 0) |
491 | return r; | |
492 | } | |
091214b6 PF |
493 | } |
494 | ||
c555a358 | 495 | return radv_emit_dns(link); |
091214b6 | 496 | } |