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