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