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