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