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