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