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