]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/network/networkd-link.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
networkd: add support to configure ip rule port range and protocol.
[thirdparty/systemd.git] / src / network / networkd-link.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <netinet/ether.h>
4 #include <linux/if.h>
5 #include <linux/can/netlink.h>
6 #include <unistd.h>
7 #include <stdio_ext.h>
8
9 #include "alloc-util.h"
10 #include "bus-util.h"
11 #include "dhcp-identifier.h"
12 #include "dhcp-lease-internal.h"
13 #include "fd-util.h"
14 #include "fileio.h"
15 #include "netlink-util.h"
16 #include "network-internal.h"
17 #include "networkd-ipv6-proxy-ndp.h"
18 #include "networkd-lldp-tx.h"
19 #include "networkd-manager.h"
20 #include "networkd-ndisc.h"
21 #include "networkd-radv.h"
22 #include "networkd-routing-policy-rule.h"
23 #include "set.h"
24 #include "socket-util.h"
25 #include "stdio-util.h"
26 #include "string-table.h"
27 #include "strv.h"
28 #include "util.h"
29 #include "virt.h"
30
31 DUID* link_get_duid(Link *link) {
32 if (link->network->duid.type != _DUID_TYPE_INVALID)
33 return &link->network->duid;
34 else
35 return &link->manager->duid;
36 }
37
38 static bool link_dhcp6_enabled(Link *link) {
39 assert(link);
40
41 if (!socket_ipv6_is_supported())
42 return false;
43
44 if (link->flags & IFF_LOOPBACK)
45 return false;
46
47 if (!link->network)
48 return false;
49
50 return link->network->dhcp & ADDRESS_FAMILY_IPV6;
51 }
52
53 static bool link_dhcp4_enabled(Link *link) {
54 assert(link);
55
56 if (link->flags & IFF_LOOPBACK)
57 return false;
58
59 if (!link->network)
60 return false;
61
62 return link->network->dhcp & ADDRESS_FAMILY_IPV4;
63 }
64
65 static bool link_dhcp4_server_enabled(Link *link) {
66 assert(link);
67
68 if (link->flags & IFF_LOOPBACK)
69 return false;
70
71 if (!link->network)
72 return false;
73
74 return link->network->dhcp_server;
75 }
76
77 static bool link_ipv4ll_enabled(Link *link) {
78 assert(link);
79
80 if (link->flags & IFF_LOOPBACK)
81 return false;
82
83 if (!link->network)
84 return false;
85
86 if (streq_ptr(link->kind, "wireguard"))
87 return false;
88
89 return link->network->link_local & ADDRESS_FAMILY_IPV4;
90 }
91
92 static bool link_ipv6ll_enabled(Link *link) {
93 assert(link);
94
95 if (!socket_ipv6_is_supported())
96 return false;
97
98 if (link->flags & IFF_LOOPBACK)
99 return false;
100
101 if (!link->network)
102 return false;
103
104 if (streq_ptr(link->kind, "wireguard"))
105 return false;
106
107 return link->network->link_local & ADDRESS_FAMILY_IPV6;
108 }
109
110 static bool link_ipv6_enabled(Link *link) {
111 assert(link);
112
113 if (!socket_ipv6_is_supported())
114 return false;
115
116 if (link->network->bridge)
117 return false;
118
119 /* DHCPv6 client will not be started if no IPv6 link-local address is configured. */
120 return link_ipv6ll_enabled(link) || network_has_static_ipv6_addresses(link->network);
121 }
122
123 static bool link_radv_enabled(Link *link) {
124 assert(link);
125
126 if (!link_ipv6ll_enabled(link))
127 return false;
128
129 return link->network->router_prefix_delegation != RADV_PREFIX_DELEGATION_NONE;
130 }
131
132 static bool link_lldp_rx_enabled(Link *link) {
133 assert(link);
134
135 if (link->flags & IFF_LOOPBACK)
136 return false;
137
138 if (link->iftype != ARPHRD_ETHER)
139 return false;
140
141 if (!link->network)
142 return false;
143
144 /* LLDP should be handled on bridge slaves as those have a direct
145 * connection to their peers not on the bridge master. Linux doesn't
146 * even (by default) forward lldp packets to the bridge master.*/
147 if (streq_ptr("bridge", link->kind))
148 return false;
149
150 return link->network->lldp_mode != LLDP_MODE_NO;
151 }
152
153 static bool link_lldp_emit_enabled(Link *link) {
154 assert(link);
155
156 if (link->flags & IFF_LOOPBACK)
157 return false;
158
159 if (link->iftype != ARPHRD_ETHER)
160 return false;
161
162 if (!link->network)
163 return false;
164
165 return link->network->lldp_emit != LLDP_EMIT_NO;
166 }
167
168 static bool link_ipv4_forward_enabled(Link *link) {
169 assert(link);
170
171 if (link->flags & IFF_LOOPBACK)
172 return false;
173
174 if (!link->network)
175 return false;
176
177 if (link->network->ip_forward == _ADDRESS_FAMILY_BOOLEAN_INVALID)
178 return false;
179
180 return link->network->ip_forward & ADDRESS_FAMILY_IPV4;
181 }
182
183 static bool link_ipv6_forward_enabled(Link *link) {
184 assert(link);
185
186 if (!socket_ipv6_is_supported())
187 return false;
188
189 if (link->flags & IFF_LOOPBACK)
190 return false;
191
192 if (!link->network)
193 return false;
194
195 if (link->network->ip_forward == _ADDRESS_FAMILY_BOOLEAN_INVALID)
196 return false;
197
198 return link->network->ip_forward & ADDRESS_FAMILY_IPV6;
199 }
200
201 static bool link_proxy_arp_enabled(Link *link) {
202 assert(link);
203
204 if (link->flags & IFF_LOOPBACK)
205 return false;
206
207 if (!link->network)
208 return false;
209
210 if (link->network->proxy_arp < 0)
211 return false;
212
213 return true;
214 }
215
216 static bool link_ipv6_accept_ra_enabled(Link *link) {
217 assert(link);
218
219 if (!socket_ipv6_is_supported())
220 return false;
221
222 if (link->flags & IFF_LOOPBACK)
223 return false;
224
225 if (!link->network)
226 return false;
227
228 if (!link_ipv6ll_enabled(link))
229 return false;
230
231 /* If unset use system default (enabled if local forwarding is disabled.
232 * disabled if local forwarding is enabled).
233 * If set, ignore or enforce RA independent of local forwarding state.
234 */
235 if (link->network->ipv6_accept_ra < 0)
236 /* default to accept RA if ip_forward is disabled and ignore RA if ip_forward is enabled */
237 return !link_ipv6_forward_enabled(link);
238 else if (link->network->ipv6_accept_ra > 0)
239 /* accept RA even if ip_forward is enabled */
240 return true;
241 else
242 /* ignore RA */
243 return false;
244 }
245
246 static IPv6PrivacyExtensions link_ipv6_privacy_extensions(Link *link) {
247 assert(link);
248
249 if (!socket_ipv6_is_supported())
250 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
251
252 if (link->flags & IFF_LOOPBACK)
253 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
254
255 if (!link->network)
256 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
257
258 return link->network->ipv6_privacy_extensions;
259 }
260
261 static int link_enable_ipv6(Link *link) {
262 const char *p = NULL;
263 bool disabled;
264 int r;
265
266 if (link->flags & IFF_LOOPBACK)
267 return 0;
268
269 disabled = !link_ipv6_enabled(link);
270
271 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/disable_ipv6");
272
273 r = write_string_file(p, one_zero(disabled), WRITE_STRING_FILE_VERIFY_ON_FAILURE | WRITE_STRING_FILE_DISABLE_BUFFER);
274 if (r < 0)
275 log_link_warning_errno(link, r, "Cannot %s IPv6 for interface %s: %m",
276 enable_disable(!disabled), link->ifname);
277 else
278 log_link_info(link, "IPv6 successfully %sd", enable_disable(!disabled));
279
280 return 0;
281 }
282
283 void link_update_operstate(Link *link) {
284 LinkOperationalState operstate;
285 assert(link);
286
287 if (link->kernel_operstate == IF_OPER_DORMANT)
288 operstate = LINK_OPERSTATE_DORMANT;
289 else if (link_has_carrier(link)) {
290 Address *address;
291 uint8_t scope = RT_SCOPE_NOWHERE;
292 Iterator i;
293
294 /* if we have carrier, check what addresses we have */
295 SET_FOREACH(address, link->addresses, i) {
296 if (!address_is_ready(address))
297 continue;
298
299 if (address->scope < scope)
300 scope = address->scope;
301 }
302
303 /* for operstate we also take foreign addresses into account */
304 SET_FOREACH(address, link->addresses_foreign, i) {
305 if (!address_is_ready(address))
306 continue;
307
308 if (address->scope < scope)
309 scope = address->scope;
310 }
311
312 if (scope < RT_SCOPE_SITE)
313 /* universally accessible addresses found */
314 operstate = LINK_OPERSTATE_ROUTABLE;
315 else if (scope < RT_SCOPE_HOST)
316 /* only link or site local addresses found */
317 operstate = LINK_OPERSTATE_DEGRADED;
318 else
319 /* no useful addresses found */
320 operstate = LINK_OPERSTATE_CARRIER;
321 } else if (link->flags & IFF_UP)
322 operstate = LINK_OPERSTATE_NO_CARRIER;
323 else
324 operstate = LINK_OPERSTATE_OFF;
325
326 if (link->operstate != operstate) {
327 link->operstate = operstate;
328 link_send_changed(link, "OperationalState", NULL);
329 link_dirty(link);
330 }
331 }
332
333 #define FLAG_STRING(string, flag, old, new) \
334 (((old ^ new) & flag) \
335 ? ((old & flag) ? (" -" string) : (" +" string)) \
336 : "")
337
338 static int link_update_flags(Link *link, sd_netlink_message *m) {
339 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
340 uint8_t operstate;
341 int r;
342
343 assert(link);
344
345 r = sd_rtnl_message_link_get_flags(m, &flags);
346 if (r < 0)
347 return log_link_warning_errno(link, r, "Could not get link flags: %m");
348
349 r = sd_netlink_message_read_u8(m, IFLA_OPERSTATE, &operstate);
350 if (r < 0)
351 /* if we got a message without operstate, take it to mean
352 the state was unchanged */
353 operstate = link->kernel_operstate;
354
355 if ((link->flags == flags) && (link->kernel_operstate == operstate))
356 return 0;
357
358 if (link->flags != flags) {
359 log_link_debug(link, "Flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
360 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
361 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
362 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
363 FLAG_STRING("UP", IFF_UP, link->flags, flags),
364 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
365 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
366 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
367 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
368 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
369 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
370 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
371 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
372 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
373 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
374 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
375 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
376 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
377 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
378 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
379
380 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
381 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
382 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
383 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
384 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
385 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
386 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
387 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
388
389 /* link flags are currently at most 18 bits, let's align to
390 * printing 20 */
391 if (unknown_flags_added)
392 log_link_debug(link,
393 "Unknown link flags gained: %#.5x (ignoring)",
394 unknown_flags_added);
395
396 if (unknown_flags_removed)
397 log_link_debug(link,
398 "Unknown link flags lost: %#.5x (ignoring)",
399 unknown_flags_removed);
400 }
401
402 link->flags = flags;
403 link->kernel_operstate = operstate;
404
405 link_update_operstate(link);
406
407 return 0;
408 }
409
410 DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_unref);
411
412 static int link_new(Manager *manager, sd_netlink_message *message, Link **ret) {
413 _cleanup_(link_unrefp) Link *link = NULL;
414 uint16_t type;
415 const char *ifname, *kind = NULL;
416 int r, ifindex;
417 unsigned short iftype;
418
419 assert(manager);
420 assert(message);
421 assert(ret);
422
423 /* check for link kind */
424 r = sd_netlink_message_enter_container(message, IFLA_LINKINFO);
425 if (r == 0) {
426 (void) sd_netlink_message_read_string(message, IFLA_INFO_KIND, &kind);
427 r = sd_netlink_message_exit_container(message);
428 if (r < 0)
429 return r;
430 }
431
432 r = sd_netlink_message_get_type(message, &type);
433 if (r < 0)
434 return r;
435 else if (type != RTM_NEWLINK)
436 return -EINVAL;
437
438 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
439 if (r < 0)
440 return r;
441 else if (ifindex <= 0)
442 return -EINVAL;
443
444 r = sd_rtnl_message_link_get_type(message, &iftype);
445 if (r < 0)
446 return r;
447
448 r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
449 if (r < 0)
450 return r;
451
452 link = new(Link, 1);
453 if (!link)
454 return -ENOMEM;
455
456 *link = (Link) {
457 .n_ref = 1,
458 .manager = manager,
459 .state = LINK_STATE_PENDING,
460 .rtnl_extended_attrs = true,
461 .ifindex = ifindex,
462 .iftype = iftype,
463 };
464
465 link->ifname = strdup(ifname);
466 if (!link->ifname)
467 return -ENOMEM;
468
469 if (kind) {
470 link->kind = strdup(kind);
471 if (!link->kind)
472 return -ENOMEM;
473 }
474
475 r = sd_netlink_message_read_u32(message, IFLA_MASTER, (uint32_t *)&link->master_ifindex);
476 if (r < 0)
477 log_link_debug_errno(link, r, "New device has no master, continuing without");
478
479 r = sd_netlink_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
480 if (r < 0)
481 log_link_debug_errno(link, r, "MAC address not found for new device, continuing without");
482
483 if (asprintf(&link->state_file, "/run/systemd/netif/links/%d", link->ifindex) < 0)
484 return -ENOMEM;
485
486 if (asprintf(&link->lease_file, "/run/systemd/netif/leases/%d", link->ifindex) < 0)
487 return -ENOMEM;
488
489 if (asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d", link->ifindex) < 0)
490 return -ENOMEM;
491
492 r = hashmap_ensure_allocated(&manager->links, NULL);
493 if (r < 0)
494 return r;
495
496 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
497 if (r < 0)
498 return r;
499
500 r = link_update_flags(link, message);
501 if (r < 0)
502 return r;
503
504 *ret = TAKE_PTR(link);
505
506 return 0;
507 }
508
509 static void link_detach_from_manager(Link *link) {
510 if (!link || !link->manager)
511 return;
512
513 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
514 set_remove(link->manager->links_requesting_uuid, link);
515 link_clean(link);
516
517 link->manager = NULL;
518 }
519
520 static Link *link_free(Link *link) {
521 Address *address;
522 Link *carrier;
523 Route *route;
524 Iterator i;
525
526 assert(link);
527
528 while ((route = set_first(link->routes)))
529 route_free(route);
530
531 while ((route = set_first(link->routes_foreign)))
532 route_free(route);
533
534 link->routes = set_free(link->routes);
535 link->routes_foreign = set_free(link->routes_foreign);
536
537 while ((address = set_first(link->addresses)))
538 address_free(address);
539
540 while ((address = set_first(link->addresses_foreign)))
541 address_free(address);
542
543 link->addresses = set_free(link->addresses);
544 link->addresses_foreign = set_free(link->addresses_foreign);
545
546 while ((address = link->pool_addresses)) {
547 LIST_REMOVE(addresses, link->pool_addresses, address);
548 address_free(address);
549 }
550
551 sd_dhcp_server_unref(link->dhcp_server);
552 sd_dhcp_client_unref(link->dhcp_client);
553 sd_dhcp_lease_unref(link->dhcp_lease);
554
555 link_lldp_emit_stop(link);
556
557 free(link->lease_file);
558
559 sd_lldp_unref(link->lldp);
560 free(link->lldp_file);
561
562 ndisc_flush(link);
563
564 sd_ipv4ll_unref(link->ipv4ll);
565 sd_dhcp6_client_unref(link->dhcp6_client);
566 sd_ndisc_unref(link->ndisc);
567 sd_radv_unref(link->radv);
568
569 link_detach_from_manager(link);
570
571 free(link->ifname);
572
573 free(link->kind);
574
575 (void) unlink(link->state_file);
576 free(link->state_file);
577
578 sd_device_unref(link->sd_device);
579
580 HASHMAP_FOREACH (carrier, link->bound_to_links, i)
581 hashmap_remove(link->bound_to_links, INT_TO_PTR(carrier->ifindex));
582 hashmap_free(link->bound_to_links);
583
584 HASHMAP_FOREACH (carrier, link->bound_by_links, i)
585 hashmap_remove(link->bound_by_links, INT_TO_PTR(carrier->ifindex));
586 hashmap_free(link->bound_by_links);
587
588 return mfree(link);
589 }
590
591 DEFINE_TRIVIAL_REF_UNREF_FUNC(Link, link, link_free);
592
593 void link_netlink_destroy_callback(void *userdata) {
594 Link *link = userdata;
595
596 assert(userdata);
597
598 link_unref(link);
599 }
600
601 int link_get(Manager *m, int ifindex, Link **ret) {
602 Link *link;
603
604 assert(m);
605 assert(ifindex);
606 assert(ret);
607
608 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
609 if (!link)
610 return -ENODEV;
611
612 *ret = link;
613
614 return 0;
615 }
616
617 static void link_set_state(Link *link, LinkState state) {
618 assert(link);
619
620 if (link->state == state)
621 return;
622
623 link->state = state;
624
625 link_send_changed(link, "AdministrativeState", NULL);
626 }
627
628 static void link_enter_unmanaged(Link *link) {
629 assert(link);
630
631 log_link_debug(link, "Unmanaged");
632
633 link_set_state(link, LINK_STATE_UNMANAGED);
634
635 link_dirty(link);
636 }
637
638 static int link_stop_clients(Link *link) {
639 int r = 0, k;
640
641 assert(link);
642 assert(link->manager);
643 assert(link->manager->event);
644
645 if (link->dhcp_client) {
646 k = sd_dhcp_client_stop(link->dhcp_client);
647 if (k < 0)
648 r = log_link_warning_errno(link, k, "Could not stop DHCPv4 client: %m");
649 }
650
651 if (link->ipv4ll) {
652 k = sd_ipv4ll_stop(link->ipv4ll);
653 if (k < 0)
654 r = log_link_warning_errno(link, k, "Could not stop IPv4 link-local: %m");
655 }
656
657 if (link->dhcp6_client) {
658 k = sd_dhcp6_client_stop(link->dhcp6_client);
659 if (k < 0)
660 r = log_link_warning_errno(link, k, "Could not stop DHCPv6 client: %m");
661 }
662
663 if (link->ndisc) {
664 k = sd_ndisc_stop(link->ndisc);
665 if (k < 0)
666 r = log_link_warning_errno(link, k, "Could not stop IPv6 Router Discovery: %m");
667 }
668
669 if (link->radv) {
670 k = sd_radv_stop(link->radv);
671 if (k < 0)
672 r = log_link_warning_errno(link, k, "Could not stop IPv6 Router Advertisement: %m");
673 }
674
675 link_lldp_emit_stop(link);
676 return r;
677 }
678
679 void link_enter_failed(Link *link) {
680 assert(link);
681
682 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
683 return;
684
685 log_link_warning(link, "Failed");
686
687 link_set_state(link, LINK_STATE_FAILED);
688
689 link_stop_clients(link);
690
691 link_dirty(link);
692 }
693
694 static Address* link_find_dhcp_server_address(Link *link) {
695 Address *address;
696
697 assert(link);
698 assert(link->network);
699
700 /* The first statically configured address if there is any */
701 LIST_FOREACH(addresses, address, link->network->static_addresses) {
702
703 if (address->family != AF_INET)
704 continue;
705
706 if (in_addr_is_null(address->family, &address->in_addr))
707 continue;
708
709 return address;
710 }
711
712 /* If that didn't work, find a suitable address we got from the pool */
713 LIST_FOREACH(addresses, address, link->pool_addresses) {
714 if (address->family != AF_INET)
715 continue;
716
717 return address;
718 }
719
720 return NULL;
721 }
722
723 static void link_enter_configured(Link *link) {
724 assert(link);
725 assert(link->network);
726
727 if (link->state != LINK_STATE_SETTING_ROUTES)
728 return;
729
730 log_link_info(link, "Configured");
731
732 link_set_state(link, LINK_STATE_CONFIGURED);
733
734 link_dirty(link);
735 }
736
737 void link_check_ready(Link *link) {
738 Address *a;
739 Iterator i;
740
741 assert(link);
742
743 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
744 return;
745
746 if (!link->network)
747 return;
748
749 if (!link->static_routes_configured)
750 return;
751
752 if (!link->routing_policy_rules_configured)
753 return;
754
755 if (link_ipv4ll_enabled(link))
756 if (!link->ipv4ll_address ||
757 !link->ipv4ll_route)
758 return;
759
760 if (!link->network->bridge) {
761
762 if (link_ipv6ll_enabled(link))
763 if (in_addr_is_null(AF_INET6, (const union in_addr_union*) &link->ipv6ll_address) > 0)
764 return;
765
766 if ((link_dhcp4_enabled(link) && !link_dhcp6_enabled(link) &&
767 !link->dhcp4_configured) ||
768 (link_dhcp6_enabled(link) && !link_dhcp4_enabled(link) &&
769 !link->dhcp6_configured) ||
770 (link_dhcp4_enabled(link) && link_dhcp6_enabled(link) &&
771 !link->dhcp4_configured && !link->dhcp6_configured))
772 return;
773
774 if (link_ipv6_accept_ra_enabled(link) && !link->ndisc_configured)
775 return;
776 }
777
778 SET_FOREACH(a, link->addresses, i)
779 if (!address_is_ready(a))
780 return;
781
782 if (link->state != LINK_STATE_CONFIGURED)
783 link_enter_configured(link);
784
785 return;
786 }
787
788 static int link_set_routing_policy_rule(Link *link) {
789 RoutingPolicyRule *rule, *rrule = NULL;
790 int r;
791
792 assert(link);
793 assert(link->network);
794
795 LIST_FOREACH(rules, rule, link->network->rules) {
796 r = routing_policy_rule_get(link->manager, rule->family, &rule->from, rule->from_prefixlen, &rule->to,
797 rule->to_prefixlen, rule->tos, rule->fwmark, rule->table, rule->iif, rule->oif,
798 rule->protocol, &rule->sport, &rule->dport, &rrule);
799 if (r == 0) {
800 (void) routing_policy_rule_make_local(link->manager, rrule);
801 continue;
802 }
803
804 r = routing_policy_rule_configure(rule, link, link_routing_policy_rule_handler, false);
805 if (r < 0) {
806 log_link_warning_errno(link, r, "Could not set routing policy rules: %m");
807 link_enter_failed(link);
808 return r;
809 }
810
811 link->routing_policy_rule_messages++;
812 }
813
814 routing_policy_rule_purge(link->manager, link);
815 if (link->routing_policy_rule_messages == 0) {
816 link->routing_policy_rules_configured = true;
817 link_check_ready(link);
818 } else
819 log_link_debug(link, "Setting routing policy rules");
820
821 return 0;
822 }
823
824 static int route_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
825 Link *link = userdata;
826 int r;
827
828 assert(link);
829 assert(link->route_messages > 0);
830 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
831 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
832 LINK_STATE_LINGER));
833
834 link->route_messages--;
835
836 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
837 return 1;
838
839 r = sd_netlink_message_get_errno(m);
840 if (r < 0 && r != -EEXIST)
841 log_link_warning_errno(link, r, "Could not set route: %m");
842
843 if (link->route_messages == 0) {
844 log_link_debug(link, "Routes set");
845 link->static_routes_configured = true;
846 link_check_ready(link);
847 }
848
849 return 1;
850 }
851
852 static int link_enter_set_routes(Link *link) {
853 Route *rt;
854 int r;
855
856 assert(link);
857 assert(link->network);
858 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
859
860 (void) link_set_routing_policy_rule(link);
861
862 link_set_state(link, LINK_STATE_SETTING_ROUTES);
863
864 LIST_FOREACH(routes, rt, link->network->static_routes) {
865 r = route_configure(rt, link, route_handler);
866 if (r < 0) {
867 log_link_warning_errno(link, r, "Could not set routes: %m");
868 link_enter_failed(link);
869 return r;
870 }
871
872 link->route_messages++;
873 }
874
875 if (link->route_messages == 0) {
876 link->static_routes_configured = true;
877 link_check_ready(link);
878 } else
879 log_link_debug(link, "Setting routes");
880
881 return 0;
882 }
883
884 int link_route_remove_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
885 Link *link = userdata;
886 int r;
887
888 assert(m);
889 assert(link);
890 assert(link->ifname);
891
892 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
893 return 1;
894
895 r = sd_netlink_message_get_errno(m);
896 if (r < 0 && r != -ESRCH)
897 log_link_warning_errno(link, r, "Could not drop route: %m");
898
899 return 1;
900 }
901
902 static int address_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
903 Link *link = userdata;
904 int r;
905
906 assert(rtnl);
907 assert(m);
908 assert(link);
909 assert(link->ifname);
910 assert(link->address_messages > 0);
911 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
912 LINK_STATE_FAILED, LINK_STATE_LINGER));
913
914 link->address_messages--;
915
916 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
917 return 1;
918
919 r = sd_netlink_message_get_errno(m);
920 if (r < 0 && r != -EEXIST)
921 log_link_warning_errno(link, r, "could not set address: %m");
922 else if (r >= 0)
923 manager_rtnl_process_address(rtnl, m, link->manager);
924
925 if (link->address_messages == 0) {
926 log_link_debug(link, "Addresses set");
927 link_enter_set_routes(link);
928 }
929
930 return 1;
931 }
932
933 static int address_label_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
934 Link *link = userdata;
935 int r;
936
937 assert(rtnl);
938 assert(m);
939 assert(link);
940 assert(link->ifname);
941 assert(link->address_label_messages > 0);
942
943 link->address_label_messages--;
944
945 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
946 return 1;
947
948 r = sd_netlink_message_get_errno(m);
949 if (r < 0 && r != -EEXIST)
950 log_link_warning_errno(link, r, "could not set address label: %m");
951 else if (r >= 0)
952 manager_rtnl_process_address(rtnl, m, link->manager);
953
954 if (link->address_label_messages == 0)
955 log_link_debug(link, "Addresses label set");
956
957 return 1;
958 }
959
960 static int link_push_uplink_dns_to_dhcp_server(Link *link, sd_dhcp_server *s) {
961 _cleanup_free_ struct in_addr *addresses = NULL;
962 size_t n_addresses = 0, n_allocated = 0;
963 unsigned i;
964
965 log_debug("Copying DNS server information from %s", link->ifname);
966
967 if (!link->network)
968 return 0;
969
970 for (i = 0; i < link->network->n_dns; i++) {
971 struct in_addr ia;
972
973 /* Only look for IPv4 addresses */
974 if (link->network->dns[i].family != AF_INET)
975 continue;
976
977 ia = link->network->dns[i].address.in;
978
979 /* Never propagate obviously borked data */
980 if (in4_addr_is_null(&ia) || in4_addr_is_localhost(&ia))
981 continue;
982
983 if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1))
984 return log_oom();
985
986 addresses[n_addresses++] = ia;
987 }
988
989 if (link->network->dhcp_use_dns && link->dhcp_lease) {
990 const struct in_addr *da = NULL;
991 int n;
992
993 n = sd_dhcp_lease_get_dns(link->dhcp_lease, &da);
994 if (n > 0) {
995
996 if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + n))
997 return log_oom();
998
999 memcpy(addresses + n_addresses, da, n * sizeof(struct in_addr));
1000 n_addresses += n;
1001 }
1002 }
1003
1004 if (n_addresses <= 0)
1005 return 0;
1006
1007 return sd_dhcp_server_set_dns(s, addresses, n_addresses);
1008 }
1009
1010 static int link_push_uplink_ntp_to_dhcp_server(Link *link, sd_dhcp_server *s) {
1011 _cleanup_free_ struct in_addr *addresses = NULL;
1012 size_t n_addresses = 0, n_allocated = 0;
1013 char **a;
1014
1015 if (!link->network)
1016 return 0;
1017
1018 log_debug("Copying NTP server information from %s", link->ifname);
1019
1020 STRV_FOREACH(a, link->network->ntp) {
1021 struct in_addr ia;
1022
1023 /* Only look for IPv4 addresses */
1024 if (inet_pton(AF_INET, *a, &ia) <= 0)
1025 continue;
1026
1027 /* Never propagate obviously borked data */
1028 if (in4_addr_is_null(&ia) || in4_addr_is_localhost(&ia))
1029 continue;
1030
1031 if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1))
1032 return log_oom();
1033
1034 addresses[n_addresses++] = ia;
1035 }
1036
1037 if (link->network->dhcp_use_ntp && link->dhcp_lease) {
1038 const struct in_addr *da = NULL;
1039 int n;
1040
1041 n = sd_dhcp_lease_get_ntp(link->dhcp_lease, &da);
1042 if (n > 0) {
1043
1044 if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + n))
1045 return log_oom();
1046
1047 memcpy(addresses + n_addresses, da, n * sizeof(struct in_addr));
1048 n_addresses += n;
1049 }
1050 }
1051
1052 if (n_addresses <= 0)
1053 return 0;
1054
1055 return sd_dhcp_server_set_ntp(s, addresses, n_addresses);
1056 }
1057
1058 static int link_set_bridge_fdb(Link *link) {
1059 FdbEntry *fdb_entry;
1060 int r;
1061
1062 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
1063 r = fdb_entry_configure(link, fdb_entry);
1064 if (r < 0)
1065 return log_link_error_errno(link, r, "Failed to add MAC entry to static MAC table: %m");
1066 }
1067
1068 return 0;
1069 }
1070
1071 static int link_enter_set_addresses(Link *link) {
1072 AddressLabel *label;
1073 Address *ad;
1074 int r;
1075
1076 assert(link);
1077 assert(link->network);
1078 assert(link->state != _LINK_STATE_INVALID);
1079
1080 r = link_set_bridge_fdb(link);
1081 if (r < 0)
1082 return r;
1083
1084 link_set_state(link, LINK_STATE_SETTING_ADDRESSES);
1085
1086 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
1087 r = address_configure(ad, link, address_handler, false);
1088 if (r < 0) {
1089 log_link_warning_errno(link, r, "Could not set addresses: %m");
1090 link_enter_failed(link);
1091 return r;
1092 }
1093
1094 link->address_messages++;
1095 }
1096
1097 LIST_FOREACH(labels, label, link->network->address_labels) {
1098 r = address_label_configure(label, link, address_label_handler, false);
1099 if (r < 0) {
1100 log_link_warning_errno(link, r, "Could not set address label: %m");
1101 link_enter_failed(link);
1102 return r;
1103 }
1104
1105 link->address_label_messages++;
1106 }
1107
1108 /* now that we can figure out a default address for the dhcp server,
1109 start it */
1110 if (link_dhcp4_server_enabled(link) && (link->flags & IFF_UP)) {
1111 Address *address;
1112 Link *uplink = NULL;
1113 bool acquired_uplink = false;
1114
1115 address = link_find_dhcp_server_address(link);
1116 if (!address) {
1117 log_link_warning(link, "Failed to find suitable address for DHCPv4 server instance.");
1118 link_enter_failed(link);
1119 return 0;
1120 }
1121
1122 /* use the server address' subnet as the pool */
1123 r = sd_dhcp_server_configure_pool(link->dhcp_server, &address->in_addr.in, address->prefixlen,
1124 link->network->dhcp_server_pool_offset, link->network->dhcp_server_pool_size);
1125 if (r < 0)
1126 return r;
1127
1128 /* TODO:
1129 r = sd_dhcp_server_set_router(link->dhcp_server,
1130 &main_address->in_addr.in);
1131 if (r < 0)
1132 return r;
1133 */
1134
1135 if (link->network->dhcp_server_max_lease_time_usec > 0) {
1136 r = sd_dhcp_server_set_max_lease_time(
1137 link->dhcp_server,
1138 DIV_ROUND_UP(link->network->dhcp_server_max_lease_time_usec, USEC_PER_SEC));
1139 if (r < 0)
1140 return r;
1141 }
1142
1143 if (link->network->dhcp_server_default_lease_time_usec > 0) {
1144 r = sd_dhcp_server_set_default_lease_time(
1145 link->dhcp_server,
1146 DIV_ROUND_UP(link->network->dhcp_server_default_lease_time_usec, USEC_PER_SEC));
1147 if (r < 0)
1148 return r;
1149 }
1150
1151 if (link->network->dhcp_server_emit_dns) {
1152
1153 if (link->network->n_dhcp_server_dns > 0)
1154 r = sd_dhcp_server_set_dns(link->dhcp_server, link->network->dhcp_server_dns, link->network->n_dhcp_server_dns);
1155 else {
1156 uplink = manager_find_uplink(link->manager, link);
1157 acquired_uplink = true;
1158
1159 if (!uplink) {
1160 log_link_debug(link, "Not emitting DNS server information on link, couldn't find suitable uplink.");
1161 r = 0;
1162 } else
1163 r = link_push_uplink_dns_to_dhcp_server(uplink, link->dhcp_server);
1164 }
1165 if (r < 0)
1166 log_link_warning_errno(link, r, "Failed to set DNS server for DHCP server, ignoring: %m");
1167 }
1168
1169 if (link->network->dhcp_server_emit_ntp) {
1170
1171 if (link->network->n_dhcp_server_ntp > 0)
1172 r = sd_dhcp_server_set_ntp(link->dhcp_server, link->network->dhcp_server_ntp, link->network->n_dhcp_server_ntp);
1173 else {
1174 if (!acquired_uplink)
1175 uplink = manager_find_uplink(link->manager, link);
1176
1177 if (!uplink) {
1178 log_link_debug(link, "Not emitting NTP server information on link, couldn't find suitable uplink.");
1179 r = 0;
1180 } else
1181 r = link_push_uplink_ntp_to_dhcp_server(uplink, link->dhcp_server);
1182
1183 }
1184 if (r < 0)
1185 log_link_warning_errno(link, r, "Failed to set NTP server for DHCP server, ignoring: %m");
1186 }
1187
1188 r = sd_dhcp_server_set_emit_router(link->dhcp_server, link->network->dhcp_server_emit_router);
1189 if (r < 0)
1190 return log_link_warning_errno(link, r, "Failed to set router emission for DHCP server: %m");
1191
1192 if (link->network->dhcp_server_emit_timezone) {
1193 _cleanup_free_ char *buffer = NULL;
1194 const char *tz = NULL;
1195
1196 if (link->network->dhcp_server_timezone)
1197 tz = link->network->dhcp_server_timezone;
1198 else {
1199 r = get_timezone(&buffer);
1200 if (r < 0)
1201 log_warning_errno(r, "Failed to determine timezone: %m");
1202 else
1203 tz = buffer;
1204 }
1205
1206 if (tz) {
1207 r = sd_dhcp_server_set_timezone(link->dhcp_server, tz);
1208 if (r < 0)
1209 return r;
1210 }
1211 }
1212
1213 r = sd_dhcp_server_start(link->dhcp_server);
1214 if (r < 0) {
1215 log_link_warning_errno(link, r, "Could not start DHCPv4 server instance: %m");
1216
1217 link_enter_failed(link);
1218
1219 return 0;
1220 }
1221
1222 log_link_debug(link, "Offering DHCPv4 leases");
1223 }
1224
1225 if (link->address_messages == 0)
1226 link_enter_set_routes(link);
1227 else
1228 log_link_debug(link, "Setting addresses");
1229
1230 return 0;
1231 }
1232
1233 int link_address_remove_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1234 Link *link = userdata;
1235 int r;
1236
1237 assert(m);
1238 assert(link);
1239 assert(link->ifname);
1240
1241 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1242 return 1;
1243
1244 r = sd_netlink_message_get_errno(m);
1245 if (r < 0 && r != -EADDRNOTAVAIL)
1246 log_link_warning_errno(link, r, "Could not drop address: %m");
1247
1248 return 1;
1249 }
1250
1251 static int link_set_bridge_vlan(Link *link) {
1252 int r = 0;
1253
1254 r = br_vlan_configure(link, link->network->pvid, link->network->br_vid_bitmap, link->network->br_untagged_bitmap);
1255 if (r < 0)
1256 log_link_error_errno(link, r, "Failed to assign VLANs to bridge port: %m");
1257
1258 return r;
1259 }
1260
1261 static int link_set_proxy_arp(Link *link) {
1262 const char *p = NULL;
1263 int r;
1264
1265 if (!link_proxy_arp_enabled(link))
1266 return 0;
1267
1268 p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/proxy_arp");
1269
1270 r = write_string_file(p, one_zero(link->network->proxy_arp), WRITE_STRING_FILE_VERIFY_ON_FAILURE | WRITE_STRING_FILE_DISABLE_BUFFER);
1271 if (r < 0)
1272 log_link_warning_errno(link, r, "Cannot configure proxy ARP for interface: %m");
1273
1274 return 0;
1275 }
1276
1277 static int link_set_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1278 Link *link = userdata;
1279 int r;
1280
1281 assert(link);
1282
1283 log_link_debug(link, "Set link");
1284
1285 r = sd_netlink_message_get_errno(m);
1286 if (r < 0 && r != -EEXIST) {
1287 log_link_error_errno(link, r, "Could not join netdev: %m");
1288 link_enter_failed(link);
1289 }
1290
1291 return 1;
1292 }
1293
1294 static int link_configure_after_setting_mtu(Link *link);
1295
1296 static int set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1297 Link *link = userdata;
1298 int r;
1299
1300 assert(m);
1301 assert(link);
1302 assert(link->ifname);
1303
1304 link->setting_mtu = false;
1305
1306 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1307 return 1;
1308
1309 r = sd_netlink_message_get_errno(m);
1310 if (r < 0) {
1311 log_link_warning_errno(link, r, "Could not set MTU: %m");
1312 return 1;
1313 }
1314
1315 log_link_debug(link, "Setting MTU done.");
1316
1317 if (link->state == LINK_STATE_PENDING)
1318 (void) link_configure_after_setting_mtu(link);
1319
1320 return 1;
1321 }
1322
1323 int link_set_mtu(Link *link, uint32_t mtu) {
1324 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1325 int r;
1326
1327 assert(link);
1328 assert(link->manager);
1329 assert(link->manager->rtnl);
1330
1331 if (link->mtu == mtu || link->setting_mtu)
1332 return 0;
1333
1334 log_link_debug(link, "Setting MTU: %" PRIu32, mtu);
1335
1336 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1337 if (r < 0)
1338 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1339
1340 /* If IPv6 not configured (no static IPv6 address and IPv6LL autoconfiguration is disabled)
1341 * for this interface, or if it is a bridge slave, then disable IPv6 else enable it. */
1342 (void) link_enable_ipv6(link);
1343
1344 /* IPv6 protocol requires a minimum MTU of IPV6_MTU_MIN(1280) bytes
1345 * on the interface. Bump up MTU bytes to IPV6_MTU_MIN. */
1346 if (link_ipv6_enabled(link) && mtu < IPV6_MIN_MTU) {
1347
1348 log_link_warning(link, "Bumping MTU to " STRINGIFY(IPV6_MIN_MTU) ", as "
1349 "IPv6 is requested and requires a minimum MTU of " STRINGIFY(IPV6_MIN_MTU) " bytes: %m");
1350
1351 mtu = IPV6_MIN_MTU;
1352 }
1353
1354 r = sd_netlink_message_append_u32(req, IFLA_MTU, mtu);
1355 if (r < 0)
1356 return log_link_error_errno(link, r, "Could not append MTU: %m");
1357
1358 r = sd_netlink_call_async(link->manager->rtnl, NULL, req, set_mtu_handler,
1359 link_netlink_destroy_callback, link, 0, __func__);
1360 if (r < 0)
1361 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1362
1363 link_ref(link);
1364 link->setting_mtu = true;
1365
1366 return 0;
1367 }
1368
1369 static int set_flags_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1370 Link *link = userdata;
1371 int r;
1372
1373 assert(m);
1374 assert(link);
1375 assert(link->ifname);
1376
1377 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1378 return 1;
1379
1380 r = sd_netlink_message_get_errno(m);
1381 if (r < 0)
1382 log_link_warning_errno(link, r, "Could not set link flags: %m");
1383
1384 return 1;
1385 }
1386
1387 static int link_set_flags(Link *link) {
1388 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1389 unsigned ifi_change = 0;
1390 unsigned ifi_flags = 0;
1391 int r;
1392
1393 assert(link);
1394 assert(link->manager);
1395 assert(link->manager->rtnl);
1396
1397 if (link->flags & IFF_LOOPBACK)
1398 return 0;
1399
1400 if (!link->network)
1401 return 0;
1402
1403 if (link->network->arp < 0 && link->network->multicast < 0 && link->network->allmulticast < 0)
1404 return 0;
1405
1406 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1407 if (r < 0)
1408 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1409
1410 if (link->network->arp >= 0) {
1411 ifi_change |= IFF_NOARP;
1412 SET_FLAG(ifi_flags, IFF_NOARP, link->network->arp == 0);
1413 }
1414
1415 if (link->network->multicast >= 0) {
1416 ifi_change |= IFF_MULTICAST;
1417 SET_FLAG(ifi_flags, IFF_MULTICAST, link->network->multicast);
1418 }
1419
1420 if (link->network->allmulticast >= 0) {
1421 ifi_change |= IFF_ALLMULTI;
1422 SET_FLAG(ifi_flags, IFF_ALLMULTI, link->network->allmulticast);
1423 }
1424
1425 r = sd_rtnl_message_link_set_flags(req, ifi_flags, ifi_change);
1426 if (r < 0)
1427 return log_link_error_errno(link, r, "Could not set link flags: %m");
1428
1429 r = sd_netlink_call_async(link->manager->rtnl, NULL, req, set_flags_handler,
1430 link_netlink_destroy_callback, link, 0, __func__);
1431 if (r < 0)
1432 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1433
1434 link_ref(link);
1435
1436 return 0;
1437 }
1438
1439 static int link_set_bridge(Link *link) {
1440 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1441 int r;
1442
1443 assert(link);
1444 assert(link->network);
1445
1446 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1447 if (r < 0)
1448 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1449
1450 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
1451 if (r < 0)
1452 return log_link_error_errno(link, r, "Could not set message family: %m");
1453
1454 r = sd_netlink_message_open_container(req, IFLA_PROTINFO);
1455 if (r < 0)
1456 return log_link_error_errno(link, r, "Could not append IFLA_PROTINFO attribute: %m");
1457
1458 if (link->network->use_bpdu >= 0) {
1459 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_GUARD, link->network->use_bpdu);
1460 if (r < 0)
1461 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_GUARD attribute: %m");
1462 }
1463
1464 if (link->network->hairpin >= 0) {
1465 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MODE, link->network->hairpin);
1466 if (r < 0)
1467 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_MODE attribute: %m");
1468 }
1469
1470 if (link->network->fast_leave >= 0) {
1471 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_FAST_LEAVE, link->network->fast_leave);
1472 if (r < 0)
1473 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_FAST_LEAVE attribute: %m");
1474 }
1475
1476 if (link->network->allow_port_to_be_root >= 0) {
1477 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROTECT, link->network->allow_port_to_be_root);
1478 if (r < 0)
1479 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_PROTECT attribute: %m");
1480
1481 }
1482
1483 if (link->network->unicast_flood >= 0) {
1484 r = sd_netlink_message_append_u8(req, IFLA_BRPORT_UNICAST_FLOOD, link->network->unicast_flood);
1485 if (r < 0)
1486 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_UNICAST_FLOOD attribute: %m");
1487
1488 }
1489
1490 if (link->network->cost != 0) {
1491 r = sd_netlink_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
1492 if (r < 0)
1493 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_COST attribute: %m");
1494 }
1495 if (link->network->priority != LINK_BRIDGE_PORT_PRIORITY_INVALID) {
1496 r = sd_netlink_message_append_u16(req, IFLA_BRPORT_PRIORITY, link->network->priority);
1497 if (r < 0)
1498 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_PRIORITY attribute: %m");
1499 }
1500
1501 r = sd_netlink_message_close_container(req);
1502 if (r < 0)
1503 return log_link_error_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m");
1504
1505 r = sd_netlink_call_async(link->manager->rtnl, NULL, req, link_set_handler,
1506 link_netlink_destroy_callback, link, 0, __func__);
1507 if (r < 0)
1508 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1509
1510 link_ref(link);
1511
1512 return r;
1513 }
1514
1515 static int link_bond_set(Link *link) {
1516 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1517 int r;
1518
1519 assert(link);
1520 assert(link->network);
1521
1522 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_NEWLINK, link->network->bond->ifindex);
1523 if (r < 0)
1524 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1525
1526 r = sd_netlink_message_set_flags(req, NLM_F_REQUEST | NLM_F_ACK);
1527 if (r < 0)
1528 return log_link_error_errno(link, r, "Could not set netlink flags: %m");
1529
1530 r = sd_netlink_message_open_container(req, IFLA_LINKINFO);
1531 if (r < 0)
1532 return log_link_error_errno(link, r, "Could not append IFLA_PROTINFO attribute: %m");
1533
1534 r = sd_netlink_message_open_container_union(req, IFLA_INFO_DATA, "bond");
1535 if (r < 0)
1536 return log_link_error_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m");
1537
1538 if (link->network->active_slave) {
1539 r = sd_netlink_message_append_u32(req, IFLA_BOND_ACTIVE_SLAVE, link->ifindex);
1540 if (r < 0)
1541 return log_link_error_errno(link, r, "Could not append IFLA_BOND_ACTIVE_SLAVE attribute: %m");
1542 }
1543
1544 if (link->network->primary_slave) {
1545 r = sd_netlink_message_append_u32(req, IFLA_BOND_PRIMARY, link->ifindex);
1546 if (r < 0)
1547 return log_link_error_errno(link, r, "Could not append IFLA_BOND_PRIMARY attribute: %m");
1548 }
1549
1550 r = sd_netlink_message_close_container(req);
1551 if (r < 0)
1552 return log_link_error_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m");
1553
1554 r = sd_netlink_message_close_container(req);
1555 if (r < 0)
1556 return log_link_error_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m");
1557
1558 r = sd_netlink_call_async(link->manager->rtnl, NULL, req, set_flags_handler,
1559 link_netlink_destroy_callback, link, 0, __func__);
1560 if (r < 0)
1561 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1562
1563 link_ref(link);
1564
1565 return r;
1566 }
1567
1568 static int link_lldp_save(Link *link) {
1569 _cleanup_free_ char *temp_path = NULL;
1570 _cleanup_fclose_ FILE *f = NULL;
1571 sd_lldp_neighbor **l = NULL;
1572 int n = 0, r, i;
1573
1574 assert(link);
1575 assert(link->lldp_file);
1576
1577 if (!link->lldp) {
1578 (void) unlink(link->lldp_file);
1579 return 0;
1580 }
1581
1582 r = sd_lldp_get_neighbors(link->lldp, &l);
1583 if (r < 0)
1584 goto finish;
1585 if (r == 0) {
1586 (void) unlink(link->lldp_file);
1587 goto finish;
1588 }
1589
1590 n = r;
1591
1592 r = fopen_temporary(link->lldp_file, &f, &temp_path);
1593 if (r < 0)
1594 goto finish;
1595
1596 fchmod(fileno(f), 0644);
1597
1598 for (i = 0; i < n; i++) {
1599 const void *p;
1600 le64_t u;
1601 size_t sz;
1602
1603 r = sd_lldp_neighbor_get_raw(l[i], &p, &sz);
1604 if (r < 0)
1605 goto finish;
1606
1607 u = htole64(sz);
1608 (void) fwrite(&u, 1, sizeof(u), f);
1609 (void) fwrite(p, 1, sz, f);
1610 }
1611
1612 r = fflush_and_check(f);
1613 if (r < 0)
1614 goto finish;
1615
1616 if (rename(temp_path, link->lldp_file) < 0) {
1617 r = -errno;
1618 goto finish;
1619 }
1620
1621 finish:
1622 if (r < 0) {
1623 (void) unlink(link->lldp_file);
1624 if (temp_path)
1625 (void) unlink(temp_path);
1626
1627 log_link_error_errno(link, r, "Failed to save LLDP data to %s: %m", link->lldp_file);
1628 }
1629
1630 if (l) {
1631 for (i = 0; i < n; i++)
1632 sd_lldp_neighbor_unref(l[i]);
1633 free(l);
1634 }
1635
1636 return r;
1637 }
1638
1639 static void lldp_handler(sd_lldp *lldp, sd_lldp_event event, sd_lldp_neighbor *n, void *userdata) {
1640 Link *link = userdata;
1641 int r;
1642
1643 assert(link);
1644
1645 (void) link_lldp_save(link);
1646
1647 if (link_lldp_emit_enabled(link) && event == SD_LLDP_EVENT_ADDED) {
1648 /* If we received information about a new neighbor, restart the LLDP "fast" logic */
1649
1650 log_link_debug(link, "Received LLDP datagram from previously unknown neighbor, restarting 'fast' LLDP transmission.");
1651
1652 r = link_lldp_emit_start(link);
1653 if (r < 0)
1654 log_link_warning_errno(link, r, "Failed to restart LLDP transmission: %m");
1655 }
1656 }
1657
1658 static int link_acquire_ipv6_conf(Link *link) {
1659 int r;
1660
1661 assert(link);
1662
1663 if (link_ipv6_accept_ra_enabled(link)) {
1664 assert(link->ndisc);
1665
1666 log_link_debug(link, "Discovering IPv6 routers");
1667
1668 r = sd_ndisc_start(link->ndisc);
1669 if (r < 0 && r != -EBUSY)
1670 return log_link_warning_errno(link, r, "Could not start IPv6 Router Discovery: %m");
1671 }
1672
1673 if (link_radv_enabled(link)) {
1674 assert(link->radv);
1675 assert(in_addr_is_link_local(AF_INET6, (const union in_addr_union*)&link->ipv6ll_address) > 0);
1676
1677 log_link_debug(link, "Starting IPv6 Router Advertisements");
1678
1679 r = sd_radv_start(link->radv);
1680 if (r < 0 && r != -EBUSY)
1681 return log_link_warning_errno(link, r, "Could not start IPv6 Router Advertisement: %m");
1682 }
1683
1684 (void) dhcp6_request_prefix_delegation(link);
1685
1686 return 0;
1687 }
1688
1689 static int link_acquire_ipv4_conf(Link *link) {
1690 int r;
1691
1692 assert(link);
1693 assert(link->network);
1694 assert(link->manager);
1695 assert(link->manager->event);
1696
1697 if (link_ipv4ll_enabled(link)) {
1698 assert(link->ipv4ll);
1699
1700 log_link_debug(link, "Acquiring IPv4 link-local address");
1701
1702 r = sd_ipv4ll_start(link->ipv4ll);
1703 if (r < 0)
1704 return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
1705 }
1706
1707 if (link_dhcp4_enabled(link)) {
1708 assert(link->dhcp_client);
1709
1710 log_link_debug(link, "Acquiring DHCPv4 lease");
1711
1712 r = sd_dhcp_client_start(link->dhcp_client);
1713 if (r < 0)
1714 return log_link_warning_errno(link, r, "Could not acquire DHCPv4 lease: %m");
1715 }
1716
1717 return 0;
1718 }
1719
1720 static int link_acquire_conf(Link *link) {
1721 int r;
1722
1723 assert(link);
1724
1725 r = link_acquire_ipv4_conf(link);
1726 if (r < 0)
1727 return r;
1728
1729 if (in_addr_is_null(AF_INET6, (const union in_addr_union*) &link->ipv6ll_address) == 0) {
1730 r = link_acquire_ipv6_conf(link);
1731 if (r < 0)
1732 return r;
1733 }
1734
1735 if (link_lldp_emit_enabled(link)) {
1736 r = link_lldp_emit_start(link);
1737 if (r < 0)
1738 return log_link_warning_errno(link, r, "Failed to start LLDP transmission: %m");
1739 }
1740
1741 return 0;
1742 }
1743
1744 bool link_has_carrier(Link *link) {
1745 /* see Documentation/networking/operstates.txt in the kernel sources */
1746
1747 if (link->kernel_operstate == IF_OPER_UP)
1748 return true;
1749
1750 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1751 /* operstate may not be implemented, so fall back to flags */
1752 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1753 return true;
1754
1755 return false;
1756 }
1757
1758 static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1759 Link *link = userdata;
1760 int r;
1761
1762 assert(link);
1763
1764 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1765 return 1;
1766
1767 r = sd_netlink_message_get_errno(m);
1768 if (r < 0)
1769 /* we warn but don't fail the link, as it may be brought up later */
1770 log_link_warning_errno(link, r, "Could not bring up interface: %m");
1771
1772 return 1;
1773 }
1774
1775 int link_up(Link *link) {
1776 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1777 uint8_t ipv6ll_mode;
1778 int r;
1779
1780 assert(link);
1781 assert(link->network);
1782 assert(link->manager);
1783 assert(link->manager->rtnl);
1784
1785 log_link_debug(link, "Bringing link up");
1786
1787 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1788 if (r < 0)
1789 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1790
1791 /* set it free if not enslaved with networkd */
1792 if (!link->network->bridge && !link->network->bond && !link->network->vrf) {
1793 r = sd_netlink_message_append_u32(req, IFLA_MASTER, 0);
1794 if (r < 0)
1795 return log_link_error_errno(link, r, "Could not append IFLA_MASTER attribute: %m");
1796 }
1797
1798 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1799 if (r < 0)
1800 return log_link_error_errno(link, r, "Could not set link flags: %m");
1801
1802 if (link->network->mac) {
1803 r = sd_netlink_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1804 if (r < 0)
1805 return log_link_error_errno(link, r, "Could not set MAC address: %m");
1806 }
1807
1808 r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
1809 if (r < 0)
1810 return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
1811
1812 if (link_ipv6_enabled(link)) {
1813 /* if the kernel lacks ipv6 support setting IFF_UP fails if any ipv6 options are passed */
1814 r = sd_netlink_message_open_container(req, AF_INET6);
1815 if (r < 0)
1816 return log_link_error_errno(link, r, "Could not open AF_INET6 container: %m");
1817
1818 if (!link_ipv6ll_enabled(link))
1819 ipv6ll_mode = IN6_ADDR_GEN_MODE_NONE;
1820 else {
1821 const char *p = NULL;
1822 _cleanup_free_ char *stable_secret = NULL;
1823
1824 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/stable_secret");
1825 r = read_one_line_file(p, &stable_secret);
1826
1827 if (r < 0)
1828 ipv6ll_mode = IN6_ADDR_GEN_MODE_EUI64;
1829 else
1830 ipv6ll_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
1831 }
1832 r = sd_netlink_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
1833 if (r < 0)
1834 return log_link_error_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
1835
1836 if (!in_addr_is_null(AF_INET6, &link->network->ipv6_token)) {
1837 r = sd_netlink_message_append_in6_addr(req, IFLA_INET6_TOKEN, &link->network->ipv6_token.in6);
1838 if (r < 0)
1839 return log_link_error_errno(link, r, "Could not append IFLA_INET6_TOKEN: %m");
1840 }
1841
1842 r = sd_netlink_message_close_container(req);
1843 if (r < 0)
1844 return log_link_error_errno(link, r, "Could not close AF_INET6 container: %m");
1845 }
1846
1847 r = sd_netlink_message_close_container(req);
1848 if (r < 0)
1849 return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
1850
1851 r = sd_netlink_call_async(link->manager->rtnl, NULL, req, link_up_handler,
1852 link_netlink_destroy_callback, link, 0, __func__);
1853 if (r < 0)
1854 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1855
1856 link_ref(link);
1857
1858 return 0;
1859 }
1860
1861 static int link_up_can(Link *link) {
1862 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1863 int r;
1864
1865 assert(link);
1866
1867 log_link_debug(link, "Bringing CAN link up");
1868
1869 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1870 if (r < 0)
1871 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1872
1873 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1874 if (r < 0)
1875 return log_link_error_errno(link, r, "Could not set link flags: %m");
1876
1877 r = sd_netlink_call_async(link->manager->rtnl, NULL, req, link_up_handler,
1878 link_netlink_destroy_callback, link, 0, __func__);
1879 if (r < 0)
1880 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1881
1882 link_ref(link);
1883
1884 return 0;
1885 }
1886
1887 static int link_set_can(Link *link) {
1888 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
1889 int r;
1890
1891 assert(link);
1892 assert(link->network);
1893 assert(link->manager);
1894 assert(link->manager->rtnl);
1895
1896 log_link_debug(link, "link_set_can");
1897
1898 r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_NEWLINK, link->ifindex);
1899 if (r < 0)
1900 return log_link_error_errno(link, r, "Failed to allocate netlink message: %m");
1901
1902 r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK);
1903 if (r < 0)
1904 return log_link_error_errno(link, r, "Could not set netlink flags: %m");
1905
1906 r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
1907 if (r < 0)
1908 return log_link_error_errno(link, r, "Failed to open netlink container: %m");
1909
1910 r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
1911 if (r < 0)
1912 return log_link_error_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m");
1913
1914 if (link->network->can_bitrate > 0 || link->network->can_sample_point > 0) {
1915 struct can_bittiming bt = {
1916 .bitrate = link->network->can_bitrate,
1917 .sample_point = link->network->can_sample_point,
1918 };
1919
1920 if (link->network->can_bitrate > UINT32_MAX) {
1921 log_link_error(link, "bitrate (%zu) too big.", link->network->can_bitrate);
1922 return -ERANGE;
1923 }
1924
1925 log_link_debug(link, "Setting bitrate = %d bit/s", bt.bitrate);
1926 if (link->network->can_sample_point > 0)
1927 log_link_debug(link, "Setting sample point = %d.%d%%", bt.sample_point / 10, bt.sample_point % 10);
1928 else
1929 log_link_debug(link, "Using default sample point");
1930
1931 r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
1932 if (r < 0)
1933 return log_link_error_errno(link, r, "Could not append IFLA_CAN_BITTIMING attribute: %m");
1934 }
1935
1936 if (link->network->can_restart_us > 0) {
1937 char time_string[FORMAT_TIMESPAN_MAX];
1938 uint64_t restart_ms;
1939
1940 if (link->network->can_restart_us == USEC_INFINITY)
1941 restart_ms = 0;
1942 else
1943 restart_ms = DIV_ROUND_UP(link->network->can_restart_us, USEC_PER_MSEC);
1944
1945 format_timespan(time_string, FORMAT_TIMESPAN_MAX, restart_ms * 1000, MSEC_PER_SEC);
1946
1947 if (restart_ms > UINT32_MAX) {
1948 log_link_error(link, "restart timeout (%s) too big.", time_string);
1949 return -ERANGE;
1950 }
1951
1952 log_link_debug(link, "Setting restart = %s", time_string);
1953
1954 r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms);
1955 if (r < 0)
1956 return log_link_error_errno(link, r, "Could not append IFLA_CAN_RESTART_MS attribute: %m");
1957 }
1958
1959 r = sd_netlink_message_close_container(m);
1960 if (r < 0)
1961 return log_link_error_errno(link, r, "Failed to close netlink container: %m");
1962
1963 r = sd_netlink_message_close_container(m);
1964 if (r < 0)
1965 return log_link_error_errno(link, r, "Failed to close netlink container: %m");
1966
1967 r = sd_netlink_call_async(link->manager->rtnl, NULL, m, link_set_handler,
1968 link_netlink_destroy_callback, link, 0, __func__);
1969 if (r < 0)
1970 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1971
1972 link_ref(link);
1973
1974 if (!(link->flags & IFF_UP)) {
1975 r = link_up_can(link);
1976 if (r < 0) {
1977 link_enter_failed(link);
1978 return r;
1979 }
1980 }
1981
1982 log_link_debug(link, "link_set_can done");
1983
1984 return r;
1985 }
1986
1987 static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1988 Link *link = userdata;
1989 int r;
1990
1991 assert(link);
1992
1993 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1994 return 1;
1995
1996 r = sd_netlink_message_get_errno(m);
1997 if (r < 0)
1998 log_link_warning_errno(link, r, "Could not bring down interface: %m");
1999
2000 if (streq_ptr(link->kind, "can"))
2001 link_set_can(link);
2002
2003 return 1;
2004 }
2005
2006 int link_down(Link *link) {
2007 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
2008 int r;
2009
2010 assert(link);
2011 assert(link->manager);
2012 assert(link->manager->rtnl);
2013
2014 log_link_debug(link, "Bringing link down");
2015
2016 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
2017 RTM_SETLINK, link->ifindex);
2018 if (r < 0)
2019 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
2020
2021 r = sd_rtnl_message_link_set_flags(req, 0, IFF_UP);
2022 if (r < 0)
2023 return log_link_error_errno(link, r, "Could not set link flags: %m");
2024
2025 r = sd_netlink_call_async(link->manager->rtnl, NULL, req, link_down_handler,
2026 link_netlink_destroy_callback, link, 0, __func__);
2027 if (r < 0)
2028 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
2029
2030 link_ref(link);
2031
2032 return 0;
2033 }
2034
2035 static int link_handle_bound_to_list(Link *link) {
2036 Link *l;
2037 Iterator i;
2038 int r;
2039 bool required_up = false;
2040 bool link_is_up = false;
2041
2042 assert(link);
2043
2044 if (hashmap_isempty(link->bound_to_links))
2045 return 0;
2046
2047 if (link->flags & IFF_UP)
2048 link_is_up = true;
2049
2050 HASHMAP_FOREACH (l, link->bound_to_links, i)
2051 if (link_has_carrier(l)) {
2052 required_up = true;
2053 break;
2054 }
2055
2056 if (!required_up && link_is_up) {
2057 r = link_down(link);
2058 if (r < 0)
2059 return r;
2060 } else if (required_up && !link_is_up) {
2061 r = link_up(link);
2062 if (r < 0)
2063 return r;
2064 }
2065
2066 return 0;
2067 }
2068
2069 static int link_handle_bound_by_list(Link *link) {
2070 Iterator i;
2071 Link *l;
2072 int r;
2073
2074 assert(link);
2075
2076 if (hashmap_isempty(link->bound_by_links))
2077 return 0;
2078
2079 HASHMAP_FOREACH (l, link->bound_by_links, i) {
2080 r = link_handle_bound_to_list(l);
2081 if (r < 0)
2082 return r;
2083 }
2084
2085 return 0;
2086 }
2087
2088 static int link_put_carrier(Link *link, Link *carrier, Hashmap **h) {
2089 int r;
2090
2091 assert(link);
2092 assert(carrier);
2093
2094 if (link == carrier)
2095 return 0;
2096
2097 if (hashmap_get(*h, INT_TO_PTR(carrier->ifindex)))
2098 return 0;
2099
2100 r = hashmap_ensure_allocated(h, NULL);
2101 if (r < 0)
2102 return r;
2103
2104 r = hashmap_put(*h, INT_TO_PTR(carrier->ifindex), carrier);
2105 if (r < 0)
2106 return r;
2107
2108 return 0;
2109 }
2110
2111 static int link_new_bound_by_list(Link *link) {
2112 Manager *m;
2113 Link *carrier;
2114 Iterator i;
2115 int r;
2116 bool list_updated = false;
2117
2118 assert(link);
2119 assert(link->manager);
2120
2121 m = link->manager;
2122
2123 HASHMAP_FOREACH(carrier, m->links, i) {
2124 if (!carrier->network)
2125 continue;
2126
2127 if (strv_isempty(carrier->network->bind_carrier))
2128 continue;
2129
2130 if (strv_fnmatch(carrier->network->bind_carrier, link->ifname, 0)) {
2131 r = link_put_carrier(link, carrier, &link->bound_by_links);
2132 if (r < 0)
2133 return r;
2134
2135 list_updated = true;
2136 }
2137 }
2138
2139 if (list_updated)
2140 link_dirty(link);
2141
2142 HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
2143 r = link_put_carrier(carrier, link, &carrier->bound_to_links);
2144 if (r < 0)
2145 return r;
2146
2147 link_dirty(carrier);
2148 }
2149
2150 return 0;
2151 }
2152
2153 static int link_new_bound_to_list(Link *link) {
2154 Manager *m;
2155 Link *carrier;
2156 Iterator i;
2157 int r;
2158 bool list_updated = false;
2159
2160 assert(link);
2161 assert(link->manager);
2162
2163 if (!link->network)
2164 return 0;
2165
2166 if (strv_isempty(link->network->bind_carrier))
2167 return 0;
2168
2169 m = link->manager;
2170
2171 HASHMAP_FOREACH (carrier, m->links, i) {
2172 if (strv_fnmatch(link->network->bind_carrier, carrier->ifname, 0)) {
2173 r = link_put_carrier(link, carrier, &link->bound_to_links);
2174 if (r < 0)
2175 return r;
2176
2177 list_updated = true;
2178 }
2179 }
2180
2181 if (list_updated)
2182 link_dirty(link);
2183
2184 HASHMAP_FOREACH (carrier, link->bound_to_links, i) {
2185 r = link_put_carrier(carrier, link, &carrier->bound_by_links);
2186 if (r < 0)
2187 return r;
2188
2189 link_dirty(carrier);
2190 }
2191
2192 return 0;
2193 }
2194
2195 static int link_new_carrier_maps(Link *link) {
2196 int r;
2197
2198 r = link_new_bound_by_list(link);
2199 if (r < 0)
2200 return r;
2201
2202 r = link_handle_bound_by_list(link);
2203 if (r < 0)
2204 return r;
2205
2206 r = link_new_bound_to_list(link);
2207 if (r < 0)
2208 return r;
2209
2210 r = link_handle_bound_to_list(link);
2211 if (r < 0)
2212 return r;
2213
2214 return 0;
2215 }
2216
2217 static void link_free_bound_to_list(Link *link) {
2218 Link *bound_to;
2219 Iterator i;
2220
2221 HASHMAP_FOREACH (bound_to, link->bound_to_links, i) {
2222 hashmap_remove(link->bound_to_links, INT_TO_PTR(bound_to->ifindex));
2223
2224 if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
2225 link_dirty(bound_to);
2226 }
2227
2228 return;
2229 }
2230
2231 static void link_free_bound_by_list(Link *link) {
2232 Link *bound_by;
2233 Iterator i;
2234
2235 HASHMAP_FOREACH (bound_by, link->bound_by_links, i) {
2236 hashmap_remove(link->bound_by_links, INT_TO_PTR(bound_by->ifindex));
2237
2238 if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
2239 link_dirty(bound_by);
2240 link_handle_bound_to_list(bound_by);
2241 }
2242 }
2243
2244 return;
2245 }
2246
2247 static void link_free_carrier_maps(Link *link) {
2248 bool list_updated = false;
2249
2250 assert(link);
2251
2252 if (!hashmap_isempty(link->bound_to_links)) {
2253 link_free_bound_to_list(link);
2254 list_updated = true;
2255 }
2256
2257 if (!hashmap_isempty(link->bound_by_links)) {
2258 link_free_bound_by_list(link);
2259 list_updated = true;
2260 }
2261
2262 if (list_updated)
2263 link_dirty(link);
2264
2265 return;
2266 }
2267
2268 void link_drop(Link *link) {
2269 if (!link || link->state == LINK_STATE_LINGER)
2270 return;
2271
2272 link_set_state(link, LINK_STATE_LINGER);
2273
2274 link_free_carrier_maps(link);
2275
2276 log_link_debug(link, "Link removed");
2277
2278 (void) unlink(link->state_file);
2279
2280 link_detach_from_manager(link);
2281
2282 link_unref(link);
2283
2284 return;
2285 }
2286
2287 static int link_joined(Link *link) {
2288 int r;
2289
2290 assert(link);
2291 assert(link->network);
2292
2293 if (!hashmap_isempty(link->bound_to_links)) {
2294 r = link_handle_bound_to_list(link);
2295 if (r < 0)
2296 return r;
2297 } else if (!(link->flags & IFF_UP)) {
2298 r = link_up(link);
2299 if (r < 0) {
2300 link_enter_failed(link);
2301 return r;
2302 }
2303 }
2304
2305 if (link->network->bridge) {
2306 r = link_set_bridge(link);
2307 if (r < 0)
2308 log_link_error_errno(link, r, "Could not set bridge message: %m");
2309 }
2310
2311 if (link->network->bond) {
2312 r = link_bond_set(link);
2313 if (r < 0)
2314 log_link_error_errno(link, r, "Could not set bond message: %m");
2315 }
2316
2317 if (link->network->use_br_vlan &&
2318 (link->network->bridge || streq_ptr("bridge", link->kind))) {
2319 r = link_set_bridge_vlan(link);
2320 if (r < 0)
2321 log_link_error_errno(link, r, "Could not set bridge vlan: %m");
2322 }
2323
2324 /* Skip setting up addresses until it gets carrier,
2325 or it would try to set addresses twice,
2326 which is bad for non-idempotent steps. */
2327 if (!link_has_carrier(link) && !link->network->configure_without_carrier)
2328 return 0;
2329
2330 return link_enter_set_addresses(link);
2331 }
2332
2333 static int netdev_join_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
2334 Link *link = userdata;
2335 int r;
2336
2337 assert(link);
2338 assert(link->network);
2339
2340 link->enslaving--;
2341
2342 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
2343 return 1;
2344
2345 r = sd_netlink_message_get_errno(m);
2346 if (r < 0 && r != -EEXIST) {
2347 log_link_error_errno(link, r, "Could not join netdev: %m");
2348 link_enter_failed(link);
2349 return 1;
2350 } else
2351 log_link_debug(link, "Joined netdev");
2352
2353 if (link->enslaving <= 0)
2354 link_joined(link);
2355
2356 return 1;
2357 }
2358
2359 static int link_enter_join_netdev(Link *link) {
2360 NetDev *netdev;
2361 Iterator i;
2362 int r;
2363
2364 assert(link);
2365 assert(link->network);
2366 assert(link->state == LINK_STATE_PENDING);
2367
2368 link_set_state(link, LINK_STATE_ENSLAVING);
2369
2370 link_dirty(link);
2371
2372 if (!link->network->bridge &&
2373 !link->network->bond &&
2374 !link->network->vrf &&
2375 hashmap_isempty(link->network->stacked_netdevs))
2376 return link_joined(link);
2377
2378 if (link->network->bond) {
2379 if (link->network->bond->state == NETDEV_STATE_READY &&
2380 link->network->bond->ifindex == link->master_ifindex)
2381 return link_joined(link);
2382
2383 log_struct(LOG_DEBUG,
2384 LOG_LINK_INTERFACE(link),
2385 LOG_NETDEV_INTERFACE(link->network->bond),
2386 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bond->ifname));
2387
2388 r = netdev_join(link->network->bond, link, netdev_join_handler);
2389 if (r < 0) {
2390 log_struct_errno(LOG_WARNING, r,
2391 LOG_LINK_INTERFACE(link),
2392 LOG_NETDEV_INTERFACE(link->network->bond),
2393 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bond->ifname));
2394 link_enter_failed(link);
2395 return r;
2396 }
2397
2398 link->enslaving++;
2399 }
2400
2401 if (link->network->bridge) {
2402 log_struct(LOG_DEBUG,
2403 LOG_LINK_INTERFACE(link),
2404 LOG_NETDEV_INTERFACE(link->network->bridge),
2405 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bridge->ifname));
2406
2407 r = netdev_join(link->network->bridge, link, netdev_join_handler);
2408 if (r < 0) {
2409 log_struct_errno(LOG_WARNING, r,
2410 LOG_LINK_INTERFACE(link),
2411 LOG_NETDEV_INTERFACE(link->network->bridge),
2412 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bridge->ifname));
2413 link_enter_failed(link);
2414 return r;
2415 }
2416
2417 link->enslaving++;
2418 }
2419
2420 if (link->network->vrf) {
2421 log_struct(LOG_DEBUG,
2422 LOG_LINK_INTERFACE(link),
2423 LOG_NETDEV_INTERFACE(link->network->vrf),
2424 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->vrf->ifname));
2425
2426 r = netdev_join(link->network->vrf, link, netdev_join_handler);
2427 if (r < 0) {
2428 log_struct_errno(LOG_WARNING, r,
2429 LOG_LINK_INTERFACE(link),
2430 LOG_NETDEV_INTERFACE(link->network->vrf),
2431 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->vrf->ifname));
2432 link_enter_failed(link);
2433 return r;
2434 }
2435
2436 link->enslaving++;
2437 }
2438
2439 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
2440
2441 if (netdev->ifindex > 0) {
2442 link_joined(link);
2443 continue;
2444 }
2445
2446 log_struct(LOG_DEBUG,
2447 LOG_LINK_INTERFACE(link),
2448 LOG_NETDEV_INTERFACE(netdev),
2449 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname));
2450
2451 r = netdev_join(netdev, link, netdev_join_handler);
2452 if (r < 0) {
2453 log_struct_errno(LOG_WARNING, r,
2454 LOG_LINK_INTERFACE(link),
2455 LOG_NETDEV_INTERFACE(netdev),
2456 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname));
2457 link_enter_failed(link);
2458 return r;
2459 }
2460
2461 link->enslaving++;
2462 }
2463
2464 return 0;
2465 }
2466
2467 static int link_set_ipv4_forward(Link *link) {
2468 int r;
2469
2470 if (!link_ipv4_forward_enabled(link))
2471 return 0;
2472
2473 /* We propagate the forwarding flag from one interface to the
2474 * global setting one way. This means: as long as at least one
2475 * interface was configured at any time that had IP forwarding
2476 * enabled the setting will stay on for good. We do this
2477 * primarily to keep IPv4 and IPv6 packet forwarding behaviour
2478 * somewhat in sync (see below). */
2479
2480 r = write_string_file("/proc/sys/net/ipv4/ip_forward", "1", WRITE_STRING_FILE_VERIFY_ON_FAILURE | WRITE_STRING_FILE_DISABLE_BUFFER);
2481 if (r < 0)
2482 log_link_warning_errno(link, r, "Cannot turn on IPv4 packet forwarding, ignoring: %m");
2483
2484 return 0;
2485 }
2486
2487 static int link_set_ipv6_forward(Link *link) {
2488 int r;
2489
2490 if (!link_ipv6_forward_enabled(link))
2491 return 0;
2492
2493 /* On Linux, the IPv6 stack does not know a per-interface
2494 * packet forwarding setting: either packet forwarding is on
2495 * for all, or off for all. We hence don't bother with a
2496 * per-interface setting, but simply propagate the interface
2497 * flag, if it is set, to the global flag, one-way. Note that
2498 * while IPv4 would allow a per-interface flag, we expose the
2499 * same behaviour there and also propagate the setting from
2500 * one to all, to keep things simple (see above). */
2501
2502 r = write_string_file("/proc/sys/net/ipv6/conf/all/forwarding", "1", WRITE_STRING_FILE_VERIFY_ON_FAILURE | WRITE_STRING_FILE_DISABLE_BUFFER);
2503 if (r < 0)
2504 log_link_warning_errno(link, r, "Cannot configure IPv6 packet forwarding, ignoring: %m");
2505
2506 return 0;
2507 }
2508
2509 static int link_set_ipv6_privacy_extensions(Link *link) {
2510 char buf[DECIMAL_STR_MAX(unsigned) + 1];
2511 IPv6PrivacyExtensions s;
2512 const char *p = NULL;
2513 int r;
2514
2515 s = link_ipv6_privacy_extensions(link);
2516 if (s < 0)
2517 return 0;
2518
2519 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/use_tempaddr");
2520 xsprintf(buf, "%u", (unsigned) link->network->ipv6_privacy_extensions);
2521
2522 r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE | WRITE_STRING_FILE_DISABLE_BUFFER);
2523 if (r < 0)
2524 log_link_warning_errno(link, r, "Cannot configure IPv6 privacy extension for interface: %m");
2525
2526 return 0;
2527 }
2528
2529 static int link_set_ipv6_accept_ra(Link *link) {
2530 const char *p = NULL;
2531 int r;
2532
2533 /* Make this a NOP if IPv6 is not available */
2534 if (!socket_ipv6_is_supported())
2535 return 0;
2536
2537 if (link->flags & IFF_LOOPBACK)
2538 return 0;
2539
2540 if (!link->network)
2541 return 0;
2542
2543 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/accept_ra");
2544
2545 /* We handle router advertisements ourselves, tell the kernel to GTFO */
2546 r = write_string_file(p, "0", WRITE_STRING_FILE_VERIFY_ON_FAILURE | WRITE_STRING_FILE_DISABLE_BUFFER);
2547 if (r < 0)
2548 log_link_warning_errno(link, r, "Cannot disable kernel IPv6 accept_ra for interface: %m");
2549
2550 return 0;
2551 }
2552
2553 static int link_set_ipv6_dad_transmits(Link *link) {
2554 char buf[DECIMAL_STR_MAX(int) + 1];
2555 const char *p = NULL;
2556 int r;
2557
2558 /* Make this a NOP if IPv6 is not available */
2559 if (!socket_ipv6_is_supported())
2560 return 0;
2561
2562 if (link->flags & IFF_LOOPBACK)
2563 return 0;
2564
2565 if (!link->network)
2566 return 0;
2567
2568 if (link->network->ipv6_dad_transmits < 0)
2569 return 0;
2570
2571 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/dad_transmits");
2572 xsprintf(buf, "%i", link->network->ipv6_dad_transmits);
2573
2574 r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE | WRITE_STRING_FILE_DISABLE_BUFFER);
2575 if (r < 0)
2576 log_link_warning_errno(link, r, "Cannot set IPv6 dad transmits for interface: %m");
2577
2578 return 0;
2579 }
2580
2581 static int link_set_ipv6_hop_limit(Link *link) {
2582 char buf[DECIMAL_STR_MAX(int) + 1];
2583 const char *p = NULL;
2584 int r;
2585
2586 /* Make this a NOP if IPv6 is not available */
2587 if (!socket_ipv6_is_supported())
2588 return 0;
2589
2590 if (link->flags & IFF_LOOPBACK)
2591 return 0;
2592
2593 if (!link->network)
2594 return 0;
2595
2596 if (link->network->ipv6_hop_limit < 0)
2597 return 0;
2598
2599 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/hop_limit");
2600 xsprintf(buf, "%i", link->network->ipv6_hop_limit);
2601
2602 r = write_string_file(p, buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE | WRITE_STRING_FILE_DISABLE_BUFFER);
2603 if (r < 0)
2604 log_link_warning_errno(link, r, "Cannot set IPv6 hop limit for interface: %m");
2605
2606 return 0;
2607 }
2608
2609 static int link_set_ipv6_mtu(Link *link) {
2610 char buf[DECIMAL_STR_MAX(unsigned) + 1];
2611 const char *p = NULL;
2612 int r;
2613
2614 /* Make this a NOP if IPv6 is not available */
2615 if (!socket_ipv6_is_supported())
2616 return 0;
2617
2618 if (link->flags & IFF_LOOPBACK)
2619 return 0;
2620
2621 if (link->network->ipv6_mtu == 0)
2622 return 0;
2623
2624 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/mtu");
2625
2626 xsprintf(buf, "%" PRIu32, link->network->ipv6_mtu);
2627
2628 r = write_string_file(p, buf, WRITE_STRING_FILE_DISABLE_BUFFER);
2629 if (r < 0)
2630 log_link_warning_errno(link, r, "Cannot set IPv6 MTU for interface: %m");
2631
2632 return 0;
2633 }
2634
2635 static bool link_is_static_address_configured(Link *link, Address *address) {
2636 Address *net_address;
2637
2638 assert(link);
2639 assert(address);
2640
2641 if (!link->network)
2642 return false;
2643
2644 LIST_FOREACH(addresses, net_address, link->network->static_addresses)
2645 if (address_equal(net_address, address))
2646 return true;
2647
2648 return false;
2649 }
2650
2651 static bool link_is_static_route_configured(Link *link, Route *route) {
2652 Route *net_route;
2653
2654 assert(link);
2655 assert(route);
2656
2657 if (!link->network)
2658 return false;
2659
2660 LIST_FOREACH(routes, net_route, link->network->static_routes)
2661 if (route_equal(net_route, route))
2662 return true;
2663
2664 return false;
2665 }
2666
2667 static int link_drop_foreign_config(Link *link) {
2668 Address *address;
2669 Route *route;
2670 Iterator i;
2671 int r;
2672
2673 SET_FOREACH(address, link->addresses_foreign, i) {
2674 /* we consider IPv6LL addresses to be managed by the kernel */
2675 if (address->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &address->in_addr) == 1)
2676 continue;
2677
2678 if (link_is_static_address_configured(link, address)) {
2679 r = address_add(link, address->family, &address->in_addr, address->prefixlen, NULL);
2680 if (r < 0)
2681 return log_link_error_errno(link, r, "Failed to add address: %m");
2682 } else {
2683 r = address_remove(address, link, link_address_remove_handler);
2684 if (r < 0)
2685 return r;
2686 }
2687 }
2688
2689 SET_FOREACH(route, link->routes_foreign, i) {
2690 /* do not touch routes managed by the kernel */
2691 if (route->protocol == RTPROT_KERNEL)
2692 continue;
2693
2694 if (link_is_static_route_configured(link, route)) {
2695 r = route_add(link, route->family, &route->dst, route->dst_prefixlen, route->tos, route->priority, route->table, NULL);
2696 if (r < 0)
2697 return r;
2698 } else {
2699 r = route_remove(route, link, link_route_remove_handler);
2700 if (r < 0)
2701 return r;
2702 }
2703 }
2704
2705 return 0;
2706 }
2707
2708 static int link_drop_config(Link *link) {
2709 Address *address, *pool_address;
2710 Route *route;
2711 Iterator i;
2712 int r;
2713
2714 SET_FOREACH(address, link->addresses, i) {
2715 /* we consider IPv6LL addresses to be managed by the kernel */
2716 if (address->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &address->in_addr) == 1)
2717 continue;
2718
2719 r = address_remove(address, link, link_address_remove_handler);
2720 if (r < 0)
2721 return r;
2722
2723 /* If this address came from an address pool, clean up the pool */
2724 LIST_FOREACH(addresses, pool_address, link->pool_addresses) {
2725 if (address_equal(address, pool_address)) {
2726 LIST_REMOVE(addresses, link->pool_addresses, pool_address);
2727 address_free(pool_address);
2728 break;
2729 }
2730 }
2731 }
2732
2733 SET_FOREACH(route, link->routes, i) {
2734 /* do not touch routes managed by the kernel */
2735 if (route->protocol == RTPROT_KERNEL)
2736 continue;
2737
2738 r = route_remove(route, link, link_route_remove_handler);
2739 if (r < 0)
2740 return r;
2741 }
2742
2743 ndisc_flush(link);
2744
2745 return 0;
2746 }
2747
2748 static int link_update_lldp(Link *link) {
2749 int r;
2750
2751 assert(link);
2752
2753 if (!link->lldp)
2754 return 0;
2755
2756 if (link->flags & IFF_UP) {
2757 r = sd_lldp_start(link->lldp);
2758 if (r > 0)
2759 log_link_debug(link, "Started LLDP.");
2760 } else {
2761 r = sd_lldp_stop(link->lldp);
2762 if (r > 0)
2763 log_link_debug(link, "Stopped LLDP.");
2764 }
2765
2766 return r;
2767 }
2768
2769 static int link_configure_can(Link *link) {
2770 int r;
2771
2772 if (streq_ptr(link->kind, "can")) {
2773 /* The CAN interface must be down to configure bitrate, etc... */
2774 if ((link->flags & IFF_UP)) {
2775 r = link_down(link);
2776 if (r < 0) {
2777 link_enter_failed(link);
2778 return r;
2779 }
2780
2781 return 0;
2782 }
2783
2784 return link_set_can(link);
2785 }
2786
2787 if (!(link->flags & IFF_UP)) {
2788 r = link_up_can(link);
2789 if (r < 0) {
2790 link_enter_failed(link);
2791 return r;
2792 }
2793 }
2794
2795 return 0;
2796 }
2797
2798 static int link_configure(Link *link) {
2799 int r;
2800
2801 assert(link);
2802 assert(link->network);
2803 assert(link->state == LINK_STATE_PENDING);
2804
2805 if (STRPTR_IN_SET(link->kind, "can", "vcan"))
2806 return link_configure_can(link);
2807
2808 /* Drop foreign config, but ignore loopback or critical devices.
2809 * We do not want to remove loopback address or addresses used for root NFS. */
2810 if (!(link->flags & IFF_LOOPBACK) && !(link->network->dhcp_critical)) {
2811 r = link_drop_foreign_config(link);
2812 if (r < 0)
2813 return r;
2814 }
2815
2816 r = link_set_proxy_arp(link);
2817 if (r < 0)
2818 return r;
2819
2820 r = ipv6_proxy_ndp_addresses_configure(link);
2821 if (r < 0)
2822 return r;
2823
2824 r = link_set_ipv4_forward(link);
2825 if (r < 0)
2826 return r;
2827
2828 r = link_set_ipv6_forward(link);
2829 if (r < 0)
2830 return r;
2831
2832 r = link_set_ipv6_privacy_extensions(link);
2833 if (r < 0)
2834 return r;
2835
2836 r = link_set_ipv6_accept_ra(link);
2837 if (r < 0)
2838 return r;
2839
2840 r = link_set_ipv6_dad_transmits(link);
2841 if (r < 0)
2842 return r;
2843
2844 r = link_set_ipv6_hop_limit(link);
2845 if (r < 0)
2846 return r;
2847
2848 r = link_set_flags(link);
2849 if (r < 0)
2850 return r;
2851
2852 r = link_set_ipv6_mtu(link);
2853 if (r < 0)
2854 return r;
2855
2856 if (link_ipv4ll_enabled(link)) {
2857 r = ipv4ll_configure(link);
2858 if (r < 0)
2859 return r;
2860 }
2861
2862 if (link_dhcp4_enabled(link)) {
2863 r = dhcp4_set_promote_secondaries(link);
2864 if (r < 0)
2865 return r;
2866
2867 r = dhcp4_configure(link);
2868 if (r < 0)
2869 return r;
2870 }
2871
2872 if (link_dhcp4_server_enabled(link)) {
2873 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2874 if (r < 0)
2875 return r;
2876
2877 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2878 if (r < 0)
2879 return r;
2880 }
2881
2882 if (link_dhcp6_enabled(link) ||
2883 link_ipv6_accept_ra_enabled(link)) {
2884 r = dhcp6_configure(link);
2885 if (r < 0)
2886 return r;
2887 }
2888
2889 if (link_ipv6_accept_ra_enabled(link)) {
2890 r = ndisc_configure(link);
2891 if (r < 0)
2892 return r;
2893 }
2894
2895 if (link_radv_enabled(link)) {
2896 r = radv_configure(link);
2897 if (r < 0)
2898 return r;
2899 }
2900
2901 if (link_lldp_rx_enabled(link)) {
2902 r = sd_lldp_new(&link->lldp);
2903 if (r < 0)
2904 return r;
2905
2906 r = sd_lldp_set_ifindex(link->lldp, link->ifindex);
2907 if (r < 0)
2908 return r;
2909
2910 r = sd_lldp_match_capabilities(link->lldp,
2911 link->network->lldp_mode == LLDP_MODE_ROUTERS_ONLY ?
2912 SD_LLDP_SYSTEM_CAPABILITIES_ALL_ROUTERS :
2913 SD_LLDP_SYSTEM_CAPABILITIES_ALL);
2914 if (r < 0)
2915 return r;
2916
2917 r = sd_lldp_set_filter_address(link->lldp, &link->mac);
2918 if (r < 0)
2919 return r;
2920
2921 r = sd_lldp_attach_event(link->lldp, NULL, 0);
2922 if (r < 0)
2923 return r;
2924
2925 r = sd_lldp_set_callback(link->lldp, lldp_handler, link);
2926 if (r < 0)
2927 return r;
2928
2929 r = link_update_lldp(link);
2930 if (r < 0)
2931 return r;
2932 }
2933
2934 if (link->network->mtu > 0) {
2935 r = link_set_mtu(link, link->network->mtu);
2936 if (r < 0)
2937 return r;
2938 }
2939
2940 return link_configure_after_setting_mtu(link);
2941 }
2942
2943 static int link_configure_after_setting_mtu(Link *link) {
2944 int r;
2945
2946 assert(link);
2947 assert(link->network);
2948 assert(link->state == LINK_STATE_PENDING);
2949
2950 if (link->setting_mtu)
2951 return 0;
2952
2953 if (link_has_carrier(link) || link->network->configure_without_carrier) {
2954 r = link_acquire_conf(link);
2955 if (r < 0)
2956 return r;
2957 }
2958
2959 return link_enter_join_netdev(link);
2960 }
2961
2962 static int duid_set_uuid(DUID *duid, sd_id128_t uuid) {
2963 assert(duid);
2964
2965 if (duid->raw_data_len > 0)
2966 return 0;
2967
2968 if (duid->type != DUID_TYPE_UUID)
2969 return -EINVAL;
2970
2971 memcpy(&duid->raw_data, &uuid, sizeof(sd_id128_t));
2972 duid->raw_data_len = sizeof(sd_id128_t);
2973
2974 return 1;
2975 }
2976
2977 int get_product_uuid_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
2978 Manager *manager = userdata;
2979 const sd_bus_error *e;
2980 const void *a;
2981 size_t sz;
2982 DUID *duid;
2983 Link *link;
2984 int r;
2985
2986 assert(m);
2987 assert(manager);
2988
2989 e = sd_bus_message_get_error(m);
2990 if (e) {
2991 log_error_errno(sd_bus_error_get_errno(e),
2992 "Could not get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %s",
2993 e->message);
2994 goto configure;
2995 }
2996
2997 r = sd_bus_message_read_array(m, 'y', &a, &sz);
2998 if (r < 0)
2999 goto configure;
3000
3001 if (sz != sizeof(sd_id128_t)) {
3002 log_error("Invalid product UUID. Falling back to use machine-app-specific ID as DUID-UUID.");
3003 goto configure;
3004 }
3005
3006 memcpy(&manager->product_uuid, a, sz);
3007 while ((duid = set_steal_first(manager->duids_requesting_uuid)))
3008 (void) duid_set_uuid(duid, manager->product_uuid);
3009
3010 manager->duids_requesting_uuid = set_free(manager->duids_requesting_uuid);
3011
3012 configure:
3013 while ((link = set_steal_first(manager->links_requesting_uuid))) {
3014 r = link_configure(link);
3015 if (r < 0)
3016 log_link_error_errno(link, r, "Failed to configure link: %m");
3017 }
3018
3019 manager->links_requesting_uuid = set_free(manager->links_requesting_uuid);
3020
3021 /* To avoid calling GetProductUUID() bus method so frequently, set the flag below
3022 * even if the method fails. */
3023 manager->has_product_uuid = true;
3024
3025 return 1;
3026 }
3027
3028 static bool link_requires_uuid(Link *link) {
3029 const DUID *duid;
3030
3031 assert(link);
3032 assert(link->manager);
3033 assert(link->network);
3034
3035 duid = link_get_duid(link);
3036 if (duid->type != DUID_TYPE_UUID || duid->raw_data_len != 0)
3037 return false;
3038
3039 if (link_dhcp4_enabled(link) && IN_SET(link->network->dhcp_client_identifier, DHCP_CLIENT_ID_DUID, DHCP_CLIENT_ID_DUID_ONLY))
3040 return true;
3041
3042 if (link_dhcp6_enabled(link) || link_ipv6_accept_ra_enabled(link))
3043 return true;
3044
3045 return false;
3046 }
3047
3048 static int link_configure_duid(Link *link) {
3049 Manager *m;
3050 DUID *duid;
3051 int r;
3052
3053 assert(link);
3054 assert(link->manager);
3055 assert(link->network);
3056
3057 m = link->manager;
3058 duid = link_get_duid(link);
3059
3060 if (!link_requires_uuid(link))
3061 return 1;
3062
3063 if (m->has_product_uuid) {
3064 (void) duid_set_uuid(duid, m->product_uuid);
3065 return 1;
3066 }
3067
3068 if (!m->links_requesting_uuid) {
3069 r = manager_request_product_uuid(m, link);
3070 if (r < 0) {
3071 if (r == -ENOMEM)
3072 return r;
3073
3074 log_link_warning_errno(link, r,
3075 "Failed to get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %m");
3076 return 1;
3077 }
3078 } else {
3079 r = set_put(m->links_requesting_uuid, link);
3080 if (r < 0)
3081 return log_oom();
3082
3083 r = set_put(m->duids_requesting_uuid, duid);
3084 if (r < 0)
3085 return log_oom();
3086 }
3087
3088 return 0;
3089 }
3090
3091 static int link_initialized_and_synced(Link *link) {
3092 Network *network;
3093 int r;
3094
3095 assert(link);
3096 assert(link->ifname);
3097 assert(link->manager);
3098
3099 if (link->state != LINK_STATE_PENDING)
3100 return 1;
3101
3102 log_link_debug(link, "Link state is up-to-date");
3103
3104 r = link_new_bound_by_list(link);
3105 if (r < 0)
3106 return r;
3107
3108 r = link_handle_bound_by_list(link);
3109 if (r < 0)
3110 return r;
3111
3112 if (!link->network) {
3113 r = network_get(link->manager, link->sd_device, link->ifname,
3114 &link->mac, &network);
3115 if (r == -ENOENT) {
3116 link_enter_unmanaged(link);
3117 return 1;
3118 } else if (r == 0 && network->unmanaged) {
3119 link_enter_unmanaged(link);
3120 return 0;
3121 } else if (r < 0)
3122 return r;
3123
3124 if (link->flags & IFF_LOOPBACK) {
3125 if (network->link_local != ADDRESS_FAMILY_NO)
3126 log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
3127
3128 if (network->dhcp != ADDRESS_FAMILY_NO)
3129 log_link_debug(link, "Ignoring DHCP clients for loopback link");
3130
3131 if (network->dhcp_server)
3132 log_link_debug(link, "Ignoring DHCP server for loopback link");
3133 }
3134
3135 r = network_apply(network, link);
3136 if (r < 0)
3137 return r;
3138 }
3139
3140 r = link_new_bound_to_list(link);
3141 if (r < 0)
3142 return r;
3143
3144 /* link_configure_duid() returns 0 if it requests product UUID. In that case,
3145 * link_configure() is called later asynchronously. */
3146 r = link_configure_duid(link);
3147 if (r <= 0)
3148 return r;
3149
3150 r = link_configure(link);
3151 if (r < 0)
3152 return r;
3153
3154 return 1;
3155 }
3156
3157 static int link_initialized_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
3158 (void) link_initialized_and_synced(userdata);
3159 return 1;
3160 }
3161
3162 int link_initialized(Link *link, sd_device *device) {
3163 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
3164 int r;
3165
3166 assert(link);
3167 assert(link->manager);
3168 assert(link->manager->rtnl);
3169 assert(device);
3170
3171 if (link->state != LINK_STATE_PENDING)
3172 return 0;
3173
3174 if (link->sd_device)
3175 return 0;
3176
3177 log_link_debug(link, "udev initialized link");
3178
3179 link->sd_device = sd_device_ref(device);
3180
3181 /* udev has initialized the link, but we don't know if we have yet
3182 * processed the NEWLINK messages with the latest state. Do a GETLINK,
3183 * when it returns we know that the pending NEWLINKs have already been
3184 * processed and that we are up-to-date */
3185
3186 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
3187 link->ifindex);
3188 if (r < 0)
3189 return r;
3190
3191 r = sd_netlink_call_async(link->manager->rtnl, NULL, req, link_initialized_handler,
3192 link_netlink_destroy_callback, link, 0, __func__);
3193 if (r < 0)
3194 return r;
3195
3196 link_ref(link);
3197
3198 return 0;
3199 }
3200
3201 static int link_load(Link *link) {
3202 _cleanup_free_ char *network_file = NULL,
3203 *addresses = NULL,
3204 *routes = NULL,
3205 *dhcp4_address = NULL,
3206 *ipv4ll_address = NULL;
3207 union in_addr_union address;
3208 union in_addr_union route_dst;
3209 const char *p;
3210 int r;
3211
3212 assert(link);
3213
3214 r = parse_env_file(NULL, link->state_file,
3215 "NETWORK_FILE", &network_file,
3216 "ADDRESSES", &addresses,
3217 "ROUTES", &routes,
3218 "DHCP4_ADDRESS", &dhcp4_address,
3219 "IPV4LL_ADDRESS", &ipv4ll_address);
3220 if (r < 0 && r != -ENOENT)
3221 return log_link_error_errno(link, r, "Failed to read %s: %m", link->state_file);
3222
3223 if (network_file) {
3224 Network *network;
3225 char *suffix;
3226
3227 /* drop suffix */
3228 suffix = strrchr(network_file, '.');
3229 if (!suffix) {
3230 log_link_debug(link, "Failed to get network name from %s", network_file);
3231 goto network_file_fail;
3232 }
3233 *suffix = '\0';
3234
3235 r = network_get_by_name(link->manager, basename(network_file), &network);
3236 if (r < 0) {
3237 log_link_debug_errno(link, r, "Failed to get network %s: %m", basename(network_file));
3238 goto network_file_fail;
3239 }
3240
3241 r = network_apply(network, link);
3242 if (r < 0)
3243 return log_link_error_errno(link, r, "Failed to apply network %s: %m", basename(network_file));
3244 }
3245
3246 network_file_fail:
3247
3248 if (addresses) {
3249 p = addresses;
3250
3251 for (;;) {
3252 _cleanup_free_ char *address_str = NULL;
3253 char *prefixlen_str;
3254 int family;
3255 unsigned char prefixlen;
3256
3257 r = extract_first_word(&p, &address_str, NULL, 0);
3258 if (r < 0) {
3259 log_link_debug_errno(link, r, "Failed to extract next address string: %m");
3260 continue;
3261 }
3262 if (r == 0)
3263 break;
3264
3265 prefixlen_str = strchr(address_str, '/');
3266 if (!prefixlen_str) {
3267 log_link_debug(link, "Failed to parse address and prefix length %s", address_str);
3268 continue;
3269 }
3270
3271 *prefixlen_str++ = '\0';
3272
3273 r = sscanf(prefixlen_str, "%hhu", &prefixlen);
3274 if (r != 1) {
3275 log_link_error(link, "Failed to parse prefixlen %s", prefixlen_str);
3276 continue;
3277 }
3278
3279 r = in_addr_from_string_auto(address_str, &family, &address);
3280 if (r < 0) {
3281 log_link_debug_errno(link, r, "Failed to parse address %s: %m", address_str);
3282 continue;
3283 }
3284
3285 r = address_add(link, family, &address, prefixlen, NULL);
3286 if (r < 0)
3287 return log_link_error_errno(link, r, "Failed to add address: %m");
3288 }
3289 }
3290
3291 if (routes) {
3292 p = routes;
3293
3294 for (;;) {
3295 Route *route;
3296 _cleanup_free_ char *route_str = NULL;
3297 _cleanup_(sd_event_source_unrefp) sd_event_source *expire = NULL;
3298 usec_t lifetime;
3299 char *prefixlen_str;
3300 int family;
3301 unsigned char prefixlen, tos, table;
3302 uint32_t priority;
3303
3304 r = extract_first_word(&p, &route_str, NULL, 0);
3305 if (r < 0) {
3306 log_link_debug_errno(link, r, "Failed to extract next route string: %m");
3307 continue;
3308 }
3309 if (r == 0)
3310 break;
3311
3312 prefixlen_str = strchr(route_str, '/');
3313 if (!prefixlen_str) {
3314 log_link_debug(link, "Failed to parse route %s", route_str);
3315 continue;
3316 }
3317
3318 *prefixlen_str++ = '\0';
3319
3320 r = sscanf(prefixlen_str, "%hhu/%hhu/%"SCNu32"/%hhu/"USEC_FMT, &prefixlen, &tos, &priority, &table, &lifetime);
3321 if (r != 5) {
3322 log_link_debug(link,
3323 "Failed to parse destination prefix length, tos, priority, table or expiration %s",
3324 prefixlen_str);
3325 continue;
3326 }
3327
3328 r = in_addr_from_string_auto(route_str, &family, &route_dst);
3329 if (r < 0) {
3330 log_link_debug_errno(link, r, "Failed to parse route destination %s: %m", route_str);
3331 continue;
3332 }
3333
3334 r = route_add(link, family, &route_dst, prefixlen, tos, priority, table, &route);
3335 if (r < 0)
3336 return log_link_error_errno(link, r, "Failed to add route: %m");
3337
3338 if (lifetime != USEC_INFINITY && !kernel_route_expiration_supported()) {
3339 r = sd_event_add_time(link->manager->event, &expire, clock_boottime_or_monotonic(), lifetime,
3340 0, route_expire_handler, route);
3341 if (r < 0)
3342 log_link_warning_errno(link, r, "Could not arm route expiration handler: %m");
3343 }
3344
3345 route->lifetime = lifetime;
3346 sd_event_source_unref(route->expire);
3347 route->expire = TAKE_PTR(expire);
3348 }
3349 }
3350
3351 if (dhcp4_address) {
3352 r = in_addr_from_string(AF_INET, dhcp4_address, &address);
3353 if (r < 0) {
3354 log_link_debug_errno(link, r, "Failed to parse DHCPv4 address %s: %m", dhcp4_address);
3355 goto dhcp4_address_fail;
3356 }
3357
3358 r = sd_dhcp_client_new(&link->dhcp_client, link->network ? link->network->dhcp_anonymize : 0);
3359 if (r < 0)
3360 return log_link_error_errno(link, r, "Failed to create DHCPv4 client: %m");
3361
3362 r = sd_dhcp_client_set_request_address(link->dhcp_client, &address.in);
3363 if (r < 0)
3364 return log_link_error_errno(link, r, "Failed to set initial DHCPv4 address %s: %m", dhcp4_address);
3365 }
3366
3367 dhcp4_address_fail:
3368
3369 if (ipv4ll_address) {
3370 r = in_addr_from_string(AF_INET, ipv4ll_address, &address);
3371 if (r < 0) {
3372 log_link_debug_errno(link, r, "Failed to parse IPv4LL address %s: %m", ipv4ll_address);
3373 goto ipv4ll_address_fail;
3374 }
3375
3376 r = sd_ipv4ll_new(&link->ipv4ll);
3377 if (r < 0)
3378 return log_link_error_errno(link, r, "Failed to create IPv4LL client: %m");
3379
3380 r = sd_ipv4ll_set_address(link->ipv4ll, &address.in);
3381 if (r < 0)
3382 return log_link_error_errno(link, r, "Failed to set initial IPv4LL address %s: %m", ipv4ll_address);
3383 }
3384
3385 ipv4ll_address_fail:
3386
3387 return 0;
3388 }
3389
3390 int link_add(Manager *m, sd_netlink_message *message, Link **ret) {
3391 _cleanup_(sd_device_unrefp) sd_device *device = NULL;
3392 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
3393 Link *link;
3394 int r;
3395
3396 assert(m);
3397 assert(m->rtnl);
3398 assert(message);
3399 assert(ret);
3400
3401 r = link_new(m, message, ret);
3402 if (r < 0)
3403 return r;
3404
3405 link = *ret;
3406
3407 log_link_debug(link, "Link %d added", link->ifindex);
3408
3409 r = link_load(link);
3410 if (r < 0)
3411 return r;
3412
3413 if (detect_container() <= 0) {
3414 /* not in a container, udev will be around */
3415 sprintf(ifindex_str, "n%d", link->ifindex);
3416 r = sd_device_new_from_device_id(&device, ifindex_str);
3417 if (r < 0) {
3418 log_link_warning_errno(link, r, "Could not find device: %m");
3419 goto failed;
3420 }
3421
3422 r = sd_device_get_is_initialized(device);
3423 if (r < 0) {
3424 log_link_warning_errno(link, r, "Could not determine whether the device is initialized or not: %m");
3425 goto failed;
3426 }
3427 if (r == 0) {
3428 /* not yet ready */
3429 log_link_debug(link, "link pending udev initialization...");
3430 return 0;
3431 }
3432
3433 r = link_initialized(link, device);
3434 if (r < 0)
3435 goto failed;
3436 } else {
3437 r = link_initialized_and_synced(link);
3438 if (r < 0)
3439 goto failed;
3440 }
3441
3442 return 0;
3443 failed:
3444 link_enter_failed(link);
3445 return r;
3446 }
3447
3448 int link_ipv6ll_gained(Link *link, const struct in6_addr *address) {
3449 int r;
3450
3451 assert(link);
3452
3453 log_link_info(link, "Gained IPv6LL");
3454
3455 link->ipv6ll_address = *address;
3456 link_check_ready(link);
3457
3458 if (!IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_UNMANAGED, LINK_STATE_FAILED)) {
3459 r = link_acquire_ipv6_conf(link);
3460 if (r < 0) {
3461 link_enter_failed(link);
3462 return r;
3463 }
3464 }
3465
3466 return 0;
3467 }
3468
3469 static int link_carrier_gained(Link *link) {
3470 int r;
3471
3472 assert(link);
3473
3474 if (!IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_UNMANAGED, LINK_STATE_FAILED)) {
3475 r = link_acquire_conf(link);
3476 if (r < 0) {
3477 link_enter_failed(link);
3478 return r;
3479 }
3480
3481 r = link_enter_set_addresses(link);
3482 if (r < 0)
3483 return r;
3484 }
3485
3486 r = link_handle_bound_by_list(link);
3487 if (r < 0)
3488 return r;
3489
3490 return 0;
3491 }
3492
3493 static int link_carrier_lost(Link *link) {
3494 int r;
3495
3496 assert(link);
3497
3498 /* Some devices reset itself while setting the MTU. This causes the DHCP client fall into a loop.
3499 * setting_mtu keep track whether the device got reset because of setting MTU and does not drop the
3500 * configuration and stop the clients as well. */
3501 if (link->setting_mtu)
3502 return 0;
3503
3504 r = link_stop_clients(link);
3505 if (r < 0) {
3506 link_enter_failed(link);
3507 return r;
3508 }
3509
3510 if (link_dhcp4_server_enabled(link))
3511 (void) sd_dhcp_server_stop(link->dhcp_server);
3512
3513 r = link_drop_config(link);
3514 if (r < 0)
3515 return r;
3516
3517 if (!IN_SET(link->state, LINK_STATE_UNMANAGED, LINK_STATE_PENDING)) {
3518 log_link_debug(link, "State is %s, dropping config", link_state_to_string(link->state));
3519 r = link_drop_foreign_config(link);
3520 if (r < 0)
3521 return r;
3522 }
3523
3524 r = link_handle_bound_by_list(link);
3525 if (r < 0)
3526 return r;
3527
3528 return 0;
3529 }
3530
3531 int link_carrier_reset(Link *link) {
3532 int r;
3533
3534 assert(link);
3535
3536 if (link_has_carrier(link)) {
3537 r = link_carrier_lost(link);
3538 if (r < 0)
3539 return r;
3540
3541 r = link_carrier_gained(link);
3542 if (r < 0)
3543 return r;
3544
3545 log_link_info(link, "Reset carrier");
3546 }
3547
3548 return 0;
3549 }
3550
3551 int link_update(Link *link, sd_netlink_message *m) {
3552 struct ether_addr mac;
3553 const char *ifname;
3554 uint32_t mtu;
3555 bool had_carrier, carrier_gained, carrier_lost;
3556 int r;
3557
3558 assert(link);
3559 assert(link->ifname);
3560 assert(m);
3561
3562 if (link->state == LINK_STATE_LINGER) {
3563 log_link_info(link, "Link readded");
3564 link_set_state(link, LINK_STATE_ENSLAVING);
3565
3566 r = link_new_carrier_maps(link);
3567 if (r < 0)
3568 return r;
3569 }
3570
3571 r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
3572 if (r >= 0 && !streq(ifname, link->ifname)) {
3573 log_link_info(link, "Interface name change detected, %s has been renamed to %s.", link->ifname, ifname);
3574
3575 if (link->state == LINK_STATE_PENDING) {
3576 r = free_and_strdup(&link->ifname, ifname);
3577 if (r < 0)
3578 return r;
3579 } else {
3580 Manager *manager = link->manager;
3581
3582 link_drop(link);
3583 r = link_add(manager, m, &link);
3584 if (r < 0)
3585 return r;
3586 }
3587 }
3588
3589 r = sd_netlink_message_read_u32(m, IFLA_MTU, &mtu);
3590 if (r >= 0 && mtu > 0) {
3591 link->mtu = mtu;
3592 if (link->original_mtu == 0) {
3593 link->original_mtu = mtu;
3594 log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
3595 }
3596
3597 if (link->dhcp_client) {
3598 r = sd_dhcp_client_set_mtu(link->dhcp_client,
3599 link->mtu);
3600 if (r < 0)
3601 return log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
3602 }
3603
3604 if (link->radv) {
3605 r = sd_radv_set_mtu(link->radv, link->mtu);
3606 if (r < 0)
3607 return log_link_warning_errno(link, r, "Could not set MTU for Router Advertisement: %m");
3608 }
3609 }
3610
3611 /* The kernel may broadcast NEWLINK messages without the MAC address
3612 set, simply ignore them. */
3613 r = sd_netlink_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
3614 if (r >= 0) {
3615 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
3616 ETH_ALEN)) {
3617
3618 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
3619 ETH_ALEN);
3620
3621 log_link_debug(link, "MAC address: "
3622 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
3623 mac.ether_addr_octet[0],
3624 mac.ether_addr_octet[1],
3625 mac.ether_addr_octet[2],
3626 mac.ether_addr_octet[3],
3627 mac.ether_addr_octet[4],
3628 mac.ether_addr_octet[5]);
3629
3630 if (link->ipv4ll) {
3631 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
3632 if (r < 0)
3633 return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
3634 }
3635
3636 if (link->dhcp_client) {
3637 r = sd_dhcp_client_set_mac(link->dhcp_client,
3638 (const uint8_t *) &link->mac,
3639 sizeof (link->mac),
3640 ARPHRD_ETHER);
3641 if (r < 0)
3642 return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
3643
3644 r = dhcp4_set_client_identifier(link);
3645 if (r < 0)
3646 return r;
3647 }
3648
3649 if (link->dhcp6_client) {
3650 const DUID* duid = link_get_duid(link);
3651
3652 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
3653 (const uint8_t *) &link->mac,
3654 sizeof (link->mac),
3655 ARPHRD_ETHER);
3656 if (r < 0)
3657 return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
3658
3659 r = sd_dhcp6_client_set_iaid(link->dhcp6_client,
3660 link->network->iaid);
3661 if (r < 0)
3662 return log_link_warning_errno(link, r, "Could not update DHCPv6 IAID: %m");
3663
3664 r = sd_dhcp6_client_set_duid(link->dhcp6_client,
3665 duid->type,
3666 duid->raw_data_len > 0 ? duid->raw_data : NULL,
3667 duid->raw_data_len);
3668 if (r < 0)
3669 return log_link_warning_errno(link, r, "Could not update DHCPv6 DUID: %m");
3670 }
3671
3672 if (link->radv) {
3673 r = sd_radv_set_mac(link->radv, &link->mac);
3674 if (r < 0)
3675 return log_link_warning_errno(link, r, "Could not update MAC for Router Advertisement: %m");
3676 }
3677
3678 if (link->ndisc) {
3679 r = sd_ndisc_set_mac(link->ndisc, &link->mac);
3680 if (r < 0)
3681 return log_link_warning_errno(link, r, "Could not update MAC for ndisc: %m");
3682 }
3683 }
3684 }
3685
3686 had_carrier = link_has_carrier(link);
3687
3688 r = link_update_flags(link, m);
3689 if (r < 0)
3690 return r;
3691
3692 r = link_update_lldp(link);
3693 if (r < 0)
3694 return r;
3695
3696 carrier_gained = !had_carrier && link_has_carrier(link);
3697 carrier_lost = had_carrier && !link_has_carrier(link);
3698
3699 if (carrier_gained) {
3700 log_link_info(link, "Gained carrier");
3701
3702 r = link_carrier_gained(link);
3703 if (r < 0)
3704 return r;
3705 } else if (carrier_lost) {
3706 log_link_info(link, "Lost carrier");
3707
3708 r = link_carrier_lost(link);
3709 if (r < 0)
3710 return r;
3711 }
3712
3713 return 0;
3714 }
3715
3716 static void print_link_hashmap(FILE *f, const char *prefix, Hashmap* h) {
3717 bool space = false;
3718 Iterator i;
3719 Link *link;
3720
3721 assert(f);
3722 assert(prefix);
3723
3724 if (hashmap_isempty(h))
3725 return;
3726
3727 fputs(prefix, f);
3728 HASHMAP_FOREACH(link, h, i) {
3729 if (space)
3730 fputc(' ', f);
3731
3732 fprintf(f, "%i", link->ifindex);
3733 space = true;
3734 }
3735
3736 fputc('\n', f);
3737 }
3738
3739 int link_save(Link *link) {
3740 _cleanup_free_ char *temp_path = NULL;
3741 _cleanup_fclose_ FILE *f = NULL;
3742 const char *admin_state, *oper_state;
3743 Address *a;
3744 Route *route;
3745 Iterator i;
3746 int r;
3747
3748 assert(link);
3749 assert(link->state_file);
3750 assert(link->lease_file);
3751 assert(link->manager);
3752
3753 if (link->state == LINK_STATE_LINGER) {
3754 unlink(link->state_file);
3755 return 0;
3756 }
3757
3758 link_lldp_save(link);
3759
3760 admin_state = link_state_to_string(link->state);
3761 assert(admin_state);
3762
3763 oper_state = link_operstate_to_string(link->operstate);
3764 assert(oper_state);
3765
3766 r = fopen_temporary(link->state_file, &f, &temp_path);
3767 if (r < 0)
3768 goto fail;
3769
3770 (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
3771 (void) fchmod(fileno(f), 0644);
3772
3773 fprintf(f,
3774 "# This is private data. Do not parse.\n"
3775 "ADMIN_STATE=%s\n"
3776 "OPER_STATE=%s\n",
3777 admin_state, oper_state);
3778
3779 if (link->network) {
3780 bool space;
3781 sd_dhcp6_lease *dhcp6_lease = NULL;
3782 const char *dhcp_domainname = NULL;
3783 char **dhcp6_domains = NULL;
3784 char **dhcp_domains = NULL;
3785 unsigned j;
3786
3787 fprintf(f, "REQUIRED_FOR_ONLINE=%s\n",
3788 yes_no(link->network->required_for_online));
3789
3790 if (link->dhcp6_client) {
3791 r = sd_dhcp6_client_get_lease(link->dhcp6_client, &dhcp6_lease);
3792 if (r < 0 && r != -ENOMSG)
3793 log_link_debug(link, "No DHCPv6 lease");
3794 }
3795
3796 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
3797
3798 fputs("DNS=", f);
3799 space = false;
3800
3801 for (j = 0; j < link->network->n_dns; j++) {
3802 _cleanup_free_ char *b = NULL;
3803
3804 r = in_addr_to_string(link->network->dns[j].family,
3805 &link->network->dns[j].address, &b);
3806 if (r < 0) {
3807 log_debug_errno(r, "Failed to format address, ignoring: %m");
3808 continue;
3809 }
3810
3811 if (space)
3812 fputc(' ', f);
3813 fputs(b, f);
3814 space = true;
3815 }
3816
3817 if (link->network->dhcp_use_dns &&
3818 link->dhcp_lease) {
3819 const struct in_addr *addresses;
3820
3821 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
3822 if (r > 0) {
3823 if (space)
3824 fputc(' ', f);
3825 serialize_in_addrs(f, addresses, r);
3826 space = true;
3827 }
3828 }
3829
3830 if (link->network->dhcp_use_dns && dhcp6_lease) {
3831 struct in6_addr *in6_addrs;
3832
3833 r = sd_dhcp6_lease_get_dns(dhcp6_lease, &in6_addrs);
3834 if (r > 0) {
3835 if (space)
3836 fputc(' ', f);
3837 serialize_in6_addrs(f, in6_addrs, r);
3838 space = true;
3839 }
3840 }
3841
3842 /* Make sure to flush out old entries before we use the NDISC data */
3843 ndisc_vacuum(link);
3844
3845 if (link->network->ipv6_accept_ra_use_dns && link->ndisc_rdnss) {
3846 NDiscRDNSS *dd;
3847
3848 SET_FOREACH(dd, link->ndisc_rdnss, i) {
3849 if (space)
3850 fputc(' ', f);
3851
3852 serialize_in6_addrs(f, &dd->address, 1);
3853 space = true;
3854 }
3855 }
3856
3857 fputc('\n', f);
3858
3859 fputs("NTP=", f);
3860 space = false;
3861 fputstrv(f, link->network->ntp, NULL, &space);
3862
3863 if (link->network->dhcp_use_ntp &&
3864 link->dhcp_lease) {
3865 const struct in_addr *addresses;
3866
3867 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
3868 if (r > 0) {
3869 if (space)
3870 fputc(' ', f);
3871 serialize_in_addrs(f, addresses, r);
3872 space = true;
3873 }
3874 }
3875
3876 if (link->network->dhcp_use_ntp && dhcp6_lease) {
3877 struct in6_addr *in6_addrs;
3878 char **hosts;
3879
3880 r = sd_dhcp6_lease_get_ntp_addrs(dhcp6_lease,
3881 &in6_addrs);
3882 if (r > 0) {
3883 if (space)
3884 fputc(' ', f);
3885 serialize_in6_addrs(f, in6_addrs, r);
3886 space = true;
3887 }
3888
3889 r = sd_dhcp6_lease_get_ntp_fqdn(dhcp6_lease, &hosts);
3890 if (r > 0)
3891 fputstrv(f, hosts, NULL, &space);
3892 }
3893
3894 fputc('\n', f);
3895
3896 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
3897 if (link->dhcp_lease) {
3898 (void) sd_dhcp_lease_get_domainname(link->dhcp_lease, &dhcp_domainname);
3899 (void) sd_dhcp_lease_get_search_domains(link->dhcp_lease, &dhcp_domains);
3900 }
3901 if (dhcp6_lease)
3902 (void) sd_dhcp6_lease_get_domains(dhcp6_lease, &dhcp6_domains);
3903 }
3904
3905 fputs("DOMAINS=", f);
3906 space = false;
3907 fputstrv(f, link->network->search_domains, NULL, &space);
3908
3909 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES) {
3910 NDiscDNSSL *dd;
3911
3912 if (dhcp_domainname)
3913 fputs_with_space(f, dhcp_domainname, NULL, &space);
3914 if (dhcp_domains)
3915 fputstrv(f, dhcp_domains, NULL, &space);
3916 if (dhcp6_domains)
3917 fputstrv(f, dhcp6_domains, NULL, &space);
3918
3919 SET_FOREACH(dd, link->ndisc_dnssl, i)
3920 fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
3921 }
3922
3923 fputc('\n', f);
3924
3925 fputs("ROUTE_DOMAINS=", f);
3926 space = false;
3927 fputstrv(f, link->network->route_domains, NULL, &space);
3928
3929 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_ROUTE) {
3930 NDiscDNSSL *dd;
3931
3932 if (dhcp_domainname)
3933 fputs_with_space(f, dhcp_domainname, NULL, &space);
3934 if (dhcp_domains)
3935 fputstrv(f, dhcp_domains, NULL, &space);
3936 if (dhcp6_domains)
3937 fputstrv(f, dhcp6_domains, NULL, &space);
3938
3939 SET_FOREACH(dd, link->ndisc_dnssl, i)
3940 fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
3941 }
3942
3943 fputc('\n', f);
3944
3945 fprintf(f, "LLMNR=%s\n",
3946 resolve_support_to_string(link->network->llmnr));
3947 fprintf(f, "MDNS=%s\n",
3948 resolve_support_to_string(link->network->mdns));
3949
3950 if (link->network->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
3951 fprintf(f, "DNS_OVER_TLS=%s\n",
3952 dns_over_tls_mode_to_string(link->network->dns_over_tls_mode));
3953
3954 if (link->network->dnssec_mode != _DNSSEC_MODE_INVALID)
3955 fprintf(f, "DNSSEC=%s\n",
3956 dnssec_mode_to_string(link->network->dnssec_mode));
3957
3958 if (!set_isempty(link->network->dnssec_negative_trust_anchors)) {
3959 const char *n;
3960
3961 fputs("DNSSEC_NTA=", f);
3962 space = false;
3963 SET_FOREACH(n, link->network->dnssec_negative_trust_anchors, i)
3964 fputs_with_space(f, n, NULL, &space);
3965 fputc('\n', f);
3966 }
3967
3968 fputs("ADDRESSES=", f);
3969 space = false;
3970 SET_FOREACH(a, link->addresses, i) {
3971 _cleanup_free_ char *address_str = NULL;
3972
3973 r = in_addr_to_string(a->family, &a->in_addr, &address_str);
3974 if (r < 0)
3975 goto fail;
3976
3977 fprintf(f, "%s%s/%u", space ? " " : "", address_str, a->prefixlen);
3978 space = true;
3979 }
3980 fputc('\n', f);
3981
3982 fputs("ROUTES=", f);
3983 space = false;
3984 SET_FOREACH(route, link->routes, i) {
3985 _cleanup_free_ char *route_str = NULL;
3986
3987 r = in_addr_to_string(route->family, &route->dst, &route_str);
3988 if (r < 0)
3989 goto fail;
3990
3991 fprintf(f, "%s%s/%hhu/%hhu/%"PRIu32"/%"PRIu32"/"USEC_FMT,
3992 space ? " " : "", route_str,
3993 route->dst_prefixlen, route->tos, route->priority, route->table, route->lifetime);
3994 space = true;
3995 }
3996
3997 fputc('\n', f);
3998 }
3999
4000 print_link_hashmap(f, "CARRIER_BOUND_TO=", link->bound_to_links);
4001 print_link_hashmap(f, "CARRIER_BOUND_BY=", link->bound_by_links);
4002
4003 if (link->dhcp_lease) {
4004 struct in_addr address;
4005 const char *tz = NULL;
4006
4007 assert(link->network);
4008
4009 r = sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
4010 if (r >= 0)
4011 fprintf(f, "TIMEZONE=%s\n", tz);
4012
4013 r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
4014 if (r >= 0) {
4015 fputs("DHCP4_ADDRESS=", f);
4016 serialize_in_addrs(f, &address, 1);
4017 fputc('\n', f);
4018 }
4019
4020 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
4021 if (r < 0)
4022 goto fail;
4023
4024 fprintf(f,
4025 "DHCP_LEASE=%s\n",
4026 link->lease_file);
4027 } else
4028 unlink(link->lease_file);
4029
4030 if (link->ipv4ll) {
4031 struct in_addr address;
4032
4033 r = sd_ipv4ll_get_address(link->ipv4ll, &address);
4034 if (r >= 0) {
4035 fputs("IPV4LL_ADDRESS=", f);
4036 serialize_in_addrs(f, &address, 1);
4037 fputc('\n', f);
4038 }
4039 }
4040
4041 r = fflush_and_check(f);
4042 if (r < 0)
4043 goto fail;
4044
4045 if (rename(temp_path, link->state_file) < 0) {
4046 r = -errno;
4047 goto fail;
4048 }
4049
4050 return 0;
4051
4052 fail:
4053 (void) unlink(link->state_file);
4054 if (temp_path)
4055 (void) unlink(temp_path);
4056
4057 return log_link_error_errno(link, r, "Failed to save link data to %s: %m", link->state_file);
4058 }
4059
4060 /* The serialized state in /run is no longer up-to-date. */
4061 void link_dirty(Link *link) {
4062 int r;
4063
4064 assert(link);
4065
4066 /* mark manager dirty as link is dirty */
4067 manager_dirty(link->manager);
4068
4069 r = set_ensure_allocated(&link->manager->dirty_links, NULL);
4070 if (r < 0)
4071 /* allocation errors are ignored */
4072 return;
4073
4074 r = set_put(link->manager->dirty_links, link);
4075 if (r <= 0)
4076 /* don't take another ref if the link was already dirty */
4077 return;
4078
4079 link_ref(link);
4080 }
4081
4082 /* The serialized state in /run is up-to-date */
4083 void link_clean(Link *link) {
4084 assert(link);
4085 assert(link->manager);
4086
4087 link_unref(set_remove(link->manager->dirty_links, link));
4088 }
4089
4090 static const char* const link_state_table[_LINK_STATE_MAX] = {
4091 [LINK_STATE_PENDING] = "pending",
4092 [LINK_STATE_ENSLAVING] = "configuring",
4093 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
4094 [LINK_STATE_SETTING_ROUTES] = "configuring",
4095 [LINK_STATE_CONFIGURED] = "configured",
4096 [LINK_STATE_UNMANAGED] = "unmanaged",
4097 [LINK_STATE_FAILED] = "failed",
4098 [LINK_STATE_LINGER] = "linger",
4099 };
4100
4101 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
4102
4103 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
4104 [LINK_OPERSTATE_OFF] = "off",
4105 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
4106 [LINK_OPERSTATE_DORMANT] = "dormant",
4107 [LINK_OPERSTATE_CARRIER] = "carrier",
4108 [LINK_OPERSTATE_DEGRADED] = "degraded",
4109 [LINK_OPERSTATE_ROUTABLE] = "routable",
4110 };
4111
4112 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
Unnamed repository; edit this file 'description' to name the repository.