]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/network/networkd-link.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
network: make link enter failed state when link_initialized() is failed
[thirdparty/systemd.git] / src / network / networkd-link.c
CommitLineData
db9ecf05 1/* SPDX-License-Identifier: LGPL-2.1-or-later */
f579559b 2
9aa5d8ba 3#include <netinet/in.h>
f579559b 4#include <linux/if.h>
8f815e8b 5#include <linux/if_arp.h>
518cd6b5 6#include <linux/if_link.h>
8430841b 7#include <sys/socket.h>
4cc7a82c 8#include <unistd.h>
f579559b 9
b5efdb8a 10#include "alloc-util.h"
c0267a59 11#include "batadv.h"
737f1405
YW		 12#include "bond.h"
13#include "bridge.h"
1346b1f0 14#include "bus-util.h"
3be9d62a
YW		 15#include "device-private.h"
16#include "device-util.h"
27dfc982 17#include "dhcp-identifier.h"
bd91b83e 18#include "dhcp-lease-internal.h"
686d13b9 19#include "env-file.h"
4bb7cc82 20#include "ethtool-util.h"
3ffd4af2 21#include "fd-util.h"
cf1d700d 22#include "fileio.h"
af664001 23#include "fs-util.h"
737f1405 24#include "ipvlan.h"
ef118d00 25#include "missing_network.h"
cf1d700d 26#include "netlink-util.h"
c6f7c917 27#include "network-internal.h"
fb486c90 28#include "networkd-address-label.h"
093e3533 29#include "networkd-address.h"
9671ae9d 30#include "networkd-bridge-fdb.h"
ff9e0783 31#include "networkd-bridge-mdb.h"
3ddcbeea 32#include "networkd-can.h"
8fcf1d61 33#include "networkd-dhcp-server.h"
ca5ad760
YW		 34#include "networkd-dhcp4.h"
35#include "networkd-dhcp6.h"
36#include "networkd-ipv4ll.h"
76c5a0f2 37#include "networkd-ipv6-proxy-ndp.h"
6a1af3d4
YW		 38#include "networkd-link-bus.h"
39#include "networkd-link.h"
8e1ad1ea 40#include "networkd-lldp-tx.h"
23f53b99 41#include "networkd-manager.h"
1e7a0e21 42#include "networkd-ndisc.h"
e4a71bf3 43#include "networkd-neighbor.h"
75156ccb 44#include "networkd-nexthop.h"
19d9a5ad 45#include "networkd-queue.h"
7465dd22 46#include "networkd-radv.h"
bce67bbe 47#include "networkd-routing-policy-rule.h"
0fa8ee6c 48#include "networkd-setlink.h"
19d9a5ad 49#include "networkd-sriov.h"
3b5a4fc6 50#include "networkd-state-file.h"
19d9a5ad 51#include "networkd-sysctl.h"
8d968fdd 52#include "networkd-wifi.h"
cf1d700d
TG		 53#include "set.h"
54#include "socket-util.h"
bf331d87 55#include "stat-util.h"
15a5e950 56#include "stdio-util.h"
8b43440b 57#include "string-table.h"
51517f9e 58#include "strv.h"
34658df2 59#include "tc.h"
e4de7287 60#include "tmpfile-util.h"
299ad32d 61#include "udev-util.h"
cf1d700d 62#include "util.h"
737f1405 63#include "vrf.h"
fc2f9534 64
3ca1fab7 65bool link_ipv4ll_enabled(Link *link) {
b9d74c40
LP		 66 assert(link);
67
78c958f8
TG		 68 if (link->flags & IFF_LOOPBACK)
69 return false;
70
71 if (!link->network)
72 return false;
73
500b96eb 74 if (link->iftype == ARPHRD_CAN)
c6ac3729
YW		 75 return false;
76
98d20a17 77 if (STRPTR_IN_SET(link->kind,
78 "vrf", "wireguard", "ipip", "gre", "ip6gre","ip6tnl", "sit", "vti",
b0486c73 79 "vti6", "nlmon", "xfrm", "bareudp"))
a8f5bba6
JD		 80 return false;
81
f410d463
YW		 82 /* L3 or L3S mode do not support ARP. */
83 if (IN_SET(link_get_ipvlan_mode(link), NETDEV_IPVLAN_MODE_L3, NETDEV_IPVLAN_MODE_L3S))
84 return false;
85
f2bfcdb9
YW		 86 if (link->network->bond)
87 return false;
88
3ca1fab7 89 return link->network->link_local & ADDRESS_FAMILY_IPV4;
8bc17bb3
SS		 90}
91
f8f2f880 92bool link_ipv6ll_enabled(Link *link) {
b9d74c40
LP		 93 assert(link);
94
fa709992
LP		 95 if (!socket_ipv6_is_supported())
96 return false;
97
d0d6a4cd
TG		 98 if (link->flags & IFF_LOOPBACK)
99 return false;
100
101 if (!link->network)
102 return false;
103
500b96eb 104 if (link->iftype == ARPHRD_CAN)
c6ac3729
YW		 105 return false;
106
107 if (STRPTR_IN_SET(link->kind, "vrf", "wireguard", "ipip", "gre", "sit", "vti", "nlmon"))
a8f5bba6
JD		 108 return false;
109
f2bfcdb9
YW		 110 if (link->network->bond)
111 return false;
112
e0ee46f2 113 return link->network->link_local & ADDRESS_FAMILY_IPV6;
78c958f8
TG		 114}
115
5e0534f1 116bool link_ipv6_enabled(Link *link) {
439689c6
SS		 117 assert(link);
118
119 if (!socket_ipv6_is_supported())
120 return false;
121
b102cdca 122 if (link->network->bond)
2b00a4e0
TY		 123 return false;
124
500b96eb 125 if (link->iftype == ARPHRD_CAN)
af9ba57a
YW		 126 return false;
127
4cef7fe3 128 /* DHCPv6 client will not be started if no IPv6 link-local address is configured. */
adfeee49
YW		 129 if (link_ipv6ll_enabled(link))
130 return true;
131
132 if (network_has_static_ipv6_configurations(link->network))
133 return true;
134
135 return false;
439689c6
SS		 136}
137
7191a57a
YW		 138bool link_is_ready_to_configure(Link *link, bool allow_unmanaged) {
139 assert(link);
140
8e4b1b35 141 if (!link->network) {
7191a57a
YW		 142 if (!allow_unmanaged)
143 return false;
144
145 return link_has_carrier(link);
146 }
147
148 if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
149 return false;
150
151 if (!link_has_carrier(link) && !link->network->configure_without_carrier)
152 return false;
153
0fa8ee6c
YW		 154 if (link->set_link_messages > 0)
155 return false;
156
71a754f7
YW		 157 /* TODO: enable this check when link_request_to_create_stacked_netdev() is used.
158 if (!link->stacked_netdevs_created)
159 return false;
160 */
161
7191a57a
YW		 162 return true;
163}
164
15761549
YW		 165void link_ntp_settings_clear(Link *link) {
166 link->ntp = strv_free(link->ntp);
167}
168
169void link_dns_settings_clear(Link *link) {
f5fbe71d 170 if (link->n_dns != UINT_MAX)
e77bd3fd
YW		 171 for (unsigned i = 0; i < link->n_dns; i++)
172 in_addr_full_free(link->dns[i]);
15761549 173 link->dns = mfree(link->dns);
f5fbe71d 174 link->n_dns = UINT_MAX;
15761549 175
6e4571f0
YW		 176 link->search_domains = ordered_set_free(link->search_domains);
177 link->route_domains = ordered_set_free(link->route_domains);
15761549
YW		 178
179 link->dns_default_route = -1;
180 link->llmnr = _RESOLVE_SUPPORT_INVALID;
181 link->mdns = _RESOLVE_SUPPORT_INVALID;
182 link->dnssec_mode = _DNSSEC_MODE_INVALID;
183 link->dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID;
184
185 link->dnssec_negative_trust_anchors = set_free_free(link->dnssec_negative_trust_anchors);
186}
187
1a6bb31f
YW		 188static void link_free_engines(Link *link) {
189 if (!link)
190 return;
191
192 link->dhcp_server = sd_dhcp_server_unref(link->dhcp_server);
193 link->dhcp_client = sd_dhcp_client_unref(link->dhcp_client);
194 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1c494872 195 link->dhcp_acd = sd_ipv4acd_unref(link->dhcp_acd);
1a6bb31f
YW		 196
197 link->lldp = sd_lldp_unref(link->lldp);
1c494872 198 link_lldp_emit_stop(link);
1a6bb31f
YW		 199
200 ndisc_flush(link);
201
202 link->ipv4ll = sd_ipv4ll_unref(link->ipv4ll);
203 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1633c457 204 link->dhcp6_lease = sd_dhcp6_lease_unref(link->dhcp6_lease);
1a6bb31f
YW		 205 link->ndisc = sd_ndisc_unref(link->ndisc);
206 link->radv = sd_radv_unref(link->radv);
7abe175c
YW		 207
208 ipv4_dad_unref(link);
1a6bb31f
YW		 209}
210
8301aa0b 211static Link *link_free(Link *link) {
8301aa0b 212 assert(link);
f579559b 213
15761549
YW		 214 link_ntp_settings_clear(link);
215 link_dns_settings_clear(link);
216
8eec0b9d
YW		 217 link->routes = set_free(link->routes);
218 link->routes_foreign = set_free(link->routes_foreign);
6e537f62
YW		 219 link->dhcp_routes = set_free(link->dhcp_routes);
220 link->dhcp_routes_old = set_free(link->dhcp_routes_old);
1633c457
YW		 221 link->dhcp6_routes = set_free(link->dhcp6_routes);
222 link->dhcp6_routes_old = set_free(link->dhcp6_routes_old);
223 link->dhcp6_pd_routes = set_free(link->dhcp6_pd_routes);
224 link->dhcp6_pd_routes_old = set_free(link->dhcp6_pd_routes_old);
69203fba 225 link->ndisc_routes = set_free(link->ndisc_routes);
adda1ed9 226
8eec0b9d
YW		 227 link->nexthops = set_free(link->nexthops);
228 link->nexthops_foreign = set_free(link->nexthops_foreign);
c16c7808 229
8eec0b9d
YW		 230 link->neighbors = set_free(link->neighbors);
231 link->neighbors_foreign = set_free(link->neighbors_foreign);
d1bdafd2 232
8eec0b9d
YW		 233 link->addresses = set_free(link->addresses);
234 link->addresses_foreign = set_free(link->addresses_foreign);
aa651e88 235 link->pool_addresses = set_free(link->pool_addresses);
e5526518 236 link->static_addresses = set_free(link->static_addresses);
1633c457
YW		 237 link->dhcp6_addresses = set_free(link->dhcp6_addresses);
238 link->dhcp6_addresses_old = set_free(link->dhcp6_addresses_old);
239 link->dhcp6_pd_addresses = set_free(link->dhcp6_pd_addresses);
240 link->dhcp6_pd_addresses_old = set_free(link->dhcp6_pd_addresses_old);
69203fba 241 link->ndisc_addresses = set_free(link->ndisc_addresses);
adda1ed9 242
4b409e85
YW		 243 link->dhcp6_pd_prefixes = set_free(link->dhcp6_pd_prefixes);
244
1a6bb31f 245 link_free_engines(link);
49699bac 246
c166a070 247 free(link->ifname);
572b21d9 248 strv_free(link->alternative_names);
ceac4078 249 free(link->kind);
8d968fdd 250 free(link->ssid);
c643bda5 251 free(link->driver);
6cad256d 252
a34e58d4
YW		 253 unlink_and_free(link->lease_file);
254 unlink_and_free(link->lldp_file);
255 unlink_and_free(link->state_file);
c166a070 256
51517f9e 257 sd_device_unref(link->sd_device);
b5db00e5 258
0d4ad91d 259 hashmap_free(link->bound_to_links);
0d4ad91d
AR		 260 hashmap_free(link->bound_by_links);
261
5f707e12 262 set_free_with_destructor(link->slaves, link_unref);
033295c1 263
c9c908a6
YW		 264 network_unref(link->network);
265
8301aa0b 266 return mfree(link);
14b746f7
TG		 267}
268
8301aa0b 269DEFINE_TRIVIAL_REF_UNREF_FUNC(Link, link, link_free);
14b746f7 270
11a7f229
TG		 271int link_get(Manager *m, int ifindex, Link **ret) {
272 Link *link;
11a7f229
TG		 273
274 assert(m);
e856ed00 275 assert(ifindex > 0);
11a7f229 276
ae06ab10 277 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
11a7f229
TG		 278 if (!link)
279 return -ENODEV;
280
0b54c870
YW		 281 if (ret)
282 *ret = link;
283 return 0;
284}
285
286int link_get_by_name(Manager *m, const char *ifname, Link **ret) {
287 Link *link;
288
289 assert(m);
290 assert(ifname);
11a7f229 291
0b54c870
YW		 292 link = hashmap_get(m->links_by_name, ifname);
293 if (!link)
294 return -ENODEV;
295
296 if (ret)
297 *ret = link;
11a7f229
TG		 298 return 0;
299}
300
81357285
YW		 301int link_get_master(Link *link, Link **ret) {
302 assert(link);
303 assert(link->manager);
304 assert(ret);
305
306 if (link->master_ifindex <= 0 || link->master_ifindex == link->ifindex)
307 return -ENODEV;
308
309 return link_get(link->manager, link->master_ifindex, ret);
310}
311
af9ba57a 312void link_set_state(Link *link, LinkState state) {
e331e246
TG		 313 assert(link);
314
315 if (link->state == state)
316 return;
317
0beb9542
YW		 318 log_link_debug(link, "State changed: %s -> %s",
319 link_state_to_string(link->state),
320 link_state_to_string(state));
321
e331e246
TG		 322 link->state = state;
323
324 link_send_changed(link, "AdministrativeState", NULL);
9092113d 325 link_dirty(link);
e331e246
TG		 326}
327
57bd6899
TG		 328static void link_enter_unmanaged(Link *link) {
329 assert(link);
330
e331e246 331 link_set_state(link, LINK_STATE_UNMANAGED);
57bd6899
TG		 332}
333
2a99eed0 334int link_stop_engines(Link *link, bool may_keep_dhcp) {
111bb8f9
TG		 335 int r = 0, k;
336
337 assert(link);
338 assert(link->manager);
339 assert(link->manager->event);
340
80060352
ZJS		 341 bool keep_dhcp = may_keep_dhcp &&
342 link->network &&
343 (link->manager->restarting ||
344 FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP_ON_STOP));
345
84add3cd 346 if (!keep_dhcp) {
111bb8f9 347 k = sd_dhcp_client_stop(link->dhcp_client);
6a7a4e4d 348 if (k < 0)
36c7d709 349 r = log_link_warning_errno(link, k, "Could not stop DHCPv4 client: %m");
111bb8f9
TG		 350 }
351
84add3cd
YW		 352 k = sd_ipv4acd_stop(link->dhcp_acd);
353 if (k < 0)
354 r = log_link_warning_errno(link, k, "Could not stop IPv4 ACD client for DHCPv4: %m");
a7df5cae 355
2a99eed0
YW		 356 k = sd_dhcp_server_stop(link->dhcp_server);
357 if (k < 0)
358 r = log_link_warning_errno(link, k, "Could not stop DHCPv4 server: %m");
359
9cc65242
YW		 360 k = sd_lldp_stop(link->lldp);
361 if (k < 0)
362 r = log_link_warning_errno(link, k, "Could not stop LLDP: %m");
363
84add3cd
YW		 364 k = sd_ipv4ll_stop(link->ipv4ll);
365 if (k < 0)
366 r = log_link_warning_errno(link, k, "Could not stop IPv4 link-local: %m");
dd43110f 367
490ccbd5 368 k = ipv4_dad_stop(link);
2488e4d9
YW		 369 if (k < 0)
370 r = log_link_warning_errno(link, k, "Could not stop IPv4 ACD client: %m");
051e77ca 371
84add3cd
YW		 372 k = sd_dhcp6_client_stop(link->dhcp6_client);
373 if (k < 0)
374 r = log_link_warning_errno(link, k, "Could not stop DHCPv6 client: %m");
4138fb2c 375
2ffd6d73
YW		 376 k = dhcp6_pd_remove(link);
377 if (k < 0)
378 r = log_link_warning_errno(link, k, "Could not remove DHCPv6 PD addresses and routes: %m");
1633c457 379
84add3cd
YW		 380 k = sd_ndisc_stop(link->ndisc);
381 if (k < 0)
382 r = log_link_warning_errno(link, k, "Could not stop IPv6 Router Discovery: %m");
4138fb2c 383
84add3cd
YW		 384 k = sd_radv_stop(link->radv);
385 if (k < 0)
386 r = log_link_warning_errno(link, k, "Could not stop IPv6 Router Advertisement: %m");
7465dd22 387
7272b25e 388 link_lldp_emit_stop(link);
111bb8f9
TG		 389 return r;
390}
391
b22d8a00 392void link_enter_failed(Link *link) {
ef1ba606 393 assert(link);
f882c247 394
370e9930 395 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
2139694e
TG		 396 return;
397
6a7a4e4d 398 log_link_warning(link, "Failed");
449f7554 399
e331e246 400 link_set_state(link, LINK_STATE_FAILED);
fe8db0c5 401
2a99eed0 402 (void) link_stop_engines(link, false);
f882c247
TG		 403}
404
7033af49
YW		 405static int link_join_netdevs_after_configured(Link *link) {
406 NetDev *netdev;
7033af49
YW		 407 int r;
408
90e74a66 409 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs) {
7033af49
YW		 410 if (netdev->ifindex > 0)
411 /* Assume already enslaved. */
412 continue;
413
414 if (netdev_get_create_type(netdev) != NETDEV_CREATE_AFTER_CONFIGURED)
415 continue;
416
417 log_struct(LOG_DEBUG,
418 LOG_LINK_INTERFACE(link),
419 LOG_NETDEV_INTERFACE(netdev),
420 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname));
421
422 r = netdev_join(netdev, link, NULL);
423 if (r < 0)
424 return log_struct_errno(LOG_WARNING, r,
425 LOG_LINK_INTERFACE(link),
426 LOG_NETDEV_INTERFACE(netdev),
427 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname));
428 }
429
430 return 0;
431}
432
e3a7b048 433static void link_enter_configured(Link *link) {
dd43110f
TG		 434 assert(link);
435 assert(link->network);
e3a7b048 436
289e6774 437 if (link->state != LINK_STATE_CONFIGURING)
e3a7b048 438 return;
dd43110f 439
e331e246 440 link_set_state(link, LINK_STATE_CONFIGURED);
dd43110f 441
7033af49 442 (void) link_join_netdevs_after_configured(link);
dd43110f
TG		 443}
444
6accfd31
DA		 445void link_check_ready(Link *link) {
446 Address *a;
6accfd31
DA		 447
448 assert(link);
449
5f58af25
YW		 450 if (link->state == LINK_STATE_CONFIGURED)
451 return;
452
d19b9939
YW		 453 if (link->state != LINK_STATE_CONFIGURING)
454 return (void) log_link_debug(link, "%s(): link is in %s state.", __func__, link_state_to_string(link->state));
6accfd31
DA		 455
456 if (!link->network)
457 return;
458
600b7898
YW		 459 if (link->iftype == ARPHRD_CAN) {
460 /* let's shortcut things for CAN which doesn't need most of checks below. */
461 if (!link->can_configured)
462 return (void) log_link_debug(link, "%s(): CAN device is not configured.", __func__);
463
464 link_enter_configured(link);
465 return;
466 }
467
76c5a0f2 468 if (!link->static_addresses_configured)
d19b9939 469 return (void) log_link_debug(link, "%s(): static addresses are not configured.", __func__);
6accfd31 470
90e74a66 471 SET_FOREACH(a, link->addresses)
39373cb9
YW		 472 if (!address_is_ready(a)) {
473 _cleanup_free_ char *str = NULL;
474
5380707a
YW		 475 (void) in_addr_prefix_to_string(a->family, &a->in_addr, a->prefixlen, &str);
476 return (void) log_link_debug(link, "%s(): an address %s is not ready.", __func__, strna(str));
39373cb9 477 }
6aa5773b 478
354bc760
YW		 479 if (!link->static_address_labels_configured)
480 return (void) log_link_debug(link, "%s(): static address labels are not configured.", __func__);
481
e5b35bf6
YW		 482 if (!link->static_bridge_fdb_configured)
483 return (void) log_link_debug(link, "%s(): static bridge MDB entries are not configured.", __func__);
484
ff9e0783
YW		 485 if (!link->static_bridge_mdb_configured)
486 return (void) log_link_debug(link, "%s(): static bridge MDB entries are not configured.", __func__);
487
fdeba3f5
YW		 488 if (!link->static_ipv6_proxy_ndp_configured)
489 return (void) log_link_debug(link, "%s(): static IPv6 proxy NDP addresses are not configured.", __func__);
490
40ca350e
YW		 491 if (!link->static_neighbors_configured)
492 return (void) log_link_debug(link, "%s(): static neighbors are not configured.", __func__);
493
d19b9939
YW		 494 if (!link->static_nexthops_configured)
495 return (void) log_link_debug(link, "%s(): static nexthops are not configured.", __func__);
c16c7808 496
76c5a0f2
YW		 497 if (!link->static_routes_configured)
498 return (void) log_link_debug(link, "%s(): static routes are not configured.", __func__);
499
0e5ef6be 500 if (!link->static_routing_policy_rules_configured)
d19b9939 501 return (void) log_link_debug(link, "%s(): static routing policy rules are not configured.", __func__);
6accfd31 502
d19b9939
YW		 503 if (!link->tc_configured)
504 return (void) log_link_debug(link, "%s(): traffic controls are not configured.", __func__);
4ecdcb07 505
d19b9939
YW		 506 if (!link->sr_iov_configured)
507 return (void) log_link_debug(link, "%s(): SR-IOV is not configured.", __func__);
518cd6b5 508
463797c1 509 if (link_has_carrier(link) || !link->network->configure_without_carrier) {
50550722
YW		 510 bool has_ndisc_address = false;
511 NDiscAddress *n;
6accfd31 512
94876904
YW		 513 if (link_ipv6ll_enabled(link) && !in6_addr_is_set(&link->ipv6ll_address))
514 return (void) log_link_debug(link, "%s(): IPv6LL is not configured yet.", __func__);
6accfd31 515
90e74a66 516 SET_FOREACH(n, link->ndisc_addresses)
50550722
YW		 517 if (!n->marked) {
518 has_ndisc_address = true;
519 break;
520 }
521
8cd37e43 522 if ((link_dhcp4_enabled(link) || link_dhcp6_with_address_enabled(link) || link_ipv4ll_enabled(link)) &&
50550722 523 !link->dhcp_address && set_isempty(link->dhcp6_addresses) && !has_ndisc_address &&
0d0799da
YW		 524 !link->ipv4ll_address_configured)
525 /* When DHCP[46] or IPv4LL is enabled, at least one address is acquired by them. */
526 return (void) log_link_debug(link, "%s(): DHCP4, DHCP6 or IPv4LL is enabled but no dynamic address is assigned yet.", __func__);
659ad3a0 527
0d0799da
YW		 528 if (link_dhcp4_enabled(link) || link_dhcp6_enabled(link) || link_dhcp6_pd_is_enabled(link) ||
529 link_ipv6_accept_ra_enabled(link) || link_ipv4ll_enabled(link)) {
39373cb9
YW		 530 if (!link->dhcp4_configured &&
531 !(link->dhcp6_address_configured && link->dhcp6_route_configured) &&
532 !(link->dhcp6_pd_address_configured && link->dhcp6_pd_route_configured) &&
d98c546d 533 !(link->ndisc_addresses_configured && link->ndisc_routes_configured) &&
0d0799da
YW		 534 !link->ipv4ll_address_configured)
535 /* When DHCP[46], NDisc, or IPv4LL is enabled, at least one protocol must be finished. */
d19b9939 536 return (void) log_link_debug(link, "%s(): dynamic addresses or routes are not configured.", __func__);
39373cb9 537
0d0799da 538 log_link_debug(link, "%s(): dhcp4:%s ipv4ll:%s dhcp6_addresses:%s dhcp_routes:%s dhcp_pd_addresses:%s dhcp_pd_routes:%s ndisc_addresses:%s ndisc_routes:%s",
39373cb9
YW		 539 __func__,
540 yes_no(link->dhcp4_configured),
0d0799da 541 yes_no(link->ipv4ll_address_configured),
39373cb9
YW		 542 yes_no(link->dhcp6_address_configured),
543 yes_no(link->dhcp6_route_configured),
544 yes_no(link->dhcp6_pd_address_configured),
545 yes_no(link->dhcp6_pd_route_configured),
d98c546d
YW		 546 yes_no(link->ndisc_addresses_configured),
547 yes_no(link->ndisc_routes_configured));
39373cb9 548 }
463797c1 549 }
6accfd31 550
5f58af25 551 link_enter_configured(link);
6accfd31
DA		 552}
553
97108953 554static int link_request_static_configs(Link *link) {
f882c247
TG		 555 int r;
556
557 assert(link);
558 assert(link->network);
f5be5601 559 assert(link->state != _LINK_STATE_INVALID);
f882c247 560
354bc760 561 r = link_request_static_addresses(link);
0e5ef6be
YW		 562 if (r < 0)
563 return r;
564
354bc760 565 r = link_request_static_address_labels(link);
f3ef324d
YW		 566 if (r < 0)
567 return r;
e4a71bf3 568
e5b35bf6
YW		 569 r = link_request_static_bridge_fdb(link);
570 if (r < 0)
571 return r;
572
9a038aac
YW		 573 r = link_request_static_bridge_mdb(link);
574 if (r < 0)
575 return r;
576
fdeba3f5
YW		 577 r = link_request_static_ipv6_proxy_ndp_addresses(link);
578 if (r < 0)
579 return r;
580
40ca350e 581 r = link_request_static_neighbors(link);
682c65b0
YW		 582 if (r < 0)
583 return r;
bd6379ec 584
76c5a0f2 585 r = link_request_static_nexthops(link, false);
fe2bc17c
YW		 586 if (r < 0)
587 return r;
f882c247 588
76c5a0f2
YW		 589 r = link_request_static_routes(link, false);
590 if (r < 0)
591 return r;
592
593 r = link_request_static_routing_policy_rules(link);
5ae0fb7f
YW		 594 if (r < 0)
595 return r;
d4cdbea5 596
f882c247
TG		 597 return 0;
598}
599
e16e4b3b
DS		 600static int link_nomaster_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
601 int r;
602
603 assert(link);
604
605 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
606 return 1;
607
608 r = sd_netlink_message_get_errno(m);
609 if (r < 0)
610 log_link_message_warning_errno(link, m, r, "Could not set nomaster, ignoring");
611 else
612 log_link_debug(link, "Setting nomaster done.");
613
614 return 1;
615}
616
617static int link_set_nomaster(Link *link) {
618 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
619 int r;
620
621 assert(link);
622 assert(link->network);
623 assert(link->manager);
624 assert(link->manager->rtnl);
625
626 /* set it free if not enslaved with networkd */
c0267a59 627 if (link->network->batadv || link->network->bridge || link->network->bond || link->network->vrf)
e16e4b3b
DS		 628 return 0;
629
630 log_link_debug(link, "Setting nomaster");
631
632 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
633 if (r < 0)
634 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
635
636 r = sd_netlink_message_append_u32(req, IFLA_MASTER, 0);
637 if (r < 0)
638 return log_link_error_errno(link, r, "Could not append IFLA_MASTER attribute: %m");
639
640 r = netlink_call_async(link->manager->rtnl, NULL, req, link_nomaster_handler,
641 link_netlink_destroy_callback, link);
642 if (r < 0)
643 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
644
645 link_ref(link);
646
647 return 0;
648}
649
8566df79 650static int link_acquire_dynamic_ipv6_conf(Link *link) {
e7ab854c
TG		 651 int r;
652
653 assert(link);
654
086b8853 655 if (link->radv) {
7465dd22 656 assert(link->radv);
94876904 657 assert(in6_addr_is_link_local(&link->ipv6ll_address));
7465dd22
PF		 658
659 log_link_debug(link, "Starting IPv6 Router Advertisements");
660
fd3ef936
YW		 661 r = radv_emit_dns(link);
662 if (r < 0)
663 return log_link_warning_errno(link, r, "Failed to configure DNS or Domains in IPv6 Router Advertisement: %m");
664
7465dd22
PF		 665 r = sd_radv_start(link->radv);
666 if (r < 0 && r != -EBUSY)
667 return log_link_warning_errno(link, r, "Could not start IPv6 Router Advertisement: %m");
668 }
669
294f129b
YW		 670 r = ndisc_start(link);
671 if (r < 0)
672 return log_link_warning_errno(link, r, "Failed to start IPv6 Router Discovery: %m");
cd305af1 673
294f129b
YW		 674 r = dhcp6_start(link);
675 if (r < 0)
676 return log_link_warning_errno(link, r, "Failed to start DHCPv6 client: %m");
cd305af1 677
1633c457
YW		 678 r = dhcp6_request_prefix_delegation(link);
679 if (r < 0)
680 return log_link_warning_errno(link, r, "Failed to request DHCPv6 prefix delegation: %m");
10752343 681
e7ab854c
TG		 682 return 0;
683}
684
8566df79 685static int link_acquire_dynamic_ipv4_conf(Link *link) {
ff254138
TG		 686 int r;
687
688 assert(link);
ff254138
TG		 689 assert(link->manager);
690 assert(link->manager->event);
691
0107b769 692 if (link->dhcp_client) {
294f129b 693 r = dhcp4_start(link);
0107b769 694 if (r < 0)
294f129b 695 return log_link_warning_errno(link, r, "Failed to start DHCPv4 client: %m");
0107b769 696
0b4b66cc 697 } else if (link->ipv4ll) {
6a7a4e4d 698 log_link_debug(link, "Acquiring IPv4 link-local address");
5c1d3fc9
UTL		 699
700 r = sd_ipv4ll_start(link->ipv4ll);
6a7a4e4d
LP		 701 if (r < 0)
702 return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
5c1d3fc9
UTL		 703 }
704
ab486ef4
YW		 705 if (link->dhcp_server) {
706 r = sd_dhcp_server_start(link->dhcp_server);
707 if (r < 0)
708 return log_link_warning_errno(link, r, "Could not start DHCP server: %m");
709 }
710
6fc25497
SS		 711 return 0;
712}
713
8566df79 714static int link_acquire_dynamic_conf(Link *link) {
6fc25497
SS		 715 int r;
716
717 assert(link);
718
8566df79 719 r = link_acquire_dynamic_ipv4_conf(link);
6fc25497
SS		 720 if (r < 0)
721 return r;
722
94876904 723 if (in6_addr_is_set(&link->ipv6ll_address)) {
8566df79 724 r = link_acquire_dynamic_ipv6_conf(link);
6fc25497
SS		 725 if (r < 0)
726 return r;
727 }
728
2ffd6d73
YW		 729 r = link_lldp_emit_start(link);
730 if (r < 0)
731 return log_link_warning_errno(link, r, "Failed to start LLDP transmission: %m");
8e1ad1ea 732
ff254138
TG		 733 return 0;
734}
735
0c9ee5d5
YW		 736int link_ipv6ll_gained(Link *link, const struct in6_addr *address) {
737 int r;
deb2e523 738
0c9ee5d5 739 assert(link);
deb2e523 740
0c9ee5d5 741 log_link_info(link, "Gained IPv6LL");
deb2e523 742
0c9ee5d5
YW		 743 link->ipv6ll_address = *address;
744 link_check_ready(link);
745
746 if (IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED)) {
747 r = link_acquire_dynamic_ipv6_conf(link);
748 if (r < 0) {
749 link_enter_failed(link);
750 return r;
751 }
752 }
753
754 return 0;
deb2e523
TG		 755}
756
302a796f 757static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
dd3efc09
TG		 758 int r;
759
1746cf2a
TG		 760 assert(link);
761
5da8149f 762 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1746cf2a
TG		 763 return 1;
764
1c4baffc 765 r = sd_netlink_message_get_errno(m);
6a7a4e4d 766 if (r < 0)
26d6b214 767 /* we warn but don't fail the link, as it may be brought up later */
5ecb131d 768 log_link_message_warning_errno(link, m, r, "Could not bring up interface");
45ad2c13 769
f882c247
TG		 770 return 1;
771}
772
f282ce20 773int link_up(Link *link) {
4afd3348 774 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
f579559b
TG		 775 int r;
776
f882c247 777 assert(link);
c106cc36 778 assert(link->network);
f882c247
TG		 779 assert(link->manager);
780 assert(link->manager->rtnl);
781
6a7a4e4d 782 log_link_debug(link, "Bringing link up");
449f7554 783
6a7a4e4d
LP		 784 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
785 if (r < 0)
786 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
f579559b 787
5d4795f3 788 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
6a7a4e4d
LP		 789 if (r < 0)
790 return log_link_error_errno(link, r, "Could not set link flags: %m");
fc25d7f8 791
302a796f
YW		 792 r = netlink_call_async(link->manager->rtnl, NULL, req, link_up_handler,
793 link_netlink_destroy_callback, link);
6a7a4e4d
LP		 794 if (r < 0)
795 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
f579559b 796
b226d99b
TG		 797 link_ref(link);
798
f882c247
TG		 799 return 0;
800}
801
302a796f 802static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
0d4ad91d
AR		 803 int r;
804
805 assert(link);
806
807 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
808 return 1;
809
1c4baffc 810 r = sd_netlink_message_get_errno(m);
0d4ad91d 811 if (r < 0)
5ecb131d 812 log_link_message_warning_errno(link, m, r, "Could not bring down interface");
0d4ad91d
AR		 813
814 return 1;
815}
816
8e54db83 817int link_down(Link *link, link_netlink_message_handler_t callback) {
4afd3348 818 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
0d4ad91d
AR		 819 int r;
820
821 assert(link);
822 assert(link->manager);
823 assert(link->manager->rtnl);
824
6a7a4e4d 825 log_link_debug(link, "Bringing link down");
0d4ad91d
AR		 826
827 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
828 RTM_SETLINK, link->ifindex);
6a7a4e4d
LP		 829 if (r < 0)
830 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
0d4ad91d
AR		 831
832 r = sd_rtnl_message_link_set_flags(req, 0, IFF_UP);
6a7a4e4d
LP		 833 if (r < 0)
834 return log_link_error_errno(link, r, "Could not set link flags: %m");
0d4ad91d 835
8e54db83
YW		 836 r = netlink_call_async(link->manager->rtnl, NULL, req,
837 callback ?: link_down_handler,
302a796f 838 link_netlink_destroy_callback, link);
6a7a4e4d
LP		 839 if (r < 0)
840 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
0d4ad91d
AR		 841
842 link_ref(link);
843
844 return 0;
845}
846
847static int link_handle_bound_to_list(Link *link) {
848 Link *l;
0d4ad91d
AR		 849 int r;
850 bool required_up = false;
851 bool link_is_up = false;
852
853 assert(link);
854
855 if (hashmap_isempty(link->bound_to_links))
856 return 0;
857
858 if (link->flags & IFF_UP)
859 link_is_up = true;
860
90e74a66 861 HASHMAP_FOREACH (l, link->bound_to_links)
0d4ad91d
AR		 862 if (link_has_carrier(l)) {
863 required_up = true;
864 break;
865 }
866
867 if (!required_up && link_is_up) {
8e54db83 868 r = link_down(link, NULL);
0d4ad91d
AR		 869 if (r < 0)
870 return r;
871 } else if (required_up && !link_is_up) {
872 r = link_up(link);
873 if (r < 0)
874 return r;
875 }
876
877 return 0;
878}
879
880static int link_handle_bound_by_list(Link *link) {
0d4ad91d
AR		 881 Link *l;
882 int r;
883
884 assert(link);
885
886 if (hashmap_isempty(link->bound_by_links))
887 return 0;
888
90e74a66 889 HASHMAP_FOREACH (l, link->bound_by_links) {
0d4ad91d
AR		 890 r = link_handle_bound_to_list(l);
891 if (r < 0)
892 return r;
893 }
894
895 return 0;
896}
897
898static int link_put_carrier(Link *link, Link *carrier, Hashmap **h) {
899 int r;
900
901 assert(link);
902 assert(carrier);
903
904 if (link == carrier)
905 return 0;
906
907 if (hashmap_get(*h, INT_TO_PTR(carrier->ifindex)))
908 return 0;
909
190b3b5c 910 r = hashmap_ensure_put(h, NULL, INT_TO_PTR(carrier->ifindex), carrier);
0d4ad91d
AR		 911 if (r < 0)
912 return r;
913
9092113d
YW		 914 link_dirty(link);
915
0d4ad91d
AR		 916 return 0;
917}
918
919static int link_new_bound_by_list(Link *link) {
920 Manager *m;
921 Link *carrier;
0d4ad91d 922 int r;
0d4ad91d
AR		 923
924 assert(link);
925 assert(link->manager);
926
927 m = link->manager;
928
90e74a66 929 HASHMAP_FOREACH(carrier, m->links) {
0d4ad91d
AR		 930 if (!carrier->network)
931 continue;
932
933 if (strv_isempty(carrier->network->bind_carrier))
934 continue;
935
191a3f16 936 if (strv_fnmatch(carrier->network->bind_carrier, link->ifname)) {
0d4ad91d
AR		 937 r = link_put_carrier(link, carrier, &link->bound_by_links);
938 if (r < 0)
939 return r;
0d4ad91d
AR		 940 }
941 }
942
90e74a66 943 HASHMAP_FOREACH(carrier, link->bound_by_links) {
0d4ad91d
AR		 944 r = link_put_carrier(carrier, link, &carrier->bound_to_links);
945 if (r < 0)
946 return r;
0d4ad91d
AR		 947 }
948
949 return 0;
950}
951
952static int link_new_bound_to_list(Link *link) {
953 Manager *m;
954 Link *carrier;
0d4ad91d 955 int r;
0d4ad91d
AR		 956
957 assert(link);
958 assert(link->manager);
959
960 if (!link->network)
961 return 0;
962
963 if (strv_isempty(link->network->bind_carrier))
964 return 0;
965
966 m = link->manager;
967
90e74a66 968 HASHMAP_FOREACH (carrier, m->links) {
191a3f16 969 if (strv_fnmatch(link->network->bind_carrier, carrier->ifname)) {
0d4ad91d
AR		 970 r = link_put_carrier(link, carrier, &link->bound_to_links);
971 if (r < 0)
972 return r;
0d4ad91d
AR		 973 }
974 }
975
90e74a66 976 HASHMAP_FOREACH (carrier, link->bound_to_links) {
0d4ad91d
AR		 977 r = link_put_carrier(carrier, link, &carrier->bound_by_links);
978 if (r < 0)
979 return r;
0d4ad91d
AR		 980 }
981
982 return 0;
983}
984
985static int link_new_carrier_maps(Link *link) {
986 int r;
987
988 r = link_new_bound_by_list(link);
989 if (r < 0)
990 return r;
991
992 r = link_handle_bound_by_list(link);
993 if (r < 0)
994 return r;
995
996 r = link_new_bound_to_list(link);
997 if (r < 0)
998 return r;
999
1000 r = link_handle_bound_to_list(link);
1001 if (r < 0)
1002 return r;
1003
1004 return 0;
1005}
1006
1007static void link_free_bound_to_list(Link *link) {
9092113d 1008 bool updated = false;
0d4ad91d 1009 Link *bound_to;
0d4ad91d 1010
9092113d
YW		 1011 assert(link);
1012
1013 while ((bound_to = hashmap_steal_first(link->bound_to_links))) {
1014 updated = true;
0d4ad91d
AR		 1015
1016 if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
84de38c5 1017 link_dirty(bound_to);
0d4ad91d
AR		 1018 }
1019
9092113d
YW		 1020 if (updated)
1021 link_dirty(link);
1022
0d4ad91d
AR		 1023 return;
1024}
1025
1026static void link_free_bound_by_list(Link *link) {
9092113d 1027 bool updated = false;
0d4ad91d 1028 Link *bound_by;
0d4ad91d 1029
9092113d
YW		 1030 assert(link);
1031
1032 while ((bound_by = hashmap_steal_first(link->bound_by_links))) {
1033 updated = true;
0d4ad91d
AR		 1034
1035 if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
84de38c5 1036 link_dirty(bound_by);
0d4ad91d
AR		 1037 link_handle_bound_to_list(bound_by);
1038 }
1039 }
1040
9092113d
YW		 1041 if (updated)
1042 link_dirty(link);
1043
0d4ad91d
AR		 1044 return;
1045}
1046
1047static void link_free_carrier_maps(Link *link) {
0d4ad91d
AR		 1048 assert(link);
1049
9092113d
YW		 1050 link_free_bound_to_list(link);
1051 link_free_bound_by_list(link);
0d4ad91d
AR		 1052
1053 return;
1054}
1055
81357285 1056static int link_append_to_master(Link *link) {
5f707e12
YW		 1057 Link *master;
1058 int r;
1059
1060 assert(link);
5f707e12 1061
81357285
YW		 1062 /* - The link may have no master.
1063 * - RTM_NEWLINK message about master interface may not be received yet. */
1064 if (link_get_master(link, &master) < 0)
1065 return 0;
5f707e12 1066
de7fef4b 1067 r = set_ensure_put(&master->slaves, NULL, link);
38288f0b 1068 if (r <= 0)
5f707e12
YW		 1069 return r;
1070
1071 link_ref(link);
1072 return 0;
1073}
1074
81357285 1075static void link_drop_from_master(Link *link) {
5f707e12
YW		 1076 Link *master;
1077
1078 assert(link);
1079
81357285 1080 if (!link->manager)
5f707e12
YW		 1081 return;
1082
81357285 1083 if (link_get_master(link, &master) < 0)
5f707e12
YW		 1084 return;
1085
1086 link_unref(set_remove(master->slaves, link));
1087}
1088
56001f02
YW		 1089static void link_drop_requests(Link *link) {
1090 Request *req;
1091
1092 assert(link);
1093 assert(link->manager);
1094
1095 ORDERED_SET_FOREACH(req, link->manager->request_queue)
1096 if (req->link == link)
1097 request_drop(req);
1098}
1099
cc2d7efc 1100static Link *link_drop(Link *link) {
0b54c870
YW		 1101 char **n;
1102
63130eb3 1103 if (!link)
cc2d7efc 1104 return NULL;
0d4ad91d 1105
63130eb3
YW		 1106 assert(link->manager);
1107
0d4ad91d
AR		 1108 link_set_state(link, LINK_STATE_LINGER);
1109
63130eb3
YW		 1110 /* Drop all references from other links and manager. Note that async netlink calls may have
1111 * references to the link, and they will be dropped when we receive replies. */
1112
56001f02
YW		 1113 link_drop_requests(link);
1114
0d4ad91d
AR		 1115 link_free_carrier_maps(link);
1116
81357285 1117 link_drop_from_master(link);
5f707e12 1118
63130eb3 1119 link_unref(set_remove(link->manager->links_requesting_uuid, link));
0d4ad91d 1120
db2f8a2e 1121 (void) unlink(link->state_file);
63130eb3
YW		 1122 link_clean(link);
1123
0b54c870
YW		 1124 STRV_FOREACH(n, link->alternative_names)
1125 hashmap_remove(link->manager->links_by_name, *n);
1126
1127 hashmap_remove(link->manager->links_by_name, link->ifname);
1128
63130eb3
YW		 1129 /* The following must be called at last. */
1130 assert_se(hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex)) == link);
cc2d7efc 1131 return link_unref(link);
0d4ad91d
AR		 1132}
1133
04952b25 1134int link_activate(Link *link) {
f882c247
TG		 1135 int r;
1136
ef1ba606 1137 assert(link);
f5be5601 1138 assert(link->network);
dd3efc09 1139
61135582
DS		 1140 switch (link->network->activation_policy) {
1141 case ACTIVATION_POLICY_BOUND:
0d4ad91d
AR		 1142 r = link_handle_bound_to_list(link);
1143 if (r < 0)
1144 return r;
61135582
DS		 1145 break;
1146 case ACTIVATION_POLICY_UP:
1147 if (link->activated)
1148 break;
1149 _fallthrough_;
1150 case ACTIVATION_POLICY_ALWAYS_UP:
505f8da7 1151 r = link_up(link);
04952b25 1152 if (r < 0)
505f8da7 1153 return r;
61135582
DS		 1154 break;
1155 case ACTIVATION_POLICY_DOWN:
1156 if (link->activated)
1157 break;
1158 _fallthrough_;
1159 case ACTIVATION_POLICY_ALWAYS_DOWN:
1160 r = link_down(link, NULL);
04952b25 1161 if (r < 0)
61135582 1162 return r;
61135582
DS		 1163 break;
1164 default:
1165 break;
ef1ba606 1166 }
61135582 1167 link->activated = true;
f882c247 1168
04952b25
YW		 1169 return 0;
1170}
1171
1172static int link_joined(Link *link) {
1173 int r;
1174
1175 assert(link);
1176 assert(link->network);
1177
1178 r = link_activate(link);
1179 if (r < 0)
1180 return r;
1181
97108953
YW		 1182 link_set_state(link, LINK_STATE_CONFIGURING);
1183
9ed794a3 1184 if (link->network->bridge) {
e1853b00 1185 r = link_set_bridge(link);
6a7a4e4d
LP		 1186 if (r < 0)
1187 log_link_error_errno(link, r, "Could not set bridge message: %m");
e1853b00
SS		 1188 }
1189
eb64b435 1190 if (link->network->bond) {
7fcee284 1191 r = link_set_bond(link);
eb64b435
SS		 1192 if (r < 0)
1193 log_link_error_errno(link, r, "Could not set bond message: %m");
1194 }
1195
34d7f2c9
YW		 1196 r = link_set_bridge_vlan(link);
1197 if (r < 0)
1198 log_link_error_errno(link, r, "Could not set bridge vlan: %m");
13b498f9 1199
81357285
YW		 1200 r = link_append_to_master(link);
1201 if (r < 0)
1202 return log_link_error_errno(link, r, "Failed to add to master interface's slave list: %m");
1203
97108953 1204 r = link_request_static_configs(link);
0e569a43
YW		 1205 if (r < 0)
1206 return r;
1207
97108953
YW		 1208 if (!link_has_carrier(link))
1209 return 0;
1210
8566df79 1211 return link_acquire_dynamic_conf(link);
02b59d57
TG		 1212}
1213
302a796f 1214static int netdev_join_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
02b59d57
TG		 1215 int r;
1216
1746cf2a 1217 assert(link);
ef1ba606 1218 assert(link->network);
34bf3c00 1219 assert(link->enslaving > 0);
02b59d57 1220
313cefa1 1221 link->enslaving--;
52433f6b 1222
5da8149f 1223 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
02b59d57
TG		 1224 return 1;
1225
1c4baffc 1226 r = sd_netlink_message_get_errno(m);
856f962c 1227 if (r < 0 && r != -EEXIST) {
5ecb131d 1228 log_link_message_warning_errno(link, m, r, "Could not join netdev");
ef1ba606
TG		 1229 link_enter_failed(link);
1230 return 1;
4ff296b0
YW		 1231 }
1232
1233 log_link_debug(link, "Joined netdev");
02b59d57 1234
34bf3c00 1235 if (link->enslaving == 0) {
4ff296b0
YW		 1236 r = link_joined(link);
1237 if (r < 0)
1238 link_enter_failed(link);
34bf3c00 1239 }
02b59d57
TG		 1240
1241 return 1;
1242}
1243
0fa8ee6c 1244int link_enter_join_netdev(Link *link) {
6a0a2f86 1245 NetDev *netdev;
0fa8ee6c 1246 Request req;
02b59d57
TG		 1247 int r;
1248
1249 assert(link);
1250 assert(link->network);
bd08ce56 1251 assert(link->state == LINK_STATE_INITIALIZED);
02b59d57 1252
0fa8ee6c
YW		 1253 req = (Request) {
1254 .link = link,
1255 .type = REQUEST_TYPE_SET_LINK,
1256 .set_link_operation = SET_LINK_MTU,
1257 };
1258
1259 if (ordered_set_contains(link->manager->request_queue, &req)) {
1260 link->entering_to_join_netdev = true;
1261 return 0;
1262 }
1263
1264 link->entering_to_join_netdev = false;
1265
289e6774 1266 link_set_state(link, LINK_STATE_CONFIGURING);
02b59d57 1267
34bf3c00 1268 link->enslaving = 0;
02b59d57 1269
d9c67ea1 1270 if (link->network->bond) {
cbff7170
TJ		 1271 if (link->network->bond->state == NETDEV_STATE_READY &&
1272 link->network->bond->ifindex == link->master_ifindex)
1273 return link_joined(link);
1274
f2341e0a
LP		 1275 log_struct(LOG_DEBUG,
1276 LOG_LINK_INTERFACE(link),
1277 LOG_NETDEV_INTERFACE(link->network->bond),
a1230ff9 1278 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bond->ifname));
f2341e0a 1279
34bf3c00
YW		 1280 link->enslaving++;
1281
f2341e0a 1282 r = netdev_join(link->network->bond, link, netdev_join_handler);
52433f6b 1283 if (r < 0) {
f2341e0a
LP		 1284 log_struct_errno(LOG_WARNING, r,
1285 LOG_LINK_INTERFACE(link),
1286 LOG_NETDEV_INTERFACE(link->network->bond),
a1230ff9 1287 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bond->ifname));
52433f6b
TG		 1288 link_enter_failed(link);
1289 return r;
c0267a59
AW		 1290 }
1291 }
1292
1293 if (link->network->batadv) {
1294 log_struct(LOG_DEBUG,
1295 LOG_LINK_INTERFACE(link),
1296 LOG_NETDEV_INTERFACE(link->network->batadv),
1297 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->batadv->ifname));
1298
1299 link->enslaving++;
1300
1301 r = netdev_join(link->network->batadv, link, netdev_join_handler);
1302 if (r < 0) {
1303 log_struct_errno(LOG_WARNING, r,
1304 LOG_LINK_INTERFACE(link),
1305 LOG_NETDEV_INTERFACE(link->network->batadv),
1306 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->batadv->ifname));
1307 link_enter_failed(link);
1308 return r;
52433f6b 1309 }
0ad6148e
MO		 1310 }
1311
d9c67ea1 1312 if (link->network->bridge) {
f2341e0a
LP		 1313 log_struct(LOG_DEBUG,
1314 LOG_LINK_INTERFACE(link),
1315 LOG_NETDEV_INTERFACE(link->network->bridge),
a1230ff9 1316 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bridge->ifname));
f2341e0a 1317
34bf3c00
YW		 1318 link->enslaving++;
1319
f2341e0a 1320 r = netdev_join(link->network->bridge, link, netdev_join_handler);
0ad6148e 1321 if (r < 0) {
f2341e0a
LP		 1322 log_struct_errno(LOG_WARNING, r,
1323 LOG_LINK_INTERFACE(link),
1324 LOG_NETDEV_INTERFACE(link->network->bridge),
a1230ff9 1325 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bridge->ifname));
0ad6148e
MO		 1326 link_enter_failed(link);
1327 return r;
1328 }
52433f6b
TG		 1329 }
1330
6cb955c6
AR		 1331 if (link->network->vrf) {
1332 log_struct(LOG_DEBUG,
1333 LOG_LINK_INTERFACE(link),
1334 LOG_NETDEV_INTERFACE(link->network->vrf),
a1230ff9
ZJS		 1335 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->vrf->ifname));
1336
34bf3c00
YW		 1337 link->enslaving++;
1338
6cb955c6
AR		 1339 r = netdev_join(link->network->vrf, link, netdev_join_handler);
1340 if (r < 0) {
1341 log_struct_errno(LOG_WARNING, r,
1342 LOG_LINK_INTERFACE(link),
1343 LOG_NETDEV_INTERFACE(link->network->vrf),
a1230ff9 1344 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->vrf->ifname));
6cb955c6
AR		 1345 link_enter_failed(link);
1346 return r;
1347 }
6cb955c6
AR		 1348 }
1349
90e74a66 1350 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs) {
7951dea2 1351
2b6db913
YW		 1352 if (netdev->ifindex > 0)
1353 /* Assume already enslaved. */
a63e5daa 1354 continue;
a63e5daa 1355
7033af49
YW		 1356 if (netdev_get_create_type(netdev) != NETDEV_CREATE_STACKED)
1357 continue;
1358
f2341e0a
LP		 1359 log_struct(LOG_DEBUG,
1360 LOG_LINK_INTERFACE(link),
1361 LOG_NETDEV_INTERFACE(netdev),
a1230ff9 1362 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname));
f2341e0a 1363
34bf3c00
YW		 1364 link->enslaving++;
1365
f2341e0a 1366 r = netdev_join(netdev, link, netdev_join_handler);
7951dea2 1367 if (r < 0) {
f2341e0a
LP		 1368 log_struct_errno(LOG_WARNING, r,
1369 LOG_LINK_INTERFACE(link),
1370 LOG_NETDEV_INTERFACE(netdev),
a1230ff9 1371 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname));
326cb406
SS		 1372 link_enter_failed(link);
1373 return r;
1374 }
326cb406
SS		 1375 }
1376
34bf3c00
YW		 1377 if (link->enslaving == 0)
1378 return link_joined(link);
1379
ef1ba606
TG		 1380 return 0;
1381}
1382
5e5b137a 1383static int link_drop_foreign_config(Link *link) {
0b81225e
YW		 1384 int k, r;
1385
1386 assert(link);
1387 assert(link->manager);
5e5b137a 1388
e36d601c 1389 r = link_drop_foreign_routes(link);
5e5b137a 1390
e36d601c 1391 k = link_drop_foreign_nexthops(link);
0b81225e
YW		 1392 if (k < 0 && r >= 0)
1393 r = k;
1394
e36d601c 1395 k = link_drop_foreign_addresses(link);
0b81225e
YW		 1396 if (k < 0 && r >= 0)
1397 r = k;
d1bdafd2 1398
e36d601c 1399 k = link_drop_foreign_neighbors(link);
25b82b6e
YW		 1400 if (k < 0 && r >= 0)
1401 r = k;
1402
0b81225e
YW		 1403 k = manager_drop_foreign_routing_policy_rules(link->manager);
1404 if (k < 0 && r >= 0)
1405 r = k;
1406
1407 return r;
5e5b137a
TG		 1408}
1409
3104883d 1410static int link_drop_config(Link *link) {
0b81225e
YW		 1411 int k, r;
1412
1413 assert(link);
1414 assert(link->manager);
3104883d 1415
e36d601c 1416 r = link_drop_routes(link);
3104883d 1417
e36d601c 1418 k = link_drop_nexthops(link);
0b81225e
YW		 1419 if (k < 0 && r >= 0)
1420 r = k;
d1bdafd2 1421
e36d601c 1422 k = link_drop_addresses(link);
0b81225e
YW		 1423 if (k < 0 && r >= 0)
1424 r = k;
1425
e36d601c 1426 k = link_drop_neighbors(link);
25b82b6e
YW		 1427 if (k < 0 && r >= 0)
1428 r = k;
1429
0b81225e
YW		 1430 k = manager_drop_routing_policy_rules(link->manager, link);
1431 if (k < 0 && r >= 0)
1432 r = k;
3104883d 1433
c69305ff
LP		 1434 ndisc_flush(link);
1435
0b81225e 1436 return r;
3104883d
SS		 1437}
1438
c3b94251 1439static int link_configure(Link *link) {
4ecdcb07
YW		 1440 int r;
1441
ef1ba606 1442 assert(link);
b22d8a00 1443 assert(link->network);
bd08ce56 1444 assert(link->state == LINK_STATE_INITIALIZED);
a748b692 1445
34658df2 1446 r = link_configure_traffic_control(link);
4ecdcb07
YW		 1447 if (r < 0)
1448 return r;
1449
518cd6b5
SS		 1450 r = link_configure_sr_iov(link);
1451 if (r < 0)
1452 return r;
1453
500b96eb 1454 if (link->iftype == ARPHRD_CAN)
600b7898 1455 /* let's shortcut things for CAN which doesn't need most of what's done below. */
93ea7750 1456 return link_configure_can(link);
92c918b0 1457
5e0534f1 1458 r = link_set_sysctl(link);
b69c3180
SS		 1459 if (r < 0)
1460 return r;
8749cbcd 1461
a8e5e27c 1462 r = link_request_to_set_mac(link);
e16e4b3b
DS		 1463 if (r < 0)
1464 return r;
1465
1466 r = link_set_nomaster(link);
1467 if (r < 0)
1468 return r;
1469
93fabc10 1470 r = link_request_to_set_flags(link);
99d2baa2
SS		 1471 if (r < 0)
1472 return r;
1473
cc4c8fb1 1474 r = link_request_to_set_group(link);
89fe6535
SS		 1475 if (r < 0)
1476 return r;
1477
2ffd6d73
YW		 1478 r = ipv4ll_configure(link);
1479 if (r < 0)
1480 return r;
64b21ece 1481
2ffd6d73
YW		 1482 r = dhcp4_configure(link);
1483 if (r < 0)
1484 return r;
eb34d4af 1485
2ffd6d73
YW		 1486 r = dhcp6_configure(link);
1487 if (r < 0)
1488 return r;
f5a8c43f 1489
2ffd6d73
YW		 1490 r = ndisc_configure(link);
1491 if (r < 0)
1492 return r;
4138fb2c 1493
1d28a3cf
YW		 1494 r = link_request_dhcp_server(link);
1495 if (r < 0)
1496 return r;
1497
086b8853
YW		 1498 r = radv_configure(link);
1499 if (r < 0)
1500 return r;
7465dd22 1501
2ffd6d73
YW		 1502 r = link_lldp_rx_configure(link);
1503 if (r < 0)
1504 return r;
ce43e484 1505
f6fcc1c2 1506 r = link_configure_mtu(link);
40288ece
YW		 1507 if (r < 0)
1508 return r;
44b598a1 1509
8e00e24c 1510 r = link_request_to_set_addrgen_mode(link);
9f6e82e6
YW		 1511 if (r < 0)
1512 return r;
0e2fdb83 1513
4c649652
DS		 1514 /* Drop foreign config, but ignore loopback or critical devices.
1515 * We do not want to remove loopback address or addresses used for root NFS. */
1516 if (!(link->flags & IFF_LOOPBACK) &&
1517 link->network->keep_configuration != KEEP_CONFIGURATION_YES) {
1518 r = link_drop_foreign_config(link);
1519 if (r < 0)
1520 return r;
1521 }
1522
3f265037 1523 return link_enter_join_netdev(link);
505f8da7
TG		 1524}
1525
170e88c8
YW		 1526static int link_get_network(Link *link, Network **ret) {
1527 Network *network;
1a3caa49 1528 int r;
170e88c8
YW		 1529
1530 assert(link);
1531 assert(link->manager);
1532 assert(ret);
1533
1534 ORDERED_HASHMAP_FOREACH(network, link->manager->networks) {
1535 bool warn = false;
1536
1a3caa49 1537 r = net_match_config(
170e88c8
YW		 1538 &network->match,
1539 link->sd_device,
1540 &link->hw_addr.addr.ether,
1541 &link->permanent_mac,
1542 link->driver,
1543 link->iftype,
1544 link->ifname,
1545 link->alternative_names,
1546 link->wlan_iftype,
1547 link->ssid,
1a3caa49
YW		 1548 &link->bssid);
1549 if (r < 0)
1550 return r;
1551 if (r == 0)
170e88c8
YW		 1552 continue;
1553
1554 if (network->match.ifname && link->sd_device) {
1555 uint8_t name_assign_type = NET_NAME_UNKNOWN;
1556 const char *attr;
1557
1558 if (sd_device_get_sysattr_value(link->sd_device, "name_assign_type", &attr) >= 0)
1559 (void) safe_atou8(attr, &name_assign_type);
1560
1561 warn = name_assign_type == NET_NAME_ENUM;
1562 }
1563
1564 log_link_full(link, warn ? LOG_WARNING : LOG_DEBUG,
1565 "found matching network '%s'%s.",
1566 network->filename,
1567 warn ? ", based on potentially unpredictable interface name" : "");
1568
1569 if (network->unmanaged)
1570 return -ENOENT;
1571
1572 *ret = network;
1573 return 0;
1574 }
1575
1576 return -ENOENT;
1577}
1578
0b54c870
YW		 1579static int link_update_alternative_names(Link *link, sd_netlink_message *message) {
1580 _cleanup_strv_free_ char **altnames = NULL;
1581 char **n;
1582 int r;
1583
1584 assert(link);
1585 assert(message);
1586
1587 r = sd_netlink_message_read_strv(message, IFLA_PROP_LIST, IFLA_ALT_IFNAME, &altnames);
1588 if (r < 0 && r != -ENODATA)
1589 return r;
1590
1591 STRV_FOREACH(n, link->alternative_names)
1592 hashmap_remove(link->manager->links_by_name, *n);
1593
1594 strv_free_and_replace(link->alternative_names, altnames);
1595
1596 STRV_FOREACH(n, link->alternative_names) {
1597 r = hashmap_ensure_put(&link->manager->links_by_name, &string_hash_ops, *n, link);
1598 if (r < 0)
1599 return r;
1600 }
1601
1602 return 0;
1603}
1604
572b21d9 1605static int link_reconfigure_internal(Link *link, sd_netlink_message *m, bool force) {
ad932b15
YW		 1606 Network *network;
1607 int r;
1608
8bceafa7 1609 assert(m);
572b21d9 1610
8bceafa7
YW		 1611 r = sd_netlink_message_get_errno(m);
1612 if (r < 0)
1613 return r;
572b21d9 1614
0b54c870
YW		 1615 r = link_update_alternative_names(link, m);
1616 if (r < 0)
8bceafa7 1617 return r;
572b21d9 1618
170e88c8 1619 r = link_get_network(link, &network);
ad932b15
YW		 1620 if (r == -ENOENT) {
1621 link_enter_unmanaged(link);
1622 return 0;
170e88c8
YW		 1623 }
1624 if (r < 0)
ad932b15
YW		 1625 return r;
1626
99b8517c 1627 if (link->network == network && !force)
ad932b15
YW		 1628 return 0;
1629
1630 log_link_info(link, "Re-configuring with %s", network->filename);
1631
1632 /* Dropping old .network file */
2a99eed0 1633 r = link_stop_engines(link, false);
572b21d9 1634 if (r < 0)
ad932b15 1635 return r;
ad932b15 1636
19d9a5ad
YW		 1637 link_drop_requests(link);
1638
ad932b15
YW		 1639 r = link_drop_config(link);
1640 if (r < 0)
1641 return r;
1642
2c7b826d 1643 if (!IN_SET(link->state, LINK_STATE_UNMANAGED, LINK_STATE_PENDING, LINK_STATE_INITIALIZED)) {
942cf4b8 1644 log_link_debug(link, "State is %s, dropping foreign config", link_state_to_string(link->state));
ad932b15
YW		 1645 r = link_drop_foreign_config(link);
1646 if (r < 0)
1647 return r;
1648 }
1649
1650 link_free_carrier_maps(link);
1651 link_free_engines(link);
1652 link->network = network_unref(link->network);
59c31eba 1653 link_unref(set_remove(link->manager->links_requesting_uuid, link));
ad932b15
YW		 1654
1655 /* Then, apply new .network file */
9092113d
YW		 1656 link->network = network_ref(network);
1657 link_dirty(link);
ad932b15
YW		 1658
1659 r = link_new_carrier_maps(link);
1660 if (r < 0)
1661 return r;
1662
1663 link_set_state(link, LINK_STATE_INITIALIZED);
61135582 1664 link->activated = false;
ad932b15 1665
ad932b15
YW		 1666 r = link_configure(link);
1667 if (r < 0)
1668 return r;
1669
1670 return 0;
1671}
1672
572b21d9
YW		 1673static int link_reconfigure_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1674 int r;
1675
1676 r = link_reconfigure_internal(link, m, false);
1677 if (r < 0)
1678 link_enter_failed(link);
1679
1680 return 1;
1681}
1682
1683static int link_force_reconfigure_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1684 int r;
1685
1686 r = link_reconfigure_internal(link, m, true);
1687 if (r < 0)
1688 link_enter_failed(link);
1689
1690 return 1;
1691}
1692
1693int link_reconfigure(Link *link, bool force) {
1694 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1695 int r;
1696
8bceafa7 1697 /* When link in pending or initialized state, then link_configure() will be called. To prevent
f8dd4077
ZJS		 1698 * the function from being called multiple times simultaneously, refuse to reconfigure the
1699 * interface in these cases. */
8bceafa7 1700 if (IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_INITIALIZED, LINK_STATE_LINGER))
f8dd4077 1701 return 0; /* 0 means no-op. */
2c0d7ed3 1702
572b21d9
YW		 1703 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1704 link->ifindex);
1705 if (r < 0)
1706 return r;
1707
1708 r = netlink_call_async(link->manager->rtnl, NULL, req,
1709 force ? link_force_reconfigure_handler : link_reconfigure_handler,
1710 link_netlink_destroy_callback, link);
1711 if (r < 0)
1712 return r;
1713
1714 link_ref(link);
1715
8bceafa7 1716 return 1; /* 1 means the interface will be reconfigured. */
572b21d9
YW		 1717}
1718
e6bf7774 1719static int link_initialized_and_synced(Link *link) {
505f8da7 1720 Network *network;
505f8da7
TG		 1721 int r;
1722
1723 assert(link);
1724 assert(link->ifname);
1725 assert(link->manager);
1726
bd08ce56
YW		 1727 /* We may get called either from the asynchronous netlink callback,
1728 * or directly for link_add() if running in a container. See link_add(). */
1729 if (!IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_INITIALIZED))
4232cf04 1730 return 0;
505f8da7 1731
6a7a4e4d 1732 log_link_debug(link, "Link state is up-to-date");
bd08ce56 1733 link_set_state(link, LINK_STATE_INITIALIZED);
505f8da7 1734
0d4ad91d
AR		 1735 r = link_new_bound_by_list(link);
1736 if (r < 0)
1737 return r;
1738
1739 r = link_handle_bound_by_list(link);
1740 if (r < 0)
1741 return r;
1742
c4a03a56 1743 if (!link->network) {
0894cfe4 1744 r = wifi_get_info(link);
8d968fdd
YW		 1745 if (r < 0)
1746 return r;
1747
170e88c8 1748 r = link_get_network(link, &network);
c4a03a56
TG		 1749 if (r == -ENOENT) {
1750 link_enter_unmanaged(link);
4232cf04 1751 return 0;
170e88c8
YW		 1752 }
1753 if (r < 0)
c4a03a56 1754 return r;
505f8da7 1755
c4a03a56
TG		 1756 if (link->flags & IFF_LOOPBACK) {
1757 if (network->link_local != ADDRESS_FAMILY_NO)
1758 log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
78c958f8 1759
c4a03a56
TG		 1760 if (network->dhcp != ADDRESS_FAMILY_NO)
1761 log_link_debug(link, "Ignoring DHCP clients for loopback link");
78c958f8 1762
c4a03a56
TG		 1763 if (network->dhcp_server)
1764 log_link_debug(link, "Ignoring DHCP server for loopback link");
1765 }
bd2efe92 1766
9092113d 1767 link->network = network_ref(network);
bcdcc596 1768 link_update_operstate(link, false);
9092113d 1769 link_dirty(link);
c4a03a56 1770 }
505f8da7 1771
0d4ad91d
AR		 1772 r = link_new_bound_to_list(link);
1773 if (r < 0)
1774 return r;
1775
a748b692
TG		 1776 r = link_configure(link);
1777 if (r < 0)
1778 return r;
1779
4232cf04 1780 return 0;
505f8da7
TG		 1781}
1782
302a796f 1783static int link_initialized_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
4ff296b0
YW		 1784 int r;
1785
572b21d9
YW		 1786 r = sd_netlink_message_get_errno(m);
1787 if (r < 0) {
40681e5c 1788 log_link_warning_errno(link, r, "Failed to wait for the interface to be initialized: %m");
572b21d9
YW		 1789 link_enter_failed(link);
1790 return 0;
1791 }
1792
0b54c870
YW		 1793 r = link_update_alternative_names(link, m);
1794 if (r < 0) {
572b21d9 1795 link_enter_failed(link);
0b54c870 1796 return r;
572b21d9
YW		 1797 }
1798
4ff296b0
YW		 1799 r = link_initialized_and_synced(link);
1800 if (r < 0)
1801 link_enter_failed(link);
e6bf7774
YW		 1802 return 1;
1803}
1804
3be9d62a 1805static int link_initialized(Link *link, sd_device *device) {
4afd3348 1806 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
4f561e8e
TG		 1807 int r;
1808
1809 assert(link);
1810 assert(link->manager);
1811 assert(link->manager->rtnl);
1812 assert(device);
1813
8434fd5c 1814 if (link->state != LINK_STATE_PENDING)
4f561e8e
TG		 1815 return 0;
1816
51517f9e 1817 if (link->sd_device)
679b3605
TG		 1818 return 0;
1819
79008bdd 1820 log_link_debug(link, "udev initialized link");
bd08ce56 1821 link_set_state(link, LINK_STATE_INITIALIZED);
4f561e8e 1822
51517f9e 1823 link->sd_device = sd_device_ref(device);
4f561e8e 1824
3c9b8860
TG		 1825 /* udev has initialized the link, but we don't know if we have yet
1826 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1827 * when it returns we know that the pending NEWLINKs have already been
1828 * processed and that we are up-to-date */
4f561e8e 1829
3c9b8860
TG		 1830 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1831 link->ifindex);
4f561e8e
TG		 1832 if (r < 0)
1833 return r;
1834
0c9ee5d5
YW		 1835 r = netlink_call_async(link->manager->rtnl, NULL, req, link_initialized_handler,
1836 link_netlink_destroy_callback, link);
cc2d7efc
YW		 1837 if (r < 0)
1838 return r;
1839
0c9ee5d5 1840 link_ref(link);
cc2d7efc
YW		 1841
1842 return 0;
1843}
1844
0c9ee5d5
YW		 1845static int link_new(Manager *m, sd_netlink_message *message, Link **ret);
1846
3be9d62a 1847static int link_add(Manager *m, sd_netlink_message *message, Link **ret) {
51517f9e 1848 _cleanup_(sd_device_unrefp) sd_device *device = NULL;
505f8da7 1849 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
51517f9e 1850 Link *link;
5a937ea2 1851 int r;
505f8da7
TG		 1852
1853 assert(m);
fbbeb65a 1854 assert(m->rtnl);
505f8da7
TG		 1855 assert(message);
1856 assert(ret);
1857
1858 r = link_new(m, message, ret);
1859 if (r < 0)
1860 return r;
1861
1862 link = *ret;
1863
6a7a4e4d 1864 log_link_debug(link, "Link %d added", link->ifindex);
505f8da7 1865
bf331d87
YW		 1866 if (path_is_read_only_fs("/sys") <= 0) {
1867 /* udev should be around */
ae06ab10 1868 sprintf(ifindex_str, "n%d", link->ifindex);
51517f9e
YW		 1869 r = sd_device_new_from_device_id(&device, ifindex_str);
1870 if (r < 0) {
83e7c37b 1871 log_link_debug_errno(link, r, "Could not find device, waiting for device initialization: %m");
4d59e14f 1872 return 0;
5c416fc4 1873 }
505f8da7 1874
5a937ea2 1875 r = sd_device_get_is_initialized(device);
51517f9e 1876 if (r < 0) {
bf331d87 1877 log_link_warning_errno(link, r, "Could not determine whether the device is initialized: %m");
51517f9e
YW		 1878 goto failed;
1879 }
5a937ea2 1880 if (r == 0) {
505f8da7 1881 /* not yet ready */
79008bdd 1882 log_link_debug(link, "link pending udev initialization...");
505f8da7 1883 return 0;
3c4cb064 1884 }
505f8da7 1885
299ad32d
YW		 1886 r = device_is_renaming(device);
1887 if (r < 0) {
bf331d87 1888 log_link_warning_errno(link, r, "Failed to determine the device is being renamed: %m");
299ad32d
YW		 1889 goto failed;
1890 }
1891 if (r > 0) {
bf331d87 1892 log_link_debug(link, "Interface is being renamed, pending initialization.");
299ad32d
YW		 1893 return 0;
1894 }
1895
4f561e8e
TG		 1896 r = link_initialized(link, device);
1897 if (r < 0)
5c416fc4 1898 goto failed;
4f561e8e 1899 } else {
e6bf7774 1900 r = link_initialized_and_synced(link);
4f561e8e 1901 if (r < 0)
5c416fc4 1902 goto failed;
4f561e8e 1903 }
505f8da7 1904
a748b692 1905 return 0;
5c416fc4
TG		 1906failed:
1907 link_enter_failed(link);
1908 return r;
a748b692
TG		 1909}
1910
3be9d62a
YW		 1911int manager_udev_process_link(sd_device_monitor *monitor, sd_device *device, void *userdata) {
1912 sd_device_action_t action;
1913 Manager *m = userdata;
1914 Link *link = NULL;
1915 int r, ifindex;
1916
1917 assert(m);
1918 assert(device);
1919
1920 r = sd_device_get_action(device, &action);
1921 if (r < 0) {
1922 log_device_debug_errno(device, r, "Failed to get udev action, ignoring device: %m");
1923 return 0;
1924 }
1925
1926 /* Ignore the "remove" uevent — let's remove a device only if rtnetlink says so. All other uevents
1927 * are "positive" events in some form, i.e. inform us about a changed or new network interface, that
1928 * still exists — and we are interested in that. */
1929 if (action == SD_DEVICE_REMOVE)
1930 return 0;
1931
1932 r = sd_device_get_ifindex(device, &ifindex);
1933 if (r < 0) {
1934 log_device_debug_errno(device, r, "Ignoring udev %s event for device without ifindex or with invalid ifindex: %m",
1935 device_action_to_string(action));
1936 return 0;
1937 }
1938
1939 r = device_is_renaming(device);
1940 if (r < 0) {
4b9a8c2b 1941 log_device_debug_errno(device, r, "Failed to determine the device is renamed or not, ignoring '%s' uevent: %m",
3be9d62a
YW		 1942 device_action_to_string(action));
1943 return 0;
1944 }
1945 if (r > 0) {
1946 log_device_debug(device, "Interface is under renaming, wait for the interface to be renamed.");
1947 return 0;
1948 }
1949
1950 r = link_get(m, ifindex, &link);
1951 if (r < 0) {
4b9a8c2b 1952 log_device_debug_errno(device, r, "Failed to get link from ifindex %i, ignoring: %m", ifindex);
3be9d62a
YW		 1953 return 0;
1954 }
1955
4b9a8c2b
YW		 1956 r = link_initialized(link, device);
1957 if (r < 0)
1958 link_enter_failed(link);
3be9d62a
YW		 1959
1960 return 0;
1961}
1962
9c0a72f9
TG		 1963static int link_carrier_gained(Link *link) {
1964 int r;
1965
1966 assert(link);
1967
600b7898
YW		 1968 if (link->iftype == ARPHRD_CAN)
1969 /* let's shortcut things for CAN which doesn't need most of what's done below. */
1970 return link_handle_bound_by_list(link);
1971
0894cfe4 1972 r = wifi_get_info(link);
8d968fdd
YW		 1973 if (r < 0)
1974 return r;
1975 if (r > 0) {
8bceafa7 1976 r = link_reconfigure(link, false);
f0269653 1977 if (r < 0)
8d968fdd
YW		 1978 return r;
1979 }
1980
b9ea3d2e 1981 if (IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED)) {
8566df79 1982 r = link_acquire_dynamic_conf(link);
f0269653 1983 if (r < 0)
9c0a72f9 1984 return r;
6fc25497 1985
97108953 1986 r = link_request_static_configs(link);
6fc25497
SS		 1987 if (r < 0)
1988 return r;
9c0a72f9
TG		 1989 }
1990
9a038aac 1991 return link_handle_bound_by_list(link);
9c0a72f9
TG		 1992}
1993
1994static int link_carrier_lost(Link *link) {
1995 int r;
1996
1997 assert(link);
1998
25e992ba 1999 if (link->network && link->network->ignore_carrier_loss)
93b4dab5
SS		 2000 return 0;
2001
600b7898
YW		 2002 if (link->iftype == ARPHRD_CAN)
2003 /* let's shortcut things for CAN which doesn't need most of what's done below. */
2004 return link_handle_bound_by_list(link);
2005
2a99eed0 2006 r = link_stop_engines(link, false);
9c0a72f9
TG		 2007 if (r < 0) {
2008 link_enter_failed(link);
2009 return r;
2010 }
2011
19d9a5ad
YW		 2012 link_drop_requests(link);
2013
3104883d
SS		 2014 r = link_drop_config(link);
2015 if (r < 0)
2016 return r;
2017
2c7b826d 2018 if (!IN_SET(link->state, LINK_STATE_UNMANAGED, LINK_STATE_PENDING, LINK_STATE_INITIALIZED)) {
942cf4b8 2019 log_link_debug(link, "State is %s, dropping foreign config", link_state_to_string(link->state));
c436d553
MM		 2020 r = link_drop_foreign_config(link);
2021 if (r < 0)
2022 return r;
2023 }
3104883d 2024
0c9ee5d5
YW		 2025 r = link_handle_bound_by_list(link);
2026 if (r < 0)
2027 return r;
2028
2029 return 0;
2030}
2031
2032int link_carrier_reset(Link *link) {
2033 int r;
2034
2035 assert(link);
2036
2037 if (link_has_carrier(link)) {
2038 r = link_carrier_lost(link);
2039 if (r < 0)
2040 return r;
2041
2042 r = link_carrier_gained(link);
2043 if (r < 0)
2044 return r;
2045
2046 log_link_info(link, "Reset carrier");
2047 }
2048
2049 return 0;
2050}
2051
2052static int link_admin_state_up(Link *link) {
2053 int r;
2054
2055 assert(link);
2056
2057 /* This is called every time an interface admin state changes to up;
2058 * specifically, when IFF_UP flag changes from unset to set. */
2059
2060 if (!link->network)
2061 return 0;
2062
2063 if (link->network->activation_policy == ACTIVATION_POLICY_ALWAYS_DOWN) {
2064 log_link_info(link, "ActivationPolicy is \"always-off\", forcing link down");
2065 return link_down(link, NULL);
2066 }
2067
2068 /* We set the ipv6 mtu after the device mtu, but the kernel resets
2069 * ipv6 mtu on NETDEV_UP, so we need to reset it. */
2070 r = link_set_ipv6_mtu(link);
2071 if (r < 0)
2072 log_link_warning_errno(link, r, "Cannot set IPv6 MTU, ignoring: %m");
2073
2074 return 0;
2075}
2076
2077static int link_admin_state_down(Link *link) {
2078 assert(link);
2079
2080 if (!link->network)
2081 return 0;
2082
2083 if (link->network->activation_policy == ACTIVATION_POLICY_ALWAYS_UP) {
2084 if (streq_ptr(link->kind, "can") && !link->can_configured)
2085 /* CAN device needs to be down on configure. */
2086 return 0;
2087
2088 log_link_info(link, "ActivationPolicy is \"always-on\", forcing link up");
2089 return link_up(link);
2090 }
2091
2092 return 0;
2093}
2094
2095bool link_has_carrier(Link *link) {
2096 /* see Documentation/networking/operstates.txt in the kernel sources */
2097
2098 if (link->kernel_operstate == IF_OPER_UP)
2099 return true;
2100
2101 if (link->kernel_operstate == IF_OPER_UNKNOWN)
2102 /* operstate may not be implemented, so fall back to flags */
2103 if (FLAGS_SET(link->flags, IFF_LOWER_UP | IFF_RUNNING) &&
2104 !FLAGS_SET(link->flags, IFF_DORMANT))
2105 return true;
2106
2107 return false;
2108}
2109
2110static bool link_is_enslaved(Link *link) {
2111 if (link->flags & IFF_SLAVE)
2112 /* Even if the link is not managed by networkd, honor IFF_SLAVE flag. */
2113 return true;
2114
2115 if (!link->network)
2116 return false;
2117
2118 if (link->master_ifindex > 0 && link->network->bridge)
2119 return true;
2120
2121 /* TODO: add conditions for other netdevs. */
2122
2123 return false;
2124}
2125
2126static LinkAddressState address_state_from_scope(uint8_t scope) {
2127 if (scope < RT_SCOPE_SITE)
2128 /* universally accessible addresses found */
2129 return LINK_ADDRESS_STATE_ROUTABLE;
2130
2131 if (scope < RT_SCOPE_HOST)
2132 /* only link or site local addresses found */
2133 return LINK_ADDRESS_STATE_DEGRADED;
2134
2135 /* no useful addresses found */
2136 return LINK_ADDRESS_STATE_OFF;
2137}
2138
2139void link_update_operstate(Link *link, bool also_update_master) {
2140 LinkOperationalState operstate;
2141 LinkCarrierState carrier_state;
2142 LinkAddressState ipv4_address_state, ipv6_address_state, address_state;
2143 LinkOnlineState online_state;
2144 _cleanup_strv_free_ char **p = NULL;
2145 uint8_t ipv4_scope = RT_SCOPE_NOWHERE, ipv6_scope = RT_SCOPE_NOWHERE;
2146 bool changed = false;
2147 Address *address;
2148
2149 assert(link);
2150
2151 if (link->kernel_operstate == IF_OPER_DORMANT)
2152 carrier_state = LINK_CARRIER_STATE_DORMANT;
2153 else if (link_has_carrier(link)) {
2154 if (link_is_enslaved(link))
2155 carrier_state = LINK_CARRIER_STATE_ENSLAVED;
2156 else
2157 carrier_state = LINK_CARRIER_STATE_CARRIER;
2158 } else if (link->flags & IFF_UP)
2159 carrier_state = LINK_CARRIER_STATE_NO_CARRIER;
2160 else
2161 carrier_state = LINK_CARRIER_STATE_OFF;
2162
2163 if (carrier_state >= LINK_CARRIER_STATE_CARRIER) {
2164 Link *slave;
2165
2166 SET_FOREACH(slave, link->slaves) {
2167 link_update_operstate(slave, false);
2168
2169 if (slave->carrier_state < LINK_CARRIER_STATE_CARRIER)
2170 carrier_state = LINK_CARRIER_STATE_DEGRADED_CARRIER;
2171 }
2172 }
2173
2174 SET_FOREACH(address, link->addresses) {
2175 if (!address_is_ready(address))
2176 continue;
2177
2178 if (address->family == AF_INET)
2179 ipv4_scope = MIN(ipv4_scope, address->scope);
2180
2181 if (address->family == AF_INET6)
2182 ipv6_scope = MIN(ipv6_scope, address->scope);
2183 }
2184
2185 /* for operstate we also take foreign addresses into account */
2186 SET_FOREACH(address, link->addresses_foreign) {
2187 if (!address_is_ready(address))
2188 continue;
2189
2190 if (address->family == AF_INET)
2191 ipv4_scope = MIN(ipv4_scope, address->scope);
2192
2193 if (address->family == AF_INET6)
2194 ipv6_scope = MIN(ipv6_scope, address->scope);
2195 }
2196
2197 ipv4_address_state = address_state_from_scope(ipv4_scope);
2198 ipv6_address_state = address_state_from_scope(ipv6_scope);
2199 address_state = address_state_from_scope(MIN(ipv4_scope, ipv6_scope));
2200
2201 /* Mapping of address and carrier state vs operational state
2202 * carrier state
2203 * | off | no-carrier | dormant | degraded-carrier | carrier | enslaved
2204 * ------------------------------------------------------------------------------
2205 * off | off | no-carrier | dormant | degraded-carrier | carrier | enslaved
2206 * address_state degraded | off | no-carrier | dormant | degraded-carrier | degraded | enslaved
2207 * routable | off | no-carrier | dormant | degraded-carrier | routable | routable
2208 */
2209
2210 if (carrier_state < LINK_CARRIER_STATE_CARRIER || address_state == LINK_ADDRESS_STATE_OFF)
2211 operstate = (LinkOperationalState) carrier_state;
2212 else if (address_state == LINK_ADDRESS_STATE_ROUTABLE)
2213 operstate = LINK_OPERSTATE_ROUTABLE;
2214 else if (carrier_state == LINK_CARRIER_STATE_CARRIER)
2215 operstate = LINK_OPERSTATE_DEGRADED;
2216 else
2217 operstate = LINK_OPERSTATE_ENSLAVED;
2218
2219 /* Only determine online state for managed links with RequiredForOnline=yes */
2220 if (!link->network || !link->network->required_for_online)
2221 online_state = _LINK_ONLINE_STATE_INVALID;
2222 else if (operstate < link->network->required_operstate_for_online.min ||
2223 operstate > link->network->required_operstate_for_online.max)
2224 online_state = LINK_ONLINE_STATE_OFFLINE;
2225 else {
2226 AddressFamily required_family = link->network->required_family_for_online;
2227 bool needs_ipv4 = required_family & ADDRESS_FAMILY_IPV4;
2228 bool needs_ipv6 = required_family & ADDRESS_FAMILY_IPV6;
2229
2230 /* The operational state is within the range required for online.
2231 * If a particular address family is also required, we might revert
2232 * to offline in the blocks below. */
2233 online_state = LINK_ONLINE_STATE_ONLINE;
2234
2235 if (link->network->required_operstate_for_online.min >= LINK_OPERSTATE_DEGRADED) {
2236 if (needs_ipv4 && ipv4_address_state < LINK_ADDRESS_STATE_DEGRADED)
2237 online_state = LINK_ONLINE_STATE_OFFLINE;
2238 if (needs_ipv6 && ipv6_address_state < LINK_ADDRESS_STATE_DEGRADED)
2239 online_state = LINK_ONLINE_STATE_OFFLINE;
2240 }
2241
2242 if (link->network->required_operstate_for_online.min >= LINK_OPERSTATE_ROUTABLE) {
2243 if (needs_ipv4 && ipv4_address_state < LINK_ADDRESS_STATE_ROUTABLE)
2244 online_state = LINK_ONLINE_STATE_OFFLINE;
2245 if (needs_ipv6 && ipv6_address_state < LINK_ADDRESS_STATE_ROUTABLE)
2246 online_state = LINK_ONLINE_STATE_OFFLINE;
2247 }
2248 }
2249
2250 if (link->carrier_state != carrier_state) {
2251 link->carrier_state = carrier_state;
2252 changed = true;
2253 if (strv_extend(&p, "CarrierState") < 0)
2254 log_oom();
2255 }
2256
2257 if (link->address_state != address_state) {
2258 link->address_state = address_state;
2259 changed = true;
2260 if (strv_extend(&p, "AddressState") < 0)
2261 log_oom();
2262 }
0d4ad91d 2263
0c9ee5d5
YW		 2264 if (link->ipv4_address_state != ipv4_address_state) {
2265 link->ipv4_address_state = ipv4_address_state;
2266 changed = true;
2267 if (strv_extend(&p, "IPv4AddressState") < 0)
2268 log_oom();
2269 }
9c0a72f9 2270
0c9ee5d5
YW		 2271 if (link->ipv6_address_state != ipv6_address_state) {
2272 link->ipv6_address_state = ipv6_address_state;
2273 changed = true;
2274 if (strv_extend(&p, "IPv6AddressState") < 0)
2275 log_oom();
2276 }
9c0a72f9 2277
0c9ee5d5
YW		 2278 if (link->operstate != operstate) {
2279 link->operstate = operstate;
2280 changed = true;
2281 if (strv_extend(&p, "OperationalState") < 0)
2282 log_oom();
2283 }
9c0a72f9 2284
0c9ee5d5
YW		 2285 if (link->online_state != online_state) {
2286 link->online_state = online_state;
2287 changed = true;
2288 if (strv_extend(&p, "OnlineState") < 0)
2289 log_oom();
2290 }
9c0a72f9 2291
0c9ee5d5
YW		 2292 if (p)
2293 link_send_changed_strv(link, p);
2294 if (changed)
2295 link_dirty(link);
9c0a72f9 2296
0c9ee5d5
YW		 2297 if (also_update_master) {
2298 Link *master;
9c0a72f9 2299
0c9ee5d5
YW		 2300 if (link_get_master(link, &master) >= 0)
2301 link_update_operstate(master, true);
2302 }
9c0a72f9
TG		 2303}
2304
0c9ee5d5
YW		 2305#define FLAG_STRING(string, flag, old, new) \
2306 (((old ^ new) & flag) \
2307 ? ((old & flag) ? (" -" string) : (" +" string)) \
2308 : "")
2309
2310static int link_update_flags(Link *link, sd_netlink_message *m, bool force_update_operstate) {
2311 uint8_t operstate;
2312 unsigned flags;
d236718c
DS		 2313 int r;
2314
61135582
DS		 2315 assert(link);
2316
0c9ee5d5
YW		 2317 r = sd_rtnl_message_link_get_flags(m, &flags);
2318 if (r < 0)
2319 return log_link_warning_errno(link, r, "Could not get link flags: %m");
3be9d62a 2320
0c9ee5d5
YW		 2321 r = sd_netlink_message_read_u8(m, IFLA_OPERSTATE, &operstate);
2322 if (r < 0)
2323 /* if we got a message without operstate, take it to mean
2324 the state was unchanged */
2325 operstate = link->kernel_operstate;
2326
2327 if (!force_update_operstate && (link->flags == flags) && (link->kernel_operstate == operstate))
61135582
DS		 2328 return 0;
2329
0c9ee5d5
YW		 2330 if (link->flags != flags) {
2331 unsigned unknown_flags, unknown_flags_added, unknown_flags_removed;
61135582 2332
0c9ee5d5
YW		 2333 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",
2334 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
2335 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
2336 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
2337 FLAG_STRING("UP", IFF_UP, link->flags, flags),
2338 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
2339 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
2340 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
2341 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
2342 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
2343 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
2344 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
2345 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
2346 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
2347 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
2348 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
2349 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
2350 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
2351 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
2352 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
d236718c 2353
0c9ee5d5
YW		 2354 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
2355 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
2356 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
2357 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
2358 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
2359 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
2360 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
2361 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
d236718c 2362
0c9ee5d5
YW		 2363 if (unknown_flags_added)
2364 log_link_debug(link, "Unknown link flags gained, ignoring: %#.5x", unknown_flags_added);
61135582 2365
0c9ee5d5
YW		 2366 if (unknown_flags_removed)
2367 log_link_debug(link, "Unknown link flags lost, ignoring: %#.5x", unknown_flags_removed);
2368 }
61135582 2369
0c9ee5d5
YW		 2370 link->flags = flags;
2371 link->kernel_operstate = operstate;
36161cba 2372
0c9ee5d5 2373 link_update_operstate(link, true);
61135582
DS		 2374
2375 return 0;
2376}
2377
3be9d62a 2378static int link_update(Link *link, sd_netlink_message *m) {
b8162cd2 2379 hw_addr_data hw_addr;
ca4e095a 2380 const char *ifname;
afe7fd56 2381 uint32_t mtu;
d236718c 2382 bool had_carrier, carrier_gained, carrier_lost, link_was_admin_up;
bb262ef0 2383 int old_master, r;
22936833 2384
dd3efc09 2385 assert(link);
b8941f74 2386 assert(link->ifname);
22936833
TG		 2387 assert(m);
2388
7619683b 2389 if (link->state == LINK_STATE_LINGER) {
5238e957 2390 log_link_info(link, "Link re-added");
289e6774 2391 link_set_state(link, LINK_STATE_CONFIGURING);
0d4ad91d
AR		 2392
2393 r = link_new_carrier_maps(link);
2394 if (r < 0)
2395 return r;
7619683b
TG		 2396 }
2397
1c4baffc 2398 r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
b8941f74 2399 if (r >= 0 && !streq(ifname, link->ifname)) {
30de2b89 2400 Manager *manager = link->manager;
b8941f74 2401
30de2b89 2402 log_link_info(link, "Interface name change detected, %s has been renamed to %s.", link->ifname, ifname);
0d4ad91d 2403
30de2b89
YW		 2404 link_drop(link);
2405 r = link_add(manager, m, &link);
2406 if (r < 0)
2407 return r;
0b54c870
YW		 2408 } else {
2409 r = link_update_alternative_names(link, m);
2410 if (r < 0)
2411 return r;
b8941f74
TG		 2412 }
2413
1c4baffc 2414 r = sd_netlink_message_read_u32(m, IFLA_MTU, &mtu);
afe7fd56
TG		 2415 if (r >= 0 && mtu > 0) {
2416 link->mtu = mtu;
4e964aa0 2417 if (link->original_mtu == 0) {
afe7fd56 2418 link->original_mtu = mtu;
6a7a4e4d 2419 log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
afe7fd56
TG		 2420 }
2421
2422 if (link->dhcp_client) {
3c9b8860
TG		 2423 r = sd_dhcp_client_set_mtu(link->dhcp_client,
2424 link->mtu);
fc95c359
YW		 2425 if (r < 0)
2426 return log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
afe7fd56 2427 }
7465dd22
PF		 2428
2429 if (link->radv) {
2430 r = sd_radv_set_mtu(link->radv, link->mtu);
2431 if (r < 0)
2432 return log_link_warning_errno(link, r, "Could not set MTU for Router Advertisement: %m");
2433 }
9842de0d 2434 }
69629de9 2435
e9189a1f
TG		 2436 /* The kernel may broadcast NEWLINK messages without the MAC address
2437 set, simply ignore them. */
b8162cd2
TR		 2438 r = netlink_message_read_hw_addr(m, IFLA_ADDRESS, &hw_addr);
2439 if (r >= 0 && (link->hw_addr.length != hw_addr.length ||
2440 memcmp(link->hw_addr.addr.bytes, hw_addr.addr.bytes, hw_addr.length) != 0)) {
807667f7 2441
b8162cd2 2442 memcpy(link->hw_addr.addr.bytes, hw_addr.addr.bytes, hw_addr.length);
807667f7 2443
b8162cd2 2444 log_link_debug(link, "Gained new hardware address: %s", HW_ADDR_TO_STR(&hw_addr));
807667f7 2445
a3adb4a6
YW		 2446 r = ipv4ll_update_mac(link);
2447 if (r < 0)
2448 return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
807667f7 2449
d947f7f9
YW		 2450 r = dhcp4_update_mac(link);
2451 if (r < 0)
2452 return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
413708d1 2453
eebba6dc
YW		 2454 r = dhcp6_update_mac(link);
2455 if (r < 0)
2456 return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
7465dd22 2457
d0c4275c 2458 r = radv_update_mac(link);
be9363cc
YW		 2459 if (r < 0)
2460 return log_link_warning_errno(link, r, "Could not update MAC address for Router Advertisement: %m");
807667f7
YW		 2461
2462 if (link->ndisc) {
b8162cd2 2463 r = sd_ndisc_set_mac(link->ndisc, &link->hw_addr.addr.ether);
807667f7
YW		 2464 if (r < 0)
2465 return log_link_warning_errno(link, r, "Could not update MAC for NDisc: %m");
2466 }
d93d655c 2467
dfc58b47
YW		 2468 if (link->lldp) {
2469 r = sd_lldp_set_filter_address(link->lldp, &link->hw_addr.addr.ether);
2470 if (r < 0)
2471 return log_link_warning_errno(link, r, "Could not update MAC address for LLDP: %m");
2472 }
2473
d93d655c
YW		 2474 r = ipv4_dad_update_mac(link);
2475 if (r < 0)
2476 return log_link_warning_errno(link, r, "Could not update MAC address in IPv4 ACD client: %m");
4f882b2a
TG		 2477 }
2478
bb262ef0
YW		 2479 old_master = link->master_ifindex;
2480 (void) sd_netlink_message_read_u32(m, IFLA_MASTER, (uint32_t *) &link->master_ifindex);
2481
d236718c 2482 link_was_admin_up = link->flags & IFF_UP;
a61bb41c
TG		 2483 had_carrier = link_has_carrier(link);
2484
bb262ef0 2485 r = link_update_flags(link, m, old_master != link->master_ifindex);
a61bb41c
TG		 2486 if (r < 0)
2487 return r;
2488
d236718c
DS		 2489 if (!link_was_admin_up && (link->flags & IFF_UP)) {
2490 log_link_info(link, "Link UP");
2491
2492 r = link_admin_state_up(link);
2493 if (r < 0)
2494 return r;
61135582 2495 } else if (link_was_admin_up && !(link->flags & IFF_UP)) {
d236718c
DS		 2496 log_link_info(link, "Link DOWN");
2497
61135582
DS		 2498 r = link_admin_state_down(link);
2499 if (r < 0)
2500 return r;
2501 }
2502
273eec24
LP		 2503 r = link_update_lldp(link);
2504 if (r < 0)
2505 return r;
2506
a61bb41c
TG		 2507 carrier_gained = !had_carrier && link_has_carrier(link);
2508 carrier_lost = had_carrier && !link_has_carrier(link);
2509
2510 if (carrier_gained) {
6a7a4e4d 2511 log_link_info(link, "Gained carrier");
a61bb41c 2512
9c0a72f9
TG		 2513 r = link_carrier_gained(link);
2514 if (r < 0)
2515 return r;
a61bb41c 2516 } else if (carrier_lost) {
6a7a4e4d 2517 log_link_info(link, "Lost carrier");
a61bb41c 2518
9c0a72f9
TG		 2519 r = link_carrier_lost(link);
2520 if (r < 0)
a61bb41c 2521 return r;
a61bb41c
TG		 2522 }
2523
2524 return 0;
dd3efc09 2525}
fe8db0c5 2526
0c9ee5d5
YW		 2527static Link *link_drop_or_unref(Link *link) {
2528 if (!link)
2529 return NULL;
2530 if (!link->manager)
2531 return link_unref(link);
2532 return link_drop(link);
2533}
2534
2535DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_drop_or_unref);
2536
2537static int link_new(Manager *manager, sd_netlink_message *message, Link **ret) {
2538 _cleanup_(link_drop_or_unrefp) Link *link = NULL;
2539 _cleanup_free_ char *ifname = NULL, *kind = NULL;
2540 unsigned short iftype;
2541 int r, ifindex;
2542 uint16_t type;
2543
2544 assert(manager);
2545 assert(message);
2546 assert(ret);
2547
2548 r = sd_netlink_message_get_type(message, &type);
2549 if (r < 0)
2550 return r;
2551 else if (type != RTM_NEWLINK)
2552 return -EINVAL;
2553
2554 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
2555 if (r < 0)
2556 return r;
2557 else if (ifindex <= 0)
2558 return -EINVAL;
2559
2560 r = sd_rtnl_message_link_get_type(message, &iftype);
2561 if (r < 0)
2562 return r;
2563
2564 r = sd_netlink_message_read_string_strdup(message, IFLA_IFNAME, &ifname);
2565 if (r < 0)
2566 return r;
2567
2568 /* check for link kind */
2569 r = sd_netlink_message_enter_container(message, IFLA_LINKINFO);
2570 if (r >= 0) {
2571 (void) sd_netlink_message_read_string_strdup(message, IFLA_INFO_KIND, &kind);
2572 r = sd_netlink_message_exit_container(message);
2573 if (r < 0)
2574 return r;
2575 }
2576
2577 link = new(Link, 1);
2578 if (!link)
2579 return -ENOMEM;
2580
2581 *link = (Link) {
2582 .n_ref = 1,
2583 .state = LINK_STATE_PENDING,
2584 .online_state = _LINK_ONLINE_STATE_INVALID,
2585 .ifindex = ifindex,
2586 .iftype = iftype,
2587 .ifname = TAKE_PTR(ifname),
2588 .kind = TAKE_PTR(kind),
2589
2590 .n_dns = UINT_MAX,
2591 .dns_default_route = -1,
2592 .llmnr = _RESOLVE_SUPPORT_INVALID,
2593 .mdns = _RESOLVE_SUPPORT_INVALID,
2594 .dnssec_mode = _DNSSEC_MODE_INVALID,
2595 .dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID,
2596 };
2597
2598 r = hashmap_ensure_put(&manager->links, NULL, INT_TO_PTR(link->ifindex), link);
2599 if (r < 0)
2600 return r;
2601
2602 link->manager = manager;
2603
2604 r = sd_netlink_message_read_u32(message, IFLA_MASTER, (uint32_t*) &link->master_ifindex);
2605 if (r < 0)
2606 log_link_debug_errno(link, r, "New device has no master, continuing without");
2607
2608 r = netlink_message_read_hw_addr(message, IFLA_ADDRESS, &link->hw_addr);
2609 if (r < 0)
2610 log_link_debug_errno(link, r, "Hardware address not found for new device, continuing without");
2611
2612 r = netlink_message_read_hw_addr(message, IFLA_BROADCAST, &link->bcast_addr);
2613 if (r < 0)
2614 log_link_debug_errno(link, r, "Broadcast address not found for new device, continuing without");
2615
2616 r = ethtool_get_permanent_macaddr(&manager->ethtool_fd, link->ifname, &link->permanent_mac);
2617 if (r < 0)
2618 log_link_debug_errno(link, r, "Permanent MAC address not found for new device, continuing without: %m");
2619
2620 r = ethtool_get_driver(&manager->ethtool_fd, link->ifname, &link->driver);
2621 if (r < 0)
2622 log_link_debug_errno(link, r, "Failed to get driver, continuing without: %m");
2623
2624 if (asprintf(&link->state_file, "/run/systemd/netif/links/%d", link->ifindex) < 0)
2625 return -ENOMEM;
2626
2627 if (asprintf(&link->lease_file, "/run/systemd/netif/leases/%d", link->ifindex) < 0)
2628 return -ENOMEM;
2629
2630 if (asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d", link->ifindex) < 0)
2631 return -ENOMEM;
2632
2633 r = hashmap_ensure_put(&manager->links_by_name, &string_hash_ops, link->ifname, link);
2634 if (r < 0)
2635 return r;
2636
2637 r = link_update_alternative_names(link, message);
2638 if (r < 0)
2639 return r;
2640
2641 r = link_update_flags(link, message, false);
2642 if (r < 0)
2643 return r;
2644
2645 *ret = TAKE_PTR(link);
2646
2647 return 0;
2648}
2649
3be9d62a
YW		 2650int manager_rtnl_process_link(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
2651 Link *link = NULL;
2652 NetDev *netdev = NULL;
2653 uint16_t type;
2654 const char *name;
2655 int r, ifindex;
2656
2657 assert(rtnl);
2658 assert(message);
2659 assert(m);
2660
2661 if (sd_netlink_message_is_error(message)) {
2662 r = sd_netlink_message_get_errno(message);
2663 if (r < 0)
2664 log_message_warning_errno(message, r, "rtnl: Could not receive link message, ignoring");
2665
2666 return 0;
2667 }
2668
2669 r = sd_netlink_message_get_type(message, &type);
2670 if (r < 0) {
2671 log_warning_errno(r, "rtnl: Could not get message type, ignoring: %m");
2672 return 0;
2673 } else if (!IN_SET(type, RTM_NEWLINK, RTM_DELLINK)) {
2674 log_warning("rtnl: Received unexpected message type %u when processing link, ignoring.", type);
2675 return 0;
2676 }
2677
2678 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
2679 if (r < 0) {
2680 log_warning_errno(r, "rtnl: Could not get ifindex from link message, ignoring: %m");
2681 return 0;
2682 } else if (ifindex <= 0) {
2683 log_warning("rtnl: received link message with invalid ifindex %d, ignoring.", ifindex);
2684 return 0;
2685 }
2686
2687 r = sd_netlink_message_read_string(message, IFLA_IFNAME, &name);
2688 if (r < 0) {
2689 log_warning_errno(r, "rtnl: Received link message without ifname, ignoring: %m");
2690 return 0;
2691 }
2692
2693 (void) link_get(m, ifindex, &link);
2694 (void) netdev_get(m, name, &netdev);
2695
2696 switch (type) {
2697 case RTM_NEWLINK:
2698 if (!link) {
2699 /* link is new, so add it */
2700 r = link_add(m, message, &link);
2701 if (r < 0) {
2702 log_warning_errno(r, "Could not process new link message, ignoring: %m");
2703 return 0;
2704 }
2705 }
2706
2707 if (netdev) {
2708 /* netdev exists, so make sure the ifindex matches */
2709 r = netdev_set_ifindex(netdev, message);
2710 if (r < 0) {
2711 log_warning_errno(r, "Could not process new link message for netdev, ignoring: %m");
2712 return 0;
2713 }
2714 }
2715
2716 r = link_update(link, message);
2717 if (r < 0) {
f0269653
YW		 2718 log_warning_errno(r, "Could not process link message: %m");
2719 link_enter_failed(link);
3be9d62a
YW		 2720 return 0;
2721 }
2722
2723 break;
2724
2725 case RTM_DELLINK:
2726 link_drop(link);
2727 netdev_drop(netdev);
2728
2729 break;
2730
2731 default:
2732 assert_not_reached("Received link message with invalid RTNL message type.");
2733 }
2734
2735 return 1;
2736}
2737
fe8db0c5 2738static const char* const link_state_table[_LINK_STATE_MAX] = {
8434fd5c 2739 [LINK_STATE_PENDING] = "pending",
bd08ce56 2740 [LINK_STATE_INITIALIZED] = "initialized",
289e6774 2741 [LINK_STATE_CONFIGURING] = "configuring",
fe8db0c5 2742 [LINK_STATE_CONFIGURED] = "configured",
57bd6899 2743 [LINK_STATE_UNMANAGED] = "unmanaged",
fe8db0c5 2744 [LINK_STATE_FAILED] = "failed",
370e9930 2745 [LINK_STATE_LINGER] = "linger",
fe8db0c5
TG		 2746};
2747
2748DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
Unnamed repository; edit this file 'description' to name the repository.