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