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