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