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