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