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