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