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