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