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