]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/network/networkd-link.c
projects / thirdparty / systemd.git / blob
? search:


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