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