]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/network/networkd-link.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #1768 from vcaputo/sd-daemon-listen-fds-overflow-bis
[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_configure(Link *link) {
1956 int r;
1957
1958 assert(link);
1959 assert(link->network);
1960 assert(link->state == LINK_STATE_PENDING);
1961
1962 r = link_set_bridge_fdb(link);
1963 if (r < 0)
1964 return r;
1965
1966 r = link_set_ipv4_forward(link);
1967 if (r < 0)
1968 return r;
1969
1970 r = link_set_ipv6_forward(link);
1971 if (r < 0)
1972 return r;
1973
1974 r = link_set_ipv6_privacy_extensions(link);
1975 if (r < 0)
1976 return r;
1977
1978 r = link_set_ipv6_accept_ra(link);
1979 if (r < 0)
1980 return r;
1981
1982 r = link_set_ipv6_dad_transmits(link);
1983 if (r < 0)
1984 return r;
1985
1986 if (link_ipv4ll_enabled(link)) {
1987 r = ipv4ll_configure(link);
1988 if (r < 0)
1989 return r;
1990 }
1991
1992 if (link_dhcp4_enabled(link)) {
1993 r = dhcp4_configure(link);
1994 if (r < 0)
1995 return r;
1996 }
1997
1998 if (link_dhcp4_server_enabled(link)) {
1999 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2000 if (r < 0)
2001 return r;
2002
2003 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2004 if (r < 0)
2005 return r;
2006 }
2007
2008 if (link_dhcp6_enabled(link)) {
2009 r = ndisc_configure(link);
2010 if (r < 0)
2011 return r;
2012 }
2013
2014 if (link_lldp_enabled(link)) {
2015 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
2016 if (r < 0)
2017 return r;
2018
2019 r = sd_lldp_attach_event(link->lldp, NULL, 0);
2020 if (r < 0)
2021 return r;
2022
2023 r = sd_lldp_set_callback(link->lldp,
2024 lldp_handler, link);
2025 if (r < 0)
2026 return r;
2027 }
2028
2029 if (link_has_carrier(link)) {
2030 r = link_acquire_conf(link);
2031 if (r < 0)
2032 return r;
2033 }
2034
2035 return link_enter_join_netdev(link);
2036 }
2037
2038 static int link_initialized_and_synced(sd_netlink *rtnl, sd_netlink_message *m,
2039 void *userdata) {
2040 _cleanup_link_unref_ Link *link = userdata;
2041 Network *network;
2042 int r;
2043
2044 assert(link);
2045 assert(link->ifname);
2046 assert(link->manager);
2047
2048 if (link->state != LINK_STATE_PENDING)
2049 return 1;
2050
2051 log_link_debug(link, "Link state is up-to-date");
2052
2053 r = link_new_bound_by_list(link);
2054 if (r < 0)
2055 return r;
2056
2057 r = link_handle_bound_by_list(link);
2058 if (r < 0)
2059 return r;
2060
2061 if (!link->network) {
2062 r = network_get(link->manager, link->udev_device, link->ifname,
2063 &link->mac, &network);
2064 if (r == -ENOENT) {
2065 link_enter_unmanaged(link);
2066 return 1;
2067 } else if (r < 0)
2068 return r;
2069
2070 if (link->flags & IFF_LOOPBACK) {
2071 if (network->link_local != ADDRESS_FAMILY_NO)
2072 log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
2073
2074 if (network->dhcp != ADDRESS_FAMILY_NO)
2075 log_link_debug(link, "Ignoring DHCP clients for loopback link");
2076
2077 if (network->dhcp_server)
2078 log_link_debug(link, "Ignoring DHCP server for loopback link");
2079 }
2080
2081 r = network_apply(link->manager, network, link);
2082 if (r < 0)
2083 return r;
2084 }
2085
2086 r = link_new_bound_to_list(link);
2087 if (r < 0)
2088 return r;
2089
2090 r = link_configure(link);
2091 if (r < 0)
2092 return r;
2093
2094 return 1;
2095 }
2096
2097 int link_initialized(Link *link, struct udev_device *device) {
2098 _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
2099 int r;
2100
2101 assert(link);
2102 assert(link->manager);
2103 assert(link->manager->rtnl);
2104 assert(device);
2105
2106 if (link->state != LINK_STATE_PENDING)
2107 return 0;
2108
2109 if (link->udev_device)
2110 return 0;
2111
2112 log_link_debug(link, "udev initialized link");
2113
2114 link->udev_device = udev_device_ref(device);
2115
2116 /* udev has initialized the link, but we don't know if we have yet
2117 * processed the NEWLINK messages with the latest state. Do a GETLINK,
2118 * when it returns we know that the pending NEWLINKs have already been
2119 * processed and that we are up-to-date */
2120
2121 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
2122 link->ifindex);
2123 if (r < 0)
2124 return r;
2125
2126 r = sd_netlink_call_async(link->manager->rtnl, req,
2127 link_initialized_and_synced, link, 0, NULL);
2128 if (r < 0)
2129 return r;
2130
2131 link_ref(link);
2132
2133 return 0;
2134 }
2135
2136 static int link_load(Link *link) {
2137 _cleanup_free_ char *network_file = NULL,
2138 *addresses = NULL,
2139 *routes = NULL,
2140 *dhcp4_address = NULL,
2141 *ipv4ll_address = NULL;
2142 union in_addr_union address;
2143 union in_addr_union route_dst;
2144 const char *p;
2145 int r;
2146
2147 assert(link);
2148
2149 r = parse_env_file(link->state_file, NEWLINE,
2150 "NETWORK_FILE", &network_file,
2151 "ADDRESSES", &addresses,
2152 "ROUTES", &routes,
2153 "DHCP4_ADDRESS", &dhcp4_address,
2154 "IPV4LL_ADDRESS", &ipv4ll_address,
2155 NULL);
2156 if (r < 0 && r != -ENOENT)
2157 return log_link_error_errno(link, r, "Failed to read %s: %m", link->state_file);
2158
2159 if (network_file) {
2160 Network *network;
2161 char *suffix;
2162
2163 /* drop suffix */
2164 suffix = strrchr(network_file, '.');
2165 if (!suffix) {
2166 log_link_debug(link, "Failed to get network name from %s", network_file);
2167 goto network_file_fail;
2168 }
2169 *suffix = '\0';
2170
2171 r = network_get_by_name(link->manager, basename(network_file), &network);
2172 if (r < 0) {
2173 log_link_debug_errno(link, r, "Failed to get network %s: %m", basename(network_file));
2174 goto network_file_fail;
2175 }
2176
2177 r = network_apply(link->manager, network, link);
2178 if (r < 0)
2179 return log_link_error_errno(link, r, "Failed to apply network %s: %m", basename(network_file));
2180 }
2181
2182 network_file_fail:
2183
2184 if (addresses) {
2185 p = addresses;
2186
2187 for (;;) {
2188 _cleanup_free_ char *address_str = NULL;
2189 char *prefixlen_str;
2190 int family;
2191 unsigned char prefixlen;
2192
2193 r = extract_first_word(&p, &address_str, NULL, 0);
2194 if (r < 0) {
2195 log_link_debug_errno(link, r, "Failed to extract next address string: %m");
2196 continue;
2197 } if (r == 0)
2198 break;
2199
2200 prefixlen_str = strchr(address_str, '/');
2201 if (!prefixlen_str) {
2202 log_link_debug(link, "Failed to parse address and prefix length %s", address_str);
2203 continue;
2204 }
2205
2206 *prefixlen_str ++ = '\0';
2207
2208 r = sscanf(prefixlen_str, "%hhu", &prefixlen);
2209 if (r != 1) {
2210 log_link_error(link, "Failed to parse prefixlen %s", prefixlen_str);
2211 continue;
2212 }
2213
2214 r = in_addr_from_string_auto(address_str, &family, &address);
2215 if (r < 0) {
2216 log_link_debug_errno(link, r, "Failed to parse address %s: %m", address_str);
2217 continue;
2218 }
2219
2220 r = address_add(link, family, &address, prefixlen, NULL);
2221 if (r < 0)
2222 return log_link_error_errno(link, r, "Failed to add address: %m");
2223 }
2224 }
2225
2226 if (routes) {
2227 for (;;) {
2228 Route *route;
2229 _cleanup_free_ char *route_str = NULL;
2230 _cleanup_event_source_unref_ sd_event_source *expire = NULL;
2231 usec_t lifetime;
2232 char *prefixlen_str;
2233 int family;
2234 unsigned char prefixlen, tos, table;
2235 uint32_t priority;
2236
2237 r = extract_first_word(&p, &route_str, NULL, 0);
2238 if (r < 0) {
2239 log_link_debug_errno(link, r, "Failed to extract next route string: %m");
2240 continue;
2241 } if (r == 0)
2242 break;
2243
2244 prefixlen_str = strchr(route_str, '/');
2245 if (!prefixlen_str) {
2246 log_link_debug(link, "Failed to parse route %s", route_str);
2247 continue;
2248 }
2249
2250 *prefixlen_str ++ = '\0';
2251
2252 r = sscanf(prefixlen_str, "%hhu/%hhu/%"SCNu32"/%hhu/"USEC_FMT, &prefixlen, &tos, &priority, &table, &lifetime);
2253 if (r != 5) {
2254 log_link_debug(link,
2255 "Failed to parse destination prefix length, tos, priority, table or expiration %s",
2256 prefixlen_str);
2257 continue;
2258 }
2259
2260 r = in_addr_from_string_auto(route_str, &family, &route_dst);
2261 if (r < 0) {
2262 log_link_debug_errno(link, r, "Failed to parse route destination %s: %m", route_str);
2263 continue;
2264 }
2265
2266 r = route_add(link, family, &route_dst, prefixlen, tos, priority, table, &route);
2267 if (r < 0)
2268 return log_link_error_errno(link, r, "Failed to add route: %m");
2269
2270 if (lifetime != USEC_INFINITY) {
2271 r = sd_event_add_time(link->manager->event, &expire, clock_boottime_or_monotonic(), lifetime,
2272 0, route_expire_handler, route);
2273 if (r < 0)
2274 log_link_warning_errno(link, r, "Could not arm route expiration handler: %m");
2275 }
2276
2277 route->lifetime = lifetime;
2278 sd_event_source_unref(route->expire);
2279 route->expire = expire;
2280 expire = NULL;
2281 }
2282 }
2283
2284 if (dhcp4_address) {
2285 r = in_addr_from_string(AF_INET, dhcp4_address, &address);
2286 if (r < 0) {
2287 log_link_debug_errno(link, r, "Falied to parse DHCPv4 address %s: %m", dhcp4_address);
2288 goto dhcp4_address_fail;
2289 }
2290
2291 r = sd_dhcp_client_new(&link->dhcp_client);
2292 if (r < 0)
2293 return log_link_error_errno(link, r, "Falied to create DHCPv4 client: %m");
2294
2295 r = sd_dhcp_client_set_request_address(link->dhcp_client, &address.in);
2296 if (r < 0)
2297 return log_link_error_errno(link, r, "Falied to set inital DHCPv4 address %s: %m", dhcp4_address);
2298 }
2299
2300 dhcp4_address_fail:
2301
2302 if (ipv4ll_address) {
2303 r = in_addr_from_string(AF_INET, ipv4ll_address, &address);
2304 if (r < 0) {
2305 log_link_debug_errno(link, r, "Falied to parse IPv4LL address %s: %m", ipv4ll_address);
2306 goto ipv4ll_address_fail;
2307 }
2308
2309 r = sd_ipv4ll_new(&link->ipv4ll);
2310 if (r < 0)
2311 return log_link_error_errno(link, r, "Falied to create IPv4LL client: %m");
2312
2313 r = sd_ipv4ll_set_address(link->ipv4ll, &address.in);
2314 if (r < 0)
2315 return log_link_error_errno(link, r, "Falied to set inital IPv4LL address %s: %m", ipv4ll_address);
2316 }
2317
2318 ipv4ll_address_fail:
2319
2320 return 0;
2321 }
2322
2323 int link_add(Manager *m, sd_netlink_message *message, Link **ret) {
2324 Link *link;
2325 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2326 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2327 int r;
2328
2329 assert(m);
2330 assert(m->rtnl);
2331 assert(message);
2332 assert(ret);
2333
2334 r = link_new(m, message, ret);
2335 if (r < 0)
2336 return r;
2337
2338 link = *ret;
2339
2340 log_link_debug(link, "Link %d added", link->ifindex);
2341
2342 r = link_load(link);
2343 if (r < 0)
2344 return r;
2345
2346 if (detect_container() <= 0) {
2347 /* not in a container, udev will be around */
2348 sprintf(ifindex_str, "n%d", link->ifindex);
2349 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2350 if (!device) {
2351 r = log_link_warning_errno(link, errno, "Could not find udev device: %m");
2352 goto failed;
2353 }
2354
2355 if (udev_device_get_is_initialized(device) <= 0) {
2356 /* not yet ready */
2357 log_link_debug(link, "link pending udev initialization...");
2358 return 0;
2359 }
2360
2361 r = link_initialized(link, device);
2362 if (r < 0)
2363 goto failed;
2364 } else {
2365 /* we are calling a callback directly, so must take a ref */
2366 link_ref(link);
2367
2368 r = link_initialized_and_synced(m->rtnl, NULL, link);
2369 if (r < 0)
2370 goto failed;
2371 }
2372
2373 return 0;
2374 failed:
2375 link_enter_failed(link);
2376 return r;
2377 }
2378
2379 static int link_carrier_gained(Link *link) {
2380 int r;
2381
2382 assert(link);
2383
2384 if (link->network) {
2385 r = link_acquire_conf(link);
2386 if (r < 0) {
2387 link_enter_failed(link);
2388 return r;
2389 }
2390 }
2391
2392 r = link_handle_bound_by_list(link);
2393 if (r < 0)
2394 return r;
2395
2396 return 0;
2397 }
2398
2399 static int link_carrier_lost(Link *link) {
2400 int r;
2401
2402 assert(link);
2403
2404 r = link_stop_clients(link);
2405 if (r < 0) {
2406 link_enter_failed(link);
2407 return r;
2408 }
2409
2410 r = link_handle_bound_by_list(link);
2411 if (r < 0)
2412 return r;
2413
2414 return 0;
2415 }
2416
2417 int link_carrier_reset(Link *link) {
2418 int r;
2419
2420 assert(link);
2421
2422 if (link_has_carrier(link)) {
2423 r = link_carrier_lost(link);
2424 if (r < 0)
2425 return r;
2426
2427 r = link_carrier_gained(link);
2428 if (r < 0)
2429 return r;
2430
2431 log_link_info(link, "Reset carrier");
2432 }
2433
2434 return 0;
2435 }
2436
2437
2438 int link_update(Link *link, sd_netlink_message *m) {
2439 struct ether_addr mac;
2440 const char *ifname;
2441 uint32_t mtu;
2442 bool had_carrier, carrier_gained, carrier_lost;
2443 int r;
2444
2445 assert(link);
2446 assert(link->ifname);
2447 assert(m);
2448
2449 if (link->state == LINK_STATE_LINGER) {
2450 link_ref(link);
2451 log_link_info(link, "Link readded");
2452 link_set_state(link, LINK_STATE_ENSLAVING);
2453
2454 r = link_new_carrier_maps(link);
2455 if (r < 0)
2456 return r;
2457 }
2458
2459 r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
2460 if (r >= 0 && !streq(ifname, link->ifname)) {
2461 log_link_info(link, "Renamed to %s", ifname);
2462
2463 link_free_carrier_maps(link);
2464
2465 r = free_and_strdup(&link->ifname, ifname);
2466 if (r < 0)
2467 return r;
2468
2469 r = link_new_carrier_maps(link);
2470 if (r < 0)
2471 return r;
2472 }
2473
2474 r = sd_netlink_message_read_u32(m, IFLA_MTU, &mtu);
2475 if (r >= 0 && mtu > 0) {
2476 link->mtu = mtu;
2477 if (!link->original_mtu) {
2478 link->original_mtu = mtu;
2479 log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
2480 }
2481
2482 if (link->dhcp_client) {
2483 r = sd_dhcp_client_set_mtu(link->dhcp_client,
2484 link->mtu);
2485 if (r < 0) {
2486 log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
2487 return r;
2488 }
2489 }
2490 }
2491
2492 /* The kernel may broadcast NEWLINK messages without the MAC address
2493 set, simply ignore them. */
2494 r = sd_netlink_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2495 if (r >= 0) {
2496 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
2497 ETH_ALEN)) {
2498
2499 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
2500 ETH_ALEN);
2501
2502 log_link_debug(link, "MAC address: "
2503 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2504 mac.ether_addr_octet[0],
2505 mac.ether_addr_octet[1],
2506 mac.ether_addr_octet[2],
2507 mac.ether_addr_octet[3],
2508 mac.ether_addr_octet[4],
2509 mac.ether_addr_octet[5]);
2510
2511 if (link->ipv4ll) {
2512 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2513 if (r < 0)
2514 return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
2515 }
2516
2517 if (link->dhcp_client) {
2518 r = sd_dhcp_client_set_mac(link->dhcp_client,
2519 (const uint8_t *) &link->mac,
2520 sizeof (link->mac),
2521 ARPHRD_ETHER);
2522 if (r < 0)
2523 return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
2524 }
2525
2526 if (link->dhcp6_client) {
2527 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2528 (const uint8_t *) &link->mac,
2529 sizeof (link->mac),
2530 ARPHRD_ETHER);
2531 if (r < 0)
2532 return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
2533 }
2534 }
2535 }
2536
2537 had_carrier = link_has_carrier(link);
2538
2539 r = link_update_flags(link, m);
2540 if (r < 0)
2541 return r;
2542
2543 carrier_gained = !had_carrier && link_has_carrier(link);
2544 carrier_lost = had_carrier && !link_has_carrier(link);
2545
2546 if (carrier_gained) {
2547 log_link_info(link, "Gained carrier");
2548
2549 r = link_carrier_gained(link);
2550 if (r < 0)
2551 return r;
2552 } else if (carrier_lost) {
2553 log_link_info(link, "Lost carrier");
2554
2555 r = link_carrier_lost(link);
2556 if (r < 0)
2557 return r;
2558
2559 }
2560
2561 return 0;
2562 }
2563
2564 int link_save(Link *link) {
2565 _cleanup_free_ char *temp_path = NULL;
2566 _cleanup_fclose_ FILE *f = NULL;
2567 const char *admin_state, *oper_state;
2568 Address *a;
2569 Route *route;
2570 Iterator i;
2571 int r;
2572
2573 assert(link);
2574 assert(link->state_file);
2575 assert(link->lease_file);
2576 assert(link->manager);
2577
2578 if (link->state == LINK_STATE_LINGER) {
2579 unlink(link->state_file);
2580 return 0;
2581 }
2582
2583 admin_state = link_state_to_string(link->state);
2584 assert(admin_state);
2585
2586 oper_state = link_operstate_to_string(link->operstate);
2587 assert(oper_state);
2588
2589 r = fopen_temporary(link->state_file, &f, &temp_path);
2590 if (r < 0)
2591 goto fail;
2592
2593 fchmod(fileno(f), 0644);
2594
2595 fprintf(f,
2596 "# This is private data. Do not parse.\n"
2597 "ADMIN_STATE=%s\n"
2598 "OPER_STATE=%s\n",
2599 admin_state, oper_state);
2600
2601 if (link->network) {
2602 char **address, **domain;
2603 bool space;
2604 sd_dhcp6_lease *dhcp6_lease = NULL;
2605
2606 if (link->dhcp6_client) {
2607 r = sd_dhcp6_client_get_lease(link->dhcp6_client,
2608 &dhcp6_lease);
2609 if (r < 0)
2610 log_link_debug(link, "No DHCPv6 lease");
2611 }
2612
2613 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
2614
2615 fputs("DNS=", f);
2616 space = false;
2617 STRV_FOREACH(address, link->network->dns) {
2618 if (space)
2619 fputc(' ', f);
2620 fputs(*address, f);
2621 space = true;
2622 }
2623
2624 if (link->network->dhcp_dns &&
2625 link->dhcp_lease) {
2626 const struct in_addr *addresses;
2627
2628 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2629 if (r > 0) {
2630 if (space)
2631 fputc(' ', f);
2632 serialize_in_addrs(f, addresses, r);
2633 space = true;
2634 }
2635 }
2636
2637 if (link->network->dhcp_dns && dhcp6_lease) {
2638 struct in6_addr *in6_addrs;
2639
2640 r = sd_dhcp6_lease_get_dns(dhcp6_lease, &in6_addrs);
2641 if (r > 0) {
2642 if (space)
2643 fputc(' ', f);
2644 serialize_in6_addrs(f, in6_addrs, r);
2645 }
2646 }
2647
2648 fputc('\n', f);
2649
2650 fputs("NTP=", f);
2651 space = false;
2652 STRV_FOREACH(address, link->network->ntp) {
2653 if (space)
2654 fputc(' ', f);
2655 fputs(*address, f);
2656 space = true;
2657 }
2658
2659 if (link->network->dhcp_ntp &&
2660 link->dhcp_lease) {
2661 const struct in_addr *addresses;
2662
2663 r = sd_dhcp_lease_get_ntp(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_ntp && dhcp6_lease) {
2673 struct in6_addr *in6_addrs;
2674 char **hosts;
2675 char **hostname;
2676
2677 r = sd_dhcp6_lease_get_ntp_addrs(dhcp6_lease,
2678 &in6_addrs);
2679 if (r > 0) {
2680 if (space)
2681 fputc(' ', f);
2682 serialize_in6_addrs(f, in6_addrs, r);
2683 space = true;
2684 }
2685
2686 r = sd_dhcp6_lease_get_ntp_fqdn(dhcp6_lease, &hosts);
2687 if (r > 0) {
2688 STRV_FOREACH(hostname, hosts) {
2689 if (space)
2690 fputc(' ', f);
2691 fputs(*hostname, f);
2692 space = true;
2693 }
2694 }
2695 }
2696
2697 fputc('\n', f);
2698
2699 fputs("DOMAINS=", f);
2700 space = false;
2701 STRV_FOREACH(domain, link->network->domains) {
2702 if (space)
2703 fputc(' ', f);
2704 fputs(*domain, f);
2705 space = true;
2706 }
2707
2708 if (link->network->dhcp_domains &&
2709 link->dhcp_lease) {
2710 const char *domainname;
2711
2712 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
2713 if (r >= 0) {
2714 if (space)
2715 fputc(' ', f);
2716 fputs(domainname, f);
2717 space = true;
2718 }
2719 }
2720
2721 if (link->network->dhcp_domains && dhcp6_lease) {
2722 char **domains;
2723
2724 r = sd_dhcp6_lease_get_domains(dhcp6_lease, &domains);
2725 if (r >= 0) {
2726 STRV_FOREACH(domain, domains) {
2727 if (space)
2728 fputc(' ', f);
2729 fputs(*domain, f);
2730 space = true;
2731 }
2732 }
2733 }
2734
2735 fputc('\n', f);
2736
2737 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2738 yes_no(link->network->wildcard_domain));
2739
2740 fprintf(f, "LLMNR=%s\n",
2741 resolve_support_to_string(link->network->llmnr));
2742
2743 fputs("ADDRESSES=", f);
2744 space = false;
2745 SET_FOREACH(a, link->addresses, i) {
2746 _cleanup_free_ char *address_str = NULL;
2747
2748 r = in_addr_to_string(a->family, &a->in_addr, &address_str);
2749 if (r < 0)
2750 goto fail;
2751
2752 fprintf(f, "%s%s/%u", space ? " " : "", address_str, a->prefixlen);
2753 space = true;
2754 }
2755
2756 fputc('\n', f);
2757
2758 fputs("ROUTES=", f);
2759 space = false;
2760 SET_FOREACH(route, link->routes, i) {
2761 _cleanup_free_ char *route_str = NULL;
2762
2763 r = in_addr_to_string(route->family, &route->dst, &route_str);
2764 if (r < 0)
2765 goto fail;
2766
2767 fprintf(f, "%s%s/%hhu/%hhu/%"PRIu32"/%hhu/"USEC_FMT, space ? " " : "", route_str,
2768 route->dst_prefixlen, route->tos, route->priority, route->table, route->lifetime);
2769 space = true;
2770 }
2771
2772 fputc('\n', f);
2773 }
2774
2775 if (!hashmap_isempty(link->bound_to_links)) {
2776 Link *carrier;
2777 bool space = false;
2778
2779 fputs("CARRIER_BOUND_TO=", f);
2780 HASHMAP_FOREACH(carrier, link->bound_to_links, i) {
2781 if (space)
2782 fputc(' ', f);
2783 fputs(carrier->ifname, f);
2784 space = true;
2785 }
2786
2787 fputc('\n', f);
2788 }
2789
2790 if (!hashmap_isempty(link->bound_by_links)) {
2791 Link *carrier;
2792 bool space = false;
2793
2794 fputs("CARRIER_BOUND_BY=", f);
2795 HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
2796 if (space)
2797 fputc(' ', f);
2798 fputs(carrier->ifname, f);
2799 space = true;
2800 }
2801
2802 fputc('\n', f);
2803 }
2804
2805 if (link->dhcp_lease) {
2806 struct in_addr address;
2807 const char *tz = NULL;
2808
2809 assert(link->network);
2810
2811 r = sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
2812 if (r >= 0)
2813 fprintf(f, "TIMEZONE=%s\n", tz);
2814
2815 r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
2816 if (r >= 0) {
2817 fputs("DHCP4_ADDRESS=", f);
2818 serialize_in_addrs(f, &address, 1);
2819 fputc('\n', f);
2820 }
2821
2822 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2823 if (r < 0)
2824 goto fail;
2825
2826 fprintf(f,
2827 "DHCP_LEASE=%s\n",
2828 link->lease_file);
2829 } else
2830 unlink(link->lease_file);
2831
2832 if (link->ipv4ll) {
2833 struct in_addr address;
2834
2835 r = sd_ipv4ll_get_address(link->ipv4ll, &address);
2836 if (r >= 0) {
2837 fputs("IPV4LL_ADDRESS=", f);
2838 serialize_in_addrs(f, &address, 1);
2839 fputc('\n', f);
2840 }
2841 }
2842
2843 if (link->lldp) {
2844 assert(link->network);
2845
2846 r = sd_lldp_save(link->lldp, link->lldp_file);
2847 if (r < 0)
2848 goto fail;
2849
2850 fprintf(f,
2851 "LLDP_FILE=%s\n",
2852 link->lldp_file);
2853 } else
2854 unlink(link->lldp_file);
2855
2856 r = fflush_and_check(f);
2857 if (r < 0)
2858 goto fail;
2859
2860 if (rename(temp_path, link->state_file) < 0) {
2861 r = -errno;
2862 goto fail;
2863 }
2864
2865 return 0;
2866
2867 fail:
2868 (void) unlink(link->state_file);
2869 if (temp_path)
2870 (void) unlink(temp_path);
2871
2872 return log_link_error_errno(link, r, "Failed to save link data to %s: %m", link->state_file);
2873 }
2874
2875 /* The serialized state in /run is no longer up-to-date. */
2876 void link_dirty(Link *link) {
2877 int r;
2878
2879 assert(link);
2880
2881 r = set_ensure_allocated(&link->manager->dirty_links, NULL);
2882 if (r < 0)
2883 /* allocation errors are ignored */
2884 return;
2885
2886 r = set_put(link->manager->dirty_links, link);
2887 if (r < 0)
2888 /* allocation errors are ignored */
2889 return;
2890
2891 link_ref(link);
2892 }
2893
2894 /* The serialized state in /run is up-to-date */
2895 void link_clean(Link *link) {
2896 assert(link);
2897 assert(link->manager);
2898
2899 set_remove(link->manager->dirty_links, link);
2900 link_unref(link);
2901 }
2902
2903 static const char* const link_state_table[_LINK_STATE_MAX] = {
2904 [LINK_STATE_PENDING] = "pending",
2905 [LINK_STATE_ENSLAVING] = "configuring",
2906 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2907 [LINK_STATE_SETTING_ROUTES] = "configuring",
2908 [LINK_STATE_CONFIGURED] = "configured",
2909 [LINK_STATE_UNMANAGED] = "unmanaged",
2910 [LINK_STATE_FAILED] = "failed",
2911 [LINK_STATE_LINGER] = "linger",
2912 };
2913
2914 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2915
2916 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2917 [LINK_OPERSTATE_OFF] = "off",
2918 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2919 [LINK_OPERSTATE_DORMANT] = "dormant",
2920 [LINK_OPERSTATE_CARRIER] = "carrier",
2921 [LINK_OPERSTATE_DEGRADED] = "degraded",
2922 [LINK_OPERSTATE_ROUTABLE] = "routable",
2923 };
2924
2925 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
Unnamed repository; edit this file 'description' to name the repository.