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