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