]> 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
Merge pull request #14252 from keszybz/growfs-port-resizefs
[thirdparty/systemd.git] / src / network / networkd-link.c
CommitLineData
53e1b683 1/* SPDX-License-Identifier: LGPL-2.1+ */
f579559b 2
9aa5d8ba 3#include <netinet/in.h>
f579559b 4#include <linux/if.h>
8f815e8b 5#include <linux/if_arp.h>
4cc7a82c 6#include <unistd.h>
f579559b 7
b5efdb8a 8#include "alloc-util.h"
737f1405
YW		 9#include "bond.h"
10#include "bridge.h"
1346b1f0 11#include "bus-util.h"
27dfc982 12#include "dhcp-identifier.h"
bd91b83e 13#include "dhcp-lease-internal.h"
686d13b9 14#include "env-file.h"
3ffd4af2 15#include "fd-util.h"
cf1d700d 16#include "fileio.h"
737f1405 17#include "ipvlan.h"
ef118d00 18#include "missing_network.h"
cf1d700d 19#include "netlink-util.h"
c6f7c917 20#include "network-internal.h"
3ddcbeea 21#include "networkd-can.h"
8fcf1d61 22#include "networkd-dhcp-server.h"
ca5ad760
YW		 23#include "networkd-dhcp4.h"
24#include "networkd-dhcp6.h"
25#include "networkd-ipv4ll.h"
a0e5c15d 26#include "networkd-ipv6-proxy-ndp.h"
6a1af3d4
YW		 27#include "networkd-link-bus.h"
28#include "networkd-link.h"
8e1ad1ea 29#include "networkd-lldp-tx.h"
23f53b99 30#include "networkd-manager.h"
1e7a0e21 31#include "networkd-ndisc.h"
e4a71bf3 32#include "networkd-neighbor.h"
7465dd22 33#include "networkd-radv.h"
bce67bbe 34#include "networkd-routing-policy-rule.h"
8d968fdd 35#include "networkd-wifi.h"
737f1405 36#include "qdisc.h"
cf1d700d
TG		 37#include "set.h"
38#include "socket-util.h"
bf331d87 39#include "stat-util.h"
15a5e950 40#include "stdio-util.h"
8b43440b 41#include "string-table.h"
51517f9e 42#include "strv.h"
62e021a9 43#include "sysctl-util.h"
e4de7287 44#include "tmpfile-util.h"
299ad32d 45#include "udev-util.h"
cf1d700d 46#include "util.h"
737f1405 47#include "vrf.h"
fc2f9534 48
bdb9f580
YW		 49uint32_t link_get_vrf_table(Link *link) {
50 return link->network->vrf ? VRF(link->network->vrf)->table : RT_TABLE_MAIN;
51}
52
53uint32_t link_get_dhcp_route_table(Link *link) {
54 /* When the interface is part of an VRF use the VRFs routing table, unless
55 * another table is explicitly specified. */
56 if (link->network->dhcp_route_table_set)
57 return link->network->dhcp_route_table;
58 return link_get_vrf_table(link);
59}
60
61uint32_t link_get_ipv6_accept_ra_route_table(Link *link) {
62 if (link->network->ipv6_accept_ra_route_table_set)
63 return link->network->ipv6_accept_ra_route_table;
64 return link_get_vrf_table(link);
65}
66
f24648a6
YW		 67DUID* link_get_duid(Link *link) {
68 if (link->network->duid.type != _DUID_TYPE_INVALID)
69 return &link->network->duid;
70 else
71 return &link->manager->duid;
72}
73
b9d74c40
LP		 74static bool link_dhcp6_enabled(Link *link) {
75 assert(link);
76
fa709992
LP		 77 if (!socket_ipv6_is_supported())
78 return false;
79
78c958f8
TG		 80 if (link->flags & IFF_LOOPBACK)
81 return false;
82
83 if (!link->network)
84 return false;
85
f2bfcdb9
YW		 86 if (link->network->bond)
87 return false;
88
500b96eb 89 if (link->iftype == ARPHRD_CAN)
af9ba57a
YW		 90 return false;
91
e0ee46f2 92 return link->network->dhcp & ADDRESS_FAMILY_IPV6;
78c958f8
TG		 93}
94
b9d74c40
LP		 95static bool link_dhcp4_enabled(Link *link) {
96 assert(link);
97
78c958f8
TG		 98 if (link->flags & IFF_LOOPBACK)
99 return false;
100
101 if (!link->network)
102 return false;
103
f2bfcdb9
YW		 104 if (link->network->bond)
105 return false;
106
500b96eb 107 if (link->iftype == ARPHRD_CAN)
af9ba57a
YW		 108 return false;
109
e0ee46f2 110 return link->network->dhcp & ADDRESS_FAMILY_IPV4;
78c958f8
TG		 111}
112
b9d74c40
LP		 113static bool link_dhcp4_server_enabled(Link *link) {
114 assert(link);
115
78c958f8
TG		 116 if (link->flags & IFF_LOOPBACK)
117 return false;
118
119 if (!link->network)
120 return false;
121
f2bfcdb9
YW		 122 if (link->network->bond)
123 return false;
124
500b96eb 125 if (link->iftype == ARPHRD_CAN)
af9ba57a
YW		 126 return false;
127
78c958f8
TG		 128 return link->network->dhcp_server;
129}
130
2d792895 131bool link_ipv4ll_enabled(Link *link, AddressFamily mask) {
b9d74c40 132 assert(link);
910feb78 133 assert((mask & ~(ADDRESS_FAMILY_IPV4 | ADDRESS_FAMILY_FALLBACK_IPV4)) == 0);
b9d74c40 134
78c958f8
TG		 135 if (link->flags & IFF_LOOPBACK)
136 return false;
137
138 if (!link->network)
139 return false;
140
500b96eb 141 if (link->iftype == ARPHRD_CAN)
c6ac3729
YW		 142 return false;
143
98d20a17 144 if (STRPTR_IN_SET(link->kind,
145 "vrf", "wireguard", "ipip", "gre", "ip6gre","ip6tnl", "sit", "vti",
c6ac3729 146 "vti6", "nlmon", "xfrm"))
a8f5bba6
JD		 147 return false;
148
f410d463
YW		 149 /* L3 or L3S mode do not support ARP. */
150 if (IN_SET(link_get_ipvlan_mode(link), NETDEV_IPVLAN_MODE_L3, NETDEV_IPVLAN_MODE_L3S))
151 return false;
152
f2bfcdb9
YW		 153 if (link->network->bond)
154 return false;
155
910feb78 156 return link->network->link_local & mask;
8bc17bb3
SS		 157}
158
b9d74c40
LP		 159static bool link_ipv6ll_enabled(Link *link) {
160 assert(link);
161
fa709992
LP		 162 if (!socket_ipv6_is_supported())
163 return false;
164
d0d6a4cd
TG		 165 if (link->flags & IFF_LOOPBACK)
166 return false;
167
168 if (!link->network)
169 return false;
170
500b96eb 171 if (link->iftype == ARPHRD_CAN)
c6ac3729
YW		 172 return false;
173
174 if (STRPTR_IN_SET(link->kind, "vrf", "wireguard", "ipip", "gre", "sit", "vti", "nlmon"))
a8f5bba6
JD		 175 return false;
176
f2bfcdb9
YW		 177 if (link->network->bond)
178 return false;
179
e0ee46f2 180 return link->network->link_local & ADDRESS_FAMILY_IPV6;
78c958f8
TG		 181}
182
439689c6
SS		 183static bool link_ipv6_enabled(Link *link) {
184 assert(link);
185
186 if (!socket_ipv6_is_supported())
187 return false;
188
b102cdca 189 if (link->network->bond)
2b00a4e0
TY		 190 return false;
191
500b96eb 192 if (link->iftype == ARPHRD_CAN)
af9ba57a
YW		 193 return false;
194
4cef7fe3 195 /* DHCPv6 client will not be started if no IPv6 link-local address is configured. */
adfeee49
YW		 196 if (link_ipv6ll_enabled(link))
197 return true;
198
199 if (network_has_static_ipv6_configurations(link->network))
200 return true;
201
202 return false;
439689c6
SS		 203}
204
7465dd22
PF		 205static bool link_radv_enabled(Link *link) {
206 assert(link);
207
208 if (!link_ipv6ll_enabled(link))
209 return false;
210
55a7c78b 211 return link->network->router_prefix_delegation != RADV_PREFIX_DELEGATION_NONE;
7465dd22
PF		 212}
213
769d324c 214static bool link_ipv4_forward_enabled(Link *link) {
b9d74c40
LP		 215 assert(link);
216
5a8bcb67
LP		 217 if (link->flags & IFF_LOOPBACK)
218 return false;
219
220 if (!link->network)
221 return false;
222
2d792895 223 if (link->network->ip_forward == _ADDRESS_FAMILY_INVALID)
765afd5c
LP		 224 return false;
225
e0ee46f2 226 return link->network->ip_forward & ADDRESS_FAMILY_IPV4;
769d324c
LP		 227}
228
229static bool link_ipv6_forward_enabled(Link *link) {
b9d74c40 230 assert(link);
765afd5c
LP		 231
232 if (!socket_ipv6_is_supported())
233 return false;
234
769d324c
LP		 235 if (link->flags & IFF_LOOPBACK)
236 return false;
237
238 if (!link->network)
239 return false;
240
2d792895 241 if (link->network->ip_forward == _ADDRESS_FAMILY_INVALID)
765afd5c
LP		 242 return false;
243
e0ee46f2 244 return link->network->ip_forward & ADDRESS_FAMILY_IPV6;
5a8bcb67
LP		 245}
246
23d8b221
SS		 247static bool link_proxy_arp_enabled(Link *link) {
248 assert(link);
249
250 if (link->flags & IFF_LOOPBACK)
251 return false;
252
253 if (!link->network)
254 return false;
255
256 if (link->network->proxy_arp < 0)
257 return false;
258
259 return true;
260}
261
b9d74c40
LP		 262static bool link_ipv6_accept_ra_enabled(Link *link) {
263 assert(link);
264
fa709992
LP		 265 if (!socket_ipv6_is_supported())
266 return false;
267
f5a8c43f
TG		 268 if (link->flags & IFF_LOOPBACK)
269 return false;
270
271 if (!link->network)
272 return false;
273
702c979f
SS		 274 if (!link_ipv6ll_enabled(link))
275 return false;
276
f5a8c43f
TG		 277 /* If unset use system default (enabled if local forwarding is disabled.
278 * disabled if local forwarding is enabled).
279 * If set, ignore or enforce RA independent of local forwarding state.
280 */
281 if (link->network->ipv6_accept_ra < 0)
282 /* default to accept RA if ip_forward is disabled and ignore RA if ip_forward is enabled */
283 return !link_ipv6_forward_enabled(link);
284 else if (link->network->ipv6_accept_ra > 0)
285 /* accept RA even if ip_forward is enabled */
286 return true;
287 else
288 /* ignore RA */
289 return false;
290}
291
1f0d9695 292static IPv6PrivacyExtensions link_ipv6_privacy_extensions(Link *link) {
fa709992 293 assert(link);
d68e2e59
LP		 294
295 if (!socket_ipv6_is_supported())
296 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
297
49092e22 298 if (link->flags & IFF_LOOPBACK)
1f0d9695 299 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
49092e22
SS		 300
301 if (!link->network)
1f0d9695 302 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
49092e22
SS		 303
304 return link->network->ipv6_privacy_extensions;
305}
306
57ad7607 307static int link_update_ipv6_sysctl(Link *link) {
482efedc 308 bool enabled;
439689c6
SS		 309 int r;
310
311 if (link->flags & IFF_LOOPBACK)
312 return 0;
313
482efedc
SS		 314 enabled = link_ipv6_enabled(link);
315 if (enabled) {
316 r = sysctl_write_ip_property_boolean(AF_INET6, link->ifname, "disable_ipv6", false);
317 if (r < 0)
57ad7607
ZJS		 318 return log_link_warning_errno(link, r, "Cannot enable IPv6: %m");
319
320 log_link_info(link, "IPv6 successfully enabled");
482efedc 321 }
439689c6
SS		 322
323 return 0;
324}
325
34bf3c00
YW		 326static bool link_is_enslaved(Link *link) {
327 if (link->flags & IFF_SLAVE)
328 /* Even if the link is not managed by networkd, honor IFF_SLAVE flag. */
329 return true;
330
34bf3c00
YW		 331 if (!link->network)
332 return false;
333
bb262ef0 334 if (link->master_ifindex > 0 && link->network->bridge)
34bf3c00
YW		 335 return true;
336
bb262ef0
YW		 337 /* TODO: add conditions for other netdevs. */
338
34bf3c00
YW		 339 return false;
340}
341
45e11abf
YW		 342static void link_update_master_operstate(Link *link, NetDev *netdev) {
343 Link *master;
344
345 if (!netdev)
346 return;
347
348 if (link_get(link->manager, netdev->ifindex, &master) < 0)
349 return;
350
351 link_update_operstate(master, true);
352}
353
354void link_update_operstate(Link *link, bool also_update_master) {
84de38c5 355 LinkOperationalState operstate;
1678fbb3
YW		 356 LinkCarrierState carrier_state;
357 LinkAddressState address_state;
35c5a9ca 358 _cleanup_strv_free_ char **p = NULL;
1678fbb3 359 uint8_t scope = RT_SCOPE_NOWHERE;
35c5a9ca 360 bool changed = false;
1678fbb3 361 Address *address;
45e11abf 362 Iterator i;
14153d1b 363
84de38c5
TG		 364 assert(link);
365
366 if (link->kernel_operstate == IF_OPER_DORMANT)
1678fbb3 367 carrier_state = LINK_CARRIER_STATE_DORMANT;
84de38c5 368 else if (link_has_carrier(link)) {
1678fbb3
YW		 369 if (link_is_enslaved(link))
370 carrier_state = LINK_CARRIER_STATE_ENSLAVED;
84de38c5 371 else
1678fbb3 372 carrier_state = LINK_CARRIER_STATE_CARRIER;
84de38c5 373 } else if (link->flags & IFF_UP)
1678fbb3 374 carrier_state = LINK_CARRIER_STATE_NO_CARRIER;
84de38c5 375 else
1678fbb3 376 carrier_state = LINK_CARRIER_STATE_OFF;
84de38c5 377
1678fbb3 378 if (carrier_state >= LINK_CARRIER_STATE_CARRIER) {
959f65d3
YW		 379 Link *slave;
380
5f707e12 381 SET_FOREACH(slave, link->slaves, i) {
959f65d3 382 link_update_operstate(slave, false);
84de38c5 383
1678fbb3
YW		 384 if (slave->carrier_state < LINK_CARRIER_STATE_CARRIER)
385 carrier_state = LINK_CARRIER_STATE_DEGRADED_CARRIER;
84de38c5 386 }
959f65d3 387 }
84de38c5 388
1678fbb3
YW		 389 SET_FOREACH(address, link->addresses, i) {
390 if (!address_is_ready(address))
391 continue;
84de38c5 392
1678fbb3
YW		 393 if (address->scope < scope)
394 scope = address->scope;
395 }
84de38c5 396
1678fbb3
YW		 397 /* for operstate we also take foreign addresses into account */
398 SET_FOREACH(address, link->addresses_foreign, i) {
399 if (!address_is_ready(address))
400 continue;
401
402 if (address->scope < scope)
403 scope = address->scope;
404 }
405
406 if (scope < RT_SCOPE_SITE)
407 /* universally accessible addresses found */
408 address_state = LINK_ADDRESS_STATE_ROUTABLE;
409 else if (scope < RT_SCOPE_HOST)
410 /* only link or site local addresses found */
411 address_state = LINK_ADDRESS_STATE_DEGRADED;
84de38c5 412 else
1678fbb3
YW		 413 /* no useful addresses found */
414 address_state = LINK_ADDRESS_STATE_OFF;
415
416 /* Mapping of address and carrier state vs operational state
417 * carrier state
418 * | off | no-carrier | dormant | degraded-carrier | carrier | enslaved
419 * ------------------------------------------------------------------------------
420 * off | off | no-carrier | dormant | degraded-carrier | carrier | enslaved
421 * address_state degraded | off | no-carrier | dormant | degraded-carrier | degraded | enslaved
422 * routable | off | no-carrier | dormant | degraded-carrier | routable | routable
423 */
84de38c5 424
1678fbb3
YW		 425 if (carrier_state < LINK_CARRIER_STATE_CARRIER || address_state == LINK_ADDRESS_STATE_OFF)
426 operstate = (LinkOperationalState) carrier_state;
427 else if (address_state == LINK_ADDRESS_STATE_ROUTABLE)
428 operstate = LINK_OPERSTATE_ROUTABLE;
429 else if (carrier_state == LINK_CARRIER_STATE_CARRIER)
430 operstate = LINK_OPERSTATE_DEGRADED;
431 else
14153d1b
YW		 432 operstate = LINK_OPERSTATE_ENSLAVED;
433
35c5a9ca
YW		 434 if (link->carrier_state != carrier_state) {
435 link->carrier_state = carrier_state;
436 changed = true;
437 if (strv_extend(&p, "CarrierState") < 0)
438 log_oom();
439 }
959f65d3 440
35c5a9ca
YW		 441 if (link->address_state != address_state) {
442 link->address_state = address_state;
443 changed = true;
444 if (strv_extend(&p, "AddressState") < 0)
445 log_oom();
959f65d3
YW		 446 }
447
84de38c5
TG		 448 if (link->operstate != operstate) {
449 link->operstate = operstate;
35c5a9ca
YW		 450 changed = true;
451 if (strv_extend(&p, "OperationalState") < 0)
452 log_oom();
84de38c5 453 }
959f65d3 454
35c5a9ca
YW		 455 if (p)
456 link_send_changed_strv(link, p);
457 if (changed)
458 link_dirty(link);
459
45e11abf
YW		 460 if (also_update_master && link->network) {
461 link_update_master_operstate(link, link->network->bond);
462 link_update_master_operstate(link, link->network->bridge);
959f65d3 463 }
84de38c5
TG		 464}
465
51d18171
TG		 466#define FLAG_STRING(string, flag, old, new) \
467 (((old ^ new) & flag) \
468 ? ((old & flag) ? (" -" string) : (" +" string)) \
469 : "")
470
bb262ef0 471static int link_update_flags(Link *link, sd_netlink_message *m, bool force_update_operstate) {
51d18171
TG		 472 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
473 uint8_t operstate;
474 int r;
475
476 assert(link);
477
478 r = sd_rtnl_message_link_get_flags(m, &flags);
6a7a4e4d
LP		 479 if (r < 0)
480 return log_link_warning_errno(link, r, "Could not get link flags: %m");
51d18171 481
1c4baffc 482 r = sd_netlink_message_read_u8(m, IFLA_OPERSTATE, &operstate);
51d18171
TG		 483 if (r < 0)
484 /* if we got a message without operstate, take it to mean
485 the state was unchanged */
486 operstate = link->kernel_operstate;
487
bb262ef0 488 if (!force_update_operstate && (link->flags == flags) && (link->kernel_operstate == operstate))
51d18171
TG		 489 return 0;
490
491 if (link->flags != flags) {
6a7a4e4d 492 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		 493 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
494 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
495 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
496 FLAG_STRING("UP", IFF_UP, link->flags, flags),
497 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
498 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
499 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
500 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
501 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
502 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
503 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
504 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
505 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
506 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
507 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
508 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
509 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
510 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
511 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
512
513 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
514 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
515 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
516 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
517 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
518 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
519 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
520 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
521
522 /* link flags are currently at most 18 bits, let's align to
523 * printing 20 */
524 if (unknown_flags_added)
79008bdd 525 log_link_debug(link,
6a7a4e4d 526 "Unknown link flags gained: %#.5x (ignoring)",
51d18171
TG		 527 unknown_flags_added);
528
529 if (unknown_flags_removed)
79008bdd 530 log_link_debug(link,
6a7a4e4d 531 "Unknown link flags lost: %#.5x (ignoring)",
51d18171
TG		 532 unknown_flags_removed);
533 }
534
535 link->flags = flags;
536 link->kernel_operstate = operstate;
537
959f65d3 538 link_update_operstate(link, true);
51d18171
TG		 539
540 return 0;
541}
542
1c4baffc 543static int link_new(Manager *manager, sd_netlink_message *message, Link **ret) {
8e766630 544 _cleanup_(link_unrefp) Link *link = NULL;
505f8da7 545 uint16_t type;
6cad256d 546 const char *ifname, *kind = NULL;
505f8da7 547 int r, ifindex;
b710e6b6 548 unsigned short iftype;
f579559b 549
0c2f9b84 550 assert(manager);
505f8da7 551 assert(message);
f579559b
TG		 552 assert(ret);
553
6cad256d
TJ		 554 /* check for link kind */
555 r = sd_netlink_message_enter_container(message, IFLA_LINKINFO);
556 if (r == 0) {
db2f8a2e 557 (void) sd_netlink_message_read_string(message, IFLA_INFO_KIND, &kind);
6cad256d
TJ		 558 r = sd_netlink_message_exit_container(message);
559 if (r < 0)
560 return r;
561 }
562
1c4baffc 563 r = sd_netlink_message_get_type(message, &type);
505f8da7
TG		 564 if (r < 0)
565 return r;
566 else if (type != RTM_NEWLINK)
567 return -EINVAL;
568
569 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
570 if (r < 0)
571 return r;
572 else if (ifindex <= 0)
573 return -EINVAL;
574
b710e6b6
LP		 575 r = sd_rtnl_message_link_get_type(message, &iftype);
576 if (r < 0)
577 return r;
578
1c4baffc 579 r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
505f8da7
TG		 580 if (r < 0)
581 return r;
582
17f9c355 583 link = new(Link, 1);
f579559b
TG		 584 if (!link)
585 return -ENOMEM;
586
17f9c355
YW		 587 *link = (Link) {
588 .n_ref = 1,
589 .manager = manager,
590 .state = LINK_STATE_PENDING,
17f9c355
YW		 591 .ifindex = ifindex,
592 .iftype = iftype,
15761549
YW		 593
594 .n_dns = (unsigned) -1,
595 .dns_default_route = -1,
596 .llmnr = _RESOLVE_SUPPORT_INVALID,
597 .mdns = _RESOLVE_SUPPORT_INVALID,
598 .dnssec_mode = _DNSSEC_MODE_INVALID,
599 .dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID,
17f9c355
YW		 600 };
601
505f8da7
TG		 602 link->ifname = strdup(ifname);
603 if (!link->ifname)
604 return -ENOMEM;
f579559b 605
6cad256d
TJ		 606 if (kind) {
607 link->kind = strdup(kind);
608 if (!link->kind)
609 return -ENOMEM;
610 }
611
cbff7170
TJ		 612 r = sd_netlink_message_read_u32(message, IFLA_MASTER, (uint32_t *)&link->master_ifindex);
613 if (r < 0)
614 log_link_debug_errno(link, r, "New device has no master, continuing without");
615
1c4baffc 616 r = sd_netlink_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
512922f8 617 if (r < 0)
34437b4f 618 log_link_debug_errno(link, r, "MAC address not found for new device, continuing without");
512922f8 619
34437b4f 620 if (asprintf(&link->state_file, "/run/systemd/netif/links/%d", link->ifindex) < 0)
315db1a8 621 return -ENOMEM;
fe8db0c5 622
34437b4f 623 if (asprintf(&link->lease_file, "/run/systemd/netif/leases/%d", link->ifindex) < 0)
68a8723c
TG		 624 return -ENOMEM;
625
34437b4f 626 if (asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d", link->ifindex) < 0)
49699bac
SS		 627 return -ENOMEM;
628
d5099efc 629 r = hashmap_ensure_allocated(&manager->links, NULL);
ae06ab10
TG		 630 if (r < 0)
631 return r;
632
633 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
f579559b
TG		 634 if (r < 0)
635 return r;
636
bb262ef0 637 r = link_update_flags(link, message, false);
51d18171
TG		 638 if (r < 0)
639 return r;
640
1cc6c93a 641 *ret = TAKE_PTR(link);
f579559b
TG		 642
643 return 0;
644}
645
15761549
YW		 646void link_ntp_settings_clear(Link *link) {
647 link->ntp = strv_free(link->ntp);
648}
649
650void link_dns_settings_clear(Link *link) {
651 link->dns = mfree(link->dns);
652 link->n_dns = (unsigned) -1;
653
654 link->search_domains = ordered_set_free_free(link->search_domains);
655 link->route_domains = ordered_set_free_free(link->route_domains);
656
657 link->dns_default_route = -1;
658 link->llmnr = _RESOLVE_SUPPORT_INVALID;
659 link->mdns = _RESOLVE_SUPPORT_INVALID;
660 link->dnssec_mode = _DNSSEC_MODE_INVALID;
661 link->dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID;
662
663 link->dnssec_negative_trust_anchors = set_free_free(link->dnssec_negative_trust_anchors);
664}
665
1a6bb31f
YW		 666static void link_free_engines(Link *link) {
667 if (!link)
668 return;
669
670 link->dhcp_server = sd_dhcp_server_unref(link->dhcp_server);
671 link->dhcp_client = sd_dhcp_client_unref(link->dhcp_client);
672 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
673 link->dhcp_routes = set_free(link->dhcp_routes);
674
675 link->lldp = sd_lldp_unref(link->lldp);
676
677 ndisc_flush(link);
678
679 link->ipv4ll = sd_ipv4ll_unref(link->ipv4ll);
680 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
681 link->ndisc = sd_ndisc_unref(link->ndisc);
682 link->radv = sd_radv_unref(link->radv);
683}
684
8301aa0b 685static Link *link_free(Link *link) {
428fd0a7
TG		 686 Address *address;
687
8301aa0b 688 assert(link);
f579559b 689
15761549
YW		 690 link_ntp_settings_clear(link);
691 link_dns_settings_clear(link);
692
f535e354
YW		 693 link->routes = set_free_with_destructor(link->routes, route_free);
694 link->routes_foreign = set_free_with_destructor(link->routes_foreign, route_free);
adda1ed9 695
c16c7808
SS		 696 link->nexthops = set_free_with_destructor(link->nexthops, nexthop_free);
697 link->nexthops_foreign = set_free_with_destructor(link->nexthops_foreign, nexthop_free);
698
d1bdafd2
WKI		 699 link->neighbors = set_free_with_destructor(link->neighbors, neighbor_free);
700 link->neighbors_foreign = set_free_with_destructor(link->neighbors_foreign, neighbor_free);
701
f535e354
YW		 702 link->addresses = set_free_with_destructor(link->addresses, address_free);
703 link->addresses_foreign = set_free_with_destructor(link->addresses_foreign, address_free);
adda1ed9 704
11bf3cce
LP		 705 while ((address = link->pool_addresses)) {
706 LIST_REMOVE(addresses, link->pool_addresses, address);
707 address_free(address);
708 }
709
7272b25e 710 link_lldp_emit_stop(link);
1a6bb31f 711 link_free_engines(link);
68a8723c 712 free(link->lease_file);
49699bac
SS		 713 free(link->lldp_file);
714
c166a070 715 free(link->ifname);
ceac4078 716 free(link->kind);
8d968fdd 717 free(link->ssid);
6cad256d 718
db2f8a2e 719 (void) unlink(link->state_file);
fe8db0c5 720 free(link->state_file);
c166a070 721
51517f9e 722 sd_device_unref(link->sd_device);
b5db00e5 723
0d4ad91d 724 hashmap_free(link->bound_to_links);
0d4ad91d
AR		 725 hashmap_free(link->bound_by_links);
726
5f707e12 727 set_free_with_destructor(link->slaves, link_unref);
033295c1 728
c9c908a6
YW		 729 network_unref(link->network);
730
8301aa0b 731 return mfree(link);
14b746f7
TG		 732}
733
8301aa0b 734DEFINE_TRIVIAL_REF_UNREF_FUNC(Link, link, link_free);
14b746f7 735
11a7f229
TG		 736int link_get(Manager *m, int ifindex, Link **ret) {
737 Link *link;
11a7f229
TG		 738
739 assert(m);
11a7f229
TG		 740 assert(ifindex);
741 assert(ret);
742
ae06ab10 743 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
11a7f229
TG		 744 if (!link)
745 return -ENODEV;
746
747 *ret = link;
748
749 return 0;
750}
751
af9ba57a 752void link_set_state(Link *link, LinkState state) {
e331e246
TG		 753 assert(link);
754
755 if (link->state == state)
756 return;
757
0beb9542
YW		 758 log_link_debug(link, "State changed: %s -> %s",
759 link_state_to_string(link->state),
760 link_state_to_string(state));
761
e331e246
TG		 762 link->state = state;
763
764 link_send_changed(link, "AdministrativeState", NULL);
e331e246
TG		 765}
766
57bd6899
TG		 767static void link_enter_unmanaged(Link *link) {
768 assert(link);
769
e331e246 770 link_set_state(link, LINK_STATE_UNMANAGED);
57bd6899 771
84de38c5 772 link_dirty(link);
57bd6899
TG		 773}
774
95355a28 775int link_stop_clients(Link *link, bool may_keep_dhcp) {
111bb8f9
TG		 776 int r = 0, k;
777
778 assert(link);
779 assert(link->manager);
780 assert(link->manager->event);
781
d03073dd
YW		 782 dhcp4_release_old_lease(link);
783
80060352
ZJS		 784 bool keep_dhcp = may_keep_dhcp &&
785 link->network &&
786 (link->manager->restarting ||
787 FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP_ON_STOP));
788
789 if (link->dhcp_client && !keep_dhcp) {
111bb8f9 790 k = sd_dhcp_client_stop(link->dhcp_client);
6a7a4e4d 791 if (k < 0)
36c7d709 792 r = log_link_warning_errno(link, k, "Could not stop DHCPv4 client: %m");
111bb8f9
TG		 793 }
794
ba179154 795 if (link->ipv4ll) {
111bb8f9 796 k = sd_ipv4ll_stop(link->ipv4ll);
6a7a4e4d 797 if (k < 0)
36c7d709 798 r = log_link_warning_errno(link, k, "Could not stop IPv4 link-local: %m");
dd43110f
TG		 799 }
800
f5a8c43f
TG		 801 if (link->dhcp6_client) {
802 k = sd_dhcp6_client_stop(link->dhcp6_client);
803 if (k < 0)
36c7d709 804 r = log_link_warning_errno(link, k, "Could not stop DHCPv6 client: %m");
f5a8c43f 805 }
4138fb2c 806
1e7a0e21
LP		 807 if (link->ndisc) {
808 k = sd_ndisc_stop(link->ndisc);
6a7a4e4d 809 if (k < 0)
36c7d709 810 r = log_link_warning_errno(link, k, "Could not stop IPv6 Router Discovery: %m");
4138fb2c
PF		 811 }
812
7465dd22
PF		 813 if (link->radv) {
814 k = sd_radv_stop(link->radv);
815 if (k < 0)
816 r = log_link_warning_errno(link, k, "Could not stop IPv6 Router Advertisement: %m");
817 }
818
7272b25e 819 link_lldp_emit_stop(link);
111bb8f9
TG		 820 return r;
821}
822
b22d8a00 823void link_enter_failed(Link *link) {
ef1ba606 824 assert(link);
f882c247 825
370e9930 826 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
2139694e
TG		 827 return;
828
6a7a4e4d 829 log_link_warning(link, "Failed");
449f7554 830
e331e246 831 link_set_state(link, LINK_STATE_FAILED);
fe8db0c5 832
95355a28 833 link_stop_clients(link, false);
111bb8f9 834
84de38c5 835 link_dirty(link);
f882c247
TG		 836}
837
7033af49
YW		 838static int link_join_netdevs_after_configured(Link *link) {
839 NetDev *netdev;
840 Iterator i;
841 int r;
842
843 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
844 if (netdev->ifindex > 0)
845 /* Assume already enslaved. */
846 continue;
847
848 if (netdev_get_create_type(netdev) != NETDEV_CREATE_AFTER_CONFIGURED)
849 continue;
850
851 log_struct(LOG_DEBUG,
852 LOG_LINK_INTERFACE(link),
853 LOG_NETDEV_INTERFACE(netdev),
854 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname));
855
856 r = netdev_join(netdev, link, NULL);
857 if (r < 0)
858 return log_struct_errno(LOG_WARNING, r,
859 LOG_LINK_INTERFACE(link),
860 LOG_NETDEV_INTERFACE(netdev),
861 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname));
862 }
863
864 return 0;
865}
866
e3a7b048 867static void link_enter_configured(Link *link) {
dd43110f
TG		 868 assert(link);
869 assert(link->network);
e3a7b048 870
289e6774 871 if (link->state != LINK_STATE_CONFIGURING)
e3a7b048 872 return;
dd43110f 873
e331e246 874 link_set_state(link, LINK_STATE_CONFIGURED);
dd43110f 875
7033af49
YW		 876 (void) link_join_netdevs_after_configured(link);
877
84de38c5 878 link_dirty(link);
dd43110f
TG		 879}
880
47079967 881static int link_request_set_routing_policy_rule(Link *link) {
8a9b3a23
SS		 882 RoutingPolicyRule *rule, *rrule = NULL;
883 int r;
884
885 assert(link);
886 assert(link->network);
887
2428613f
YW		 888 link->routing_policy_rules_configured = false;
889
8a9b3a23 890 LIST_FOREACH(rules, rule, link->network->rules) {
b80a511b 891 r = routing_policy_rule_get(link->manager, rule, &rrule);
ff14e2eb
YW		 892 if (r >= 0) {
893 if (r == 0)
894 (void) routing_policy_rule_make_local(link->manager, rrule);
8a9b3a23
SS		 895 continue;
896 }
897
9f08a578 898 r = routing_policy_rule_configure(rule, link, NULL);
4ff296b0
YW		 899 if (r < 0)
900 return log_link_warning_errno(link, r, "Could not set routing policy rules: %m");
7ef7e550
YW		 901 if (r > 0)
902 link->routing_policy_rule_messages++;
8a9b3a23
SS		 903 }
904
905 routing_policy_rule_purge(link->manager, link);
7715629e
ST		 906 if (link->routing_policy_rule_messages == 0) {
907 link->routing_policy_rules_configured = true;
908 link_check_ready(link);
b425c3ae 909 } else {
7715629e 910 log_link_debug(link, "Setting routing policy rules");
b425c3ae
YW		 911 link_set_state(link, LINK_STATE_CONFIGURING);
912 }
8a9b3a23
SS		 913
914 return 0;
915}
916
c16c7808
SS		 917static int nexthop_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
918 int r;
919
920 assert(link);
921 assert(link->nexthop_messages > 0);
922 assert(IN_SET(link->state, LINK_STATE_CONFIGURING,
923 LINK_STATE_FAILED, LINK_STATE_LINGER));
924
925 link->nexthop_messages--;
926
927 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
928 return 1;
929
930 r = sd_netlink_message_get_errno(m);
931 if (r < 0 && r != -EEXIST) {
5ecb131d 932 log_link_message_warning_errno(link, m, r, "Could not set nexthop");
c16c7808
SS		 933 link_enter_failed(link);
934 return 1;
935 }
936
937 if (link->nexthop_messages == 0) {
938 log_link_debug(link, "Nexthop set");
939 link->static_nexthops_configured = true;
940 link_check_ready(link);
941 }
942
943 return 1;
944}
945
946int link_request_set_nexthop(Link *link) {
947 NextHop *nh;
948 int r;
949
950 LIST_FOREACH(nexthops, nh, link->network->static_nexthops) {
951 r = nexthop_configure(nh, link, nexthop_handler);
952 if (r < 0)
953 return log_link_warning_errno(link, r, "Could not set nexthop: %m");
954 if (r > 0)
955 link->nexthop_messages++;
956 }
957
958 if (link->nexthop_messages == 0) {
959 link->static_nexthops_configured = true;
960 link_check_ready(link);
961 } else {
962 log_link_debug(link, "Setting nexthop");
963 link_set_state(link, LINK_STATE_CONFIGURING);
964 }
965
966 return 1;
967}
968
302a796f 969static int route_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
f882c247
TG		 970 int r;
971
1046bf9b 972 assert(link);
7715629e 973 assert(link->route_messages > 0);
289e6774
WKI		 974 assert(IN_SET(link->state, LINK_STATE_CONFIGURING,
975 LINK_STATE_FAILED, LINK_STATE_LINGER));
f882c247 976
7715629e 977 link->route_messages--;
f882c247 978
77a008c0 979 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
f882c247
TG		 980 return 1;
981
1c4baffc 982 r = sd_netlink_message_get_errno(m);
4ff296b0 983 if (r < 0 && r != -EEXIST) {
5ecb131d 984 log_link_message_warning_errno(link, m, r, "Could not set route");
4ff296b0
YW		 985 link_enter_failed(link);
986 return 1;
987 }
f882c247 988
7715629e 989 if (link->route_messages == 0) {
6a7a4e4d 990 log_link_debug(link, "Routes set");
7715629e 991 link->static_routes_configured = true;
8012cd39 992 link_check_ready(link);
dd3efc09 993 }
f882c247
TG		 994
995 return 1;
996}
997
b5799eeb 998int link_request_set_routes(Link *link) {
bf61b05a
LP		 999 enum {
1000 PHASE_NON_GATEWAY, /* First phase: Routes without a gateway */
1001 PHASE_GATEWAY, /* Second phase: Routes with a gateway */
1002 _PHASE_MAX
1003 } phase;
a6cc569e 1004 Route *rt;
f882c247
TG		 1005 int r;
1006
1007 assert(link);
1008 assert(link->network);
c42ff3a1
WKI		 1009 assert(link->addresses_configured);
1010 assert(link->address_messages == 0);
289e6774 1011 assert(link->state != _LINK_STATE_INVALID);
f882c247 1012
2428613f 1013 link->static_routes_configured = false;
c16c7808 1014 link->static_routes_ready = false;
27c34f73 1015
4e2ef9d9
YW		 1016 if (!link_has_carrier(link) && !link->network->configure_without_carrier)
1017 /* During configuring addresses, the link lost its carrier. As networkd is dropping
1018 * the addresses now, let's not configure the routes either. */
1019 return 0;
1020
47079967 1021 r = link_request_set_routing_policy_rule(link);
f3ef324d
YW		 1022 if (r < 0)
1023 return r;
f882c247 1024
bf61b05a
LP		 1025 /* First add the routes that enable us to talk to gateways, then add in the others that need a gateway. */
1026 for (phase = 0; phase < _PHASE_MAX; phase++)
1027 LIST_FOREACH(routes, rt, link->network->static_routes) {
0d34228f 1028
bf61b05a
LP		 1029 if (in_addr_is_null(rt->family, &rt->gw) != (phase == PHASE_NON_GATEWAY))
1030 continue;
a6cc569e 1031
0d34228f 1032 r = route_configure(rt, link, route_handler);
4ff296b0
YW		 1033 if (r < 0)
1034 return log_link_warning_errno(link, r, "Could not set routes: %m");
c4423317
YW		 1035 if (r > 0)
1036 link->route_messages++;
0d34228f 1037 }
f5be5601 1038
7715629e
ST		 1039 if (link->route_messages == 0) {
1040 link->static_routes_configured = true;
8012cd39 1041 link_check_ready(link);
b425c3ae 1042 } else {
6a7a4e4d 1043 log_link_debug(link, "Setting routes");
b425c3ae
YW		 1044 link_set_state(link, LINK_STATE_CONFIGURING);
1045 }
f882c247
TG		 1046
1047 return 0;
1048}
1049
6accfd31
DA		 1050void link_check_ready(Link *link) {
1051 Address *a;
1052 Iterator i;
4ff296b0 1053 int r;
6accfd31
DA		 1054
1055 assert(link);
1056
1057 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1058 return;
1059
1060 if (!link->network)
1061 return;
1062
1063 if (!link->addresses_configured)
1064 return;
1065
1066 if (!link->neighbors_configured)
1067 return;
1068
6aa5773b
DA		 1069 SET_FOREACH(a, link->addresses, i)
1070 if (!address_is_ready(a))
1071 return;
1072
1073 if (!link->addresses_ready) {
1074 link->addresses_ready = true;
4ff296b0
YW		 1075 r = link_request_set_routes(link);
1076 if (r < 0)
1077 link_enter_failed(link);
710ce9e5 1078 return;
6aa5773b
DA		 1079 }
1080
6accfd31
DA		 1081 if (!link->static_routes_configured)
1082 return;
1083
c16c7808
SS		 1084 if (!link->static_routes_ready) {
1085 link->static_routes_ready = true;
1086 r = link_request_set_nexthop(link);
1087 if (r < 0)
1088 link_enter_failed(link);
1089 return;
1090 }
1091
1092 if (!link->static_nexthops_configured)
1093 return;
1094
6accfd31
DA		 1095 if (!link->routing_policy_rules_configured)
1096 return;
1097
4ecdcb07
YW		 1098 if (!link->qdiscs_configured)
1099 return;
1100
463797c1 1101 if (link_has_carrier(link) || !link->network->configure_without_carrier) {
6accfd31 1102
2aa7d367 1103 if (link_ipv4ll_enabled(link, ADDRESS_FAMILY_IPV4) && !link->ipv4ll_address)
463797c1 1104 return;
6accfd31 1105
463797c1
YW		 1106 if (link_ipv6ll_enabled(link) &&
1107 in_addr_is_null(AF_INET6, (const union in_addr_union*) &link->ipv6ll_address))
1108 return;
6accfd31 1109
463797c1
YW		 1110 if ((link_dhcp4_enabled(link) || link_dhcp6_enabled(link)) &&
1111 !link->dhcp4_configured &&
1112 !link->dhcp6_configured &&
2aa7d367 1113 !(link_ipv4ll_enabled(link, ADDRESS_FAMILY_FALLBACK_IPV4) && link->ipv4ll_address))
463797c1
YW		 1114 /* When DHCP is enabled, at least one protocol must provide an address, or
1115 * an IPv4ll fallback address must be configured. */
1116 return;
1117
1118 if (link_ipv6_accept_ra_enabled(link) && !link->ndisc_configured)
1119 return;
1120 }
6accfd31 1121
6accfd31
DA		 1122 if (link->state != LINK_STATE_CONFIGURED)
1123 link_enter_configured(link);
1124
1125 return;
1126}
1127
e4a71bf3
WKI		 1128static int link_request_set_neighbors(Link *link) {
1129 Neighbor *neighbor;
1130 int r;
1131
1132 assert(link);
1133 assert(link->network);
1134 assert(link->state != _LINK_STATE_INVALID);
1135
2428613f 1136 link->neighbors_configured = false;
e4a71bf3
WKI		 1137
1138 LIST_FOREACH(neighbors, neighbor, link->network->neighbors) {
1139 r = neighbor_configure(neighbor, link, NULL);
4ff296b0
YW		 1140 if (r < 0)
1141 return log_link_warning_errno(link, r, "Could not set neighbor: %m");
e4a71bf3
WKI		 1142 }
1143
1144 if (link->neighbor_messages == 0) {
1145 link->neighbors_configured = true;
1146 link_check_ready(link);
b425c3ae 1147 } else {
e4a71bf3 1148 log_link_debug(link, "Setting neighbors");
b425c3ae
YW		 1149 link_set_state(link, LINK_STATE_CONFIGURING);
1150 }
e4a71bf3
WKI		 1151
1152 return 0;
1153}
1154
302a796f 1155static int address_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
f882c247
TG		 1156 int r;
1157
4958aee4 1158 assert(rtnl);
f5be5601
TG		 1159 assert(m);
1160 assert(link);
1161 assert(link->ifname);
7715629e 1162 assert(link->address_messages > 0);
289e6774 1163 assert(IN_SET(link->state, LINK_STATE_CONFIGURING,
370e9930 1164 LINK_STATE_FAILED, LINK_STATE_LINGER));
f882c247 1165
7715629e 1166 link->address_messages--;
f882c247 1167
5da8149f 1168 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
f882c247
TG		 1169 return 1;
1170
1c4baffc 1171 r = sd_netlink_message_get_errno(m);
4ff296b0 1172 if (r < 0 && r != -EEXIST) {
5ecb131d 1173 log_link_message_warning_errno(link, m, r, "Could not set address");
4ff296b0
YW		 1174 link_enter_failed(link);
1175 return 1;
1176 } else if (r >= 0)
1177 (void) manager_rtnl_process_address(rtnl, m, link->manager);
f882c247 1178
7715629e 1179 if (link->address_messages == 0) {
6a7a4e4d 1180 log_link_debug(link, "Addresses set");
c42ff3a1 1181 link->addresses_configured = true;
6aa5773b 1182 link_check_ready(link);
dd3efc09 1183 }
f882c247
TG		 1184
1185 return 1;
1186}
1187
f6bb7ac5
TJ		 1188static int link_set_bridge_fdb(Link *link) {
1189 FdbEntry *fdb_entry;
197e2809 1190 int r;
f6bb7ac5
TJ		 1191
1192 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
1193 r = fdb_entry_configure(link, fdb_entry);
197e2809 1194 if (r < 0)
f6bb7ac5 1195 return log_link_error_errno(link, r, "Failed to add MAC entry to static MAC table: %m");
f6bb7ac5
TJ		 1196 }
1197
197e2809 1198 return 0;
f6bb7ac5
TJ		 1199}
1200
289e6774 1201static int link_request_set_addresses(Link *link) {
95b74ef6 1202 AddressLabel *label;
a6cc569e 1203 Address *ad;
f882c247
TG		 1204 int r;
1205
1206 assert(link);
1207 assert(link->network);
f5be5601 1208 assert(link->state != _LINK_STATE_INVALID);
f882c247 1209
2428613f
YW		 1210 /* Reset all *_configured flags we are configuring. */
1211 link->addresses_configured = false;
6aa5773b 1212 link->addresses_ready = false;
2428613f
YW		 1213 link->neighbors_configured = false;
1214 link->static_routes_configured = false;
c16c7808
SS		 1215 link->static_routes_ready = false;
1216 link->static_nexthops_configured = false;
2428613f
YW		 1217 link->routing_policy_rules_configured = false;
1218
f6bb7ac5
TJ		 1219 r = link_set_bridge_fdb(link);
1220 if (r < 0)
1221 return r;
1222
f3ef324d
YW		 1223 r = link_request_set_neighbors(link);
1224 if (r < 0)
1225 return r;
e4a71bf3 1226
3d3d4255 1227 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
a47a6dae
YW		 1228 bool update;
1229
1230 update = address_get(link, ad->family, &ad->in_addr, ad->prefixlen, NULL) > 0;
1231
1232 r = address_configure(ad, link, address_handler, update);
4ff296b0
YW		 1233 if (r < 0)
1234 return log_link_warning_errno(link, r, "Could not set addresses: %m");
54a1a535
YW		 1235 if (r > 0)
1236 link->address_messages++;
95b74ef6
SS		 1237 }
1238
1239 LIST_FOREACH(labels, label, link->network->address_labels) {
cccf9517 1240 r = address_label_configure(label, link, NULL, false);
4ff296b0
YW		 1241 if (r < 0)
1242 return log_link_warning_errno(link, r, "Could not set address label: %m");
f5be5601 1243
7715629e 1244 link->address_label_messages++;
f882c247
TG		 1245 }
1246
d4cdbea5
TG		 1247 /* now that we can figure out a default address for the dhcp server,
1248 start it */
708c425d 1249 if (link_dhcp4_server_enabled(link) && (link->flags & IFF_UP)) {
8fcf1d61 1250 r = dhcp4_server_configure(link);
4ff296b0 1251 if (r < 0)
d4cdbea5 1252 return r;
6a7a4e4d 1253 log_link_debug(link, "Offering DHCPv4 leases");
d4cdbea5
TG		 1254 }
1255
c42ff3a1
WKI		 1256 if (link->address_messages == 0) {
1257 link->addresses_configured = true;
6aa5773b 1258 link_check_ready(link);
b425c3ae 1259 } else {
6a7a4e4d 1260 log_link_debug(link, "Setting addresses");
b425c3ae
YW		 1261 link_set_state(link, LINK_STATE_CONFIGURING);
1262 }
431ca2ce 1263
f882c247
TG		 1264 return 0;
1265}
1266
13b498f9 1267static int link_set_bridge_vlan(Link *link) {
86e2be7b 1268 int r;
13b498f9
TJ		 1269
1270 r = br_vlan_configure(link, link->network->pvid, link->network->br_vid_bitmap, link->network->br_untagged_bitmap);
1271 if (r < 0)
1272 log_link_error_errno(link, r, "Failed to assign VLANs to bridge port: %m");
1273
1274 return r;
1275}
1276
a60a720c 1277static int link_set_proxy_arp(Link *link) {
23d8b221
SS		 1278 int r;
1279
1280 if (!link_proxy_arp_enabled(link))
1281 return 0;
1282
62e021a9 1283 r = sysctl_write_ip_property_boolean(AF_INET, link->ifname, "proxy_arp", link->network->proxy_arp > 0);
23d8b221
SS		 1284 if (r < 0)
1285 log_link_warning_errno(link, r, "Cannot configure proxy ARP for interface: %m");
1286
1287 return 0;
1288}
1289
55dc8c4a
YW		 1290static int link_configure_after_setting_mtu(Link *link);
1291
302a796f 1292static int set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
4f882b2a
TG		 1293 int r;
1294
1295 assert(m);
1296 assert(link);
1297 assert(link->ifname);
1298
55dc8c4a
YW		 1299 link->setting_mtu = false;
1300
5da8149f 1301 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
4f882b2a
TG		 1302 return 1;
1303
1c4baffc 1304 r = sd_netlink_message_get_errno(m);
4ff296b0 1305 if (r < 0)
5ecb131d 1306 log_link_message_warning_errno(link, m, r, "Could not set MTU, ignoring");
4ff296b0
YW		 1307 else
1308 log_link_debug(link, "Setting MTU done.");
55dc8c4a 1309
4ff296b0
YW		 1310 if (link->state == LINK_STATE_INITIALIZED) {
1311 r = link_configure_after_setting_mtu(link);
1312 if (r < 0)
1313 link_enter_failed(link);
1314 }
4f882b2a
TG		 1315
1316 return 1;
1317}
1318
933c70a0 1319int link_set_mtu(Link *link, uint32_t mtu) {
4afd3348 1320 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
4f882b2a
TG		 1321 int r;
1322
1323 assert(link);
1324 assert(link->manager);
1325 assert(link->manager->rtnl);
1326
40288ece
YW		 1327 if (mtu == 0 || link->setting_mtu)
1328 return 0;
1329
933c70a0 1330 if (link->mtu == mtu)
ee493106
YW		 1331 return 0;
1332
6a7a4e4d 1333 log_link_debug(link, "Setting MTU: %" PRIu32, mtu);
4f882b2a 1334
6a7a4e4d
LP		 1335 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1336 if (r < 0)
1337 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
4f882b2a 1338
44b598a1 1339 /* IPv6 protocol requires a minimum MTU of IPV6_MTU_MIN(1280) bytes
72c2500b
YW		 1340 * on the interface. Bump up MTU bytes to IPV6_MTU_MIN. */
1341 if (link_ipv6_enabled(link) && mtu < IPV6_MIN_MTU) {
44b598a1
SS		 1342
1343 log_link_warning(link, "Bumping MTU to " STRINGIFY(IPV6_MIN_MTU) ", as "
1344 "IPv6 is requested and requires a minimum MTU of " STRINGIFY(IPV6_MIN_MTU) " bytes: %m");
1345
72c2500b 1346 mtu = IPV6_MIN_MTU;
44b598a1
SS		 1347 }
1348
1c4baffc 1349 r = sd_netlink_message_append_u32(req, IFLA_MTU, mtu);
6a7a4e4d
LP		 1350 if (r < 0)
1351 return log_link_error_errno(link, r, "Could not append MTU: %m");
4f882b2a 1352
302a796f
YW		 1353 r = netlink_call_async(link->manager->rtnl, NULL, req, set_mtu_handler,
1354 link_netlink_destroy_callback, link);
6a7a4e4d
LP		 1355 if (r < 0)
1356 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
4f882b2a 1357
ae941762 1358 link_ref(link);
1046bf9b 1359 link->setting_mtu = true;
b226d99b 1360
4f882b2a
TG		 1361 return 0;
1362}
1363
f6fcc1c2
YW		 1364static bool link_reduces_vlan_mtu(Link *link) {
1365 /* See netif_reduces_vlan_mtu() in kernel. */
1366 return streq_ptr(link->kind, "macsec");
1367}
1368
1369static uint32_t link_get_requested_mtu_by_stacked_netdevs(Link *link) {
1370 uint32_t mtu = 0;
1371 NetDev *dev;
1372 Iterator i;
1373
1374 HASHMAP_FOREACH(dev, link->network->stacked_netdevs, i)
1375 if (dev->kind == NETDEV_KIND_VLAN && dev->mtu > 0)
1376 /* See vlan_dev_change_mtu() in kernel. */
1377 mtu = MAX(mtu, link_reduces_vlan_mtu(link) ? dev->mtu + 4 : dev->mtu);
1378
1379 else if (dev->kind == NETDEV_KIND_MACVLAN && dev->mtu > mtu)
1380 /* See macvlan_change_mtu() in kernel. */
1381 mtu = dev->mtu;
1382
1383 return mtu;
1384}
1385
1386static int link_configure_mtu(Link *link) {
1387 uint32_t mtu;
1388
1389 assert(link);
1390 assert(link->network);
1391
1392 if (link->network->mtu > 0)
1393 return link_set_mtu(link, link->network->mtu);
1394
1395 mtu = link_get_requested_mtu_by_stacked_netdevs(link);
1396 if (link->mtu >= mtu)
1397 return 0;
1398
1399 log_link_notice(link, "Bumping MTU bytes from %"PRIu32" to %"PRIu32" because of stacked device. "
1400 "If it is not desired, then please explicitly specify MTUBytes= setting.",
1401 link->mtu, mtu);
1402
1403 return link_set_mtu(link, mtu);
1404}
1405
302a796f 1406static int set_flags_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
99d2baa2
SS		 1407 int r;
1408
1409 assert(m);
1410 assert(link);
1411 assert(link->ifname);
1412
1413 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1414 return 1;
1415
1416 r = sd_netlink_message_get_errno(m);
1417 if (r < 0)
5ecb131d 1418 log_link_message_warning_errno(link, m, r, "Could not set link flags, ignoring");
99d2baa2
SS		 1419
1420 return 1;
1421}
1422
1423static int link_set_flags(Link *link) {
1424 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1425 unsigned ifi_change = 0;
1426 unsigned ifi_flags = 0;
1427 int r;
1428
1429 assert(link);
1430 assert(link->manager);
1431 assert(link->manager->rtnl);
1432
1433 if (link->flags & IFF_LOOPBACK)
1434 return 0;
1435
1436 if (!link->network)
1437 return 0;
1438
866e6b7a 1439 if (link->network->arp < 0 && link->network->multicast < 0 && link->network->allmulticast < 0)
99d2baa2
SS		 1440 return 0;
1441
1442 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1443 if (r < 0)
1444 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1445
1446 if (link->network->arp >= 0) {
1447 ifi_change |= IFF_NOARP;
e6ebebbe
SS		 1448 SET_FLAG(ifi_flags, IFF_NOARP, link->network->arp == 0);
1449 }
1450
1451 if (link->network->multicast >= 0) {
1452 ifi_change |= IFF_MULTICAST;
1453 SET_FLAG(ifi_flags, IFF_MULTICAST, link->network->multicast);
99d2baa2
SS		 1454 }
1455
866e6b7a
SS		 1456 if (link->network->allmulticast >= 0) {
1457 ifi_change |= IFF_ALLMULTI;
1458 SET_FLAG(ifi_flags, IFF_ALLMULTI, link->network->allmulticast);
1459 }
1460
99d2baa2
SS		 1461 r = sd_rtnl_message_link_set_flags(req, ifi_flags, ifi_change);
1462 if (r < 0)
1463 return log_link_error_errno(link, r, "Could not set link flags: %m");
1464
302a796f
YW		 1465 r = netlink_call_async(link->manager->rtnl, NULL, req, set_flags_handler,
1466 link_netlink_destroy_callback, link);
99d2baa2
SS		 1467 if (r < 0)
1468 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1469
1470 link_ref(link);
1471
1472 return 0;
1473}
1474
e7ab854c
TG		 1475static int link_acquire_ipv6_conf(Link *link) {
1476 int r;
1477
1478 assert(link);
1479
e7ab854c 1480 if (link_ipv6_accept_ra_enabled(link)) {
1e7a0e21 1481 assert(link->ndisc);
e7ab854c
TG		 1482
1483 log_link_debug(link, "Discovering IPv6 routers");
1484
1e7a0e21 1485 r = sd_ndisc_start(link->ndisc);
63348d13 1486 if (r < 0 && r != -EBUSY)
e7ab854c
TG		 1487 return log_link_warning_errno(link, r, "Could not start IPv6 Router Discovery: %m");
1488 }
1489
7465dd22
PF		 1490 if (link_radv_enabled(link)) {
1491 assert(link->radv);
1492 assert(in_addr_is_link_local(AF_INET6, (const union in_addr_union*)&link->ipv6ll_address) > 0);
1493
1494 log_link_debug(link, "Starting IPv6 Router Advertisements");
1495
1496 r = sd_radv_start(link->radv);
1497 if (r < 0 && r != -EBUSY)
1498 return log_link_warning_errno(link, r, "Could not start IPv6 Router Advertisement: %m");
1499 }
1500
10752343
PF		 1501 (void) dhcp6_request_prefix_delegation(link);
1502
e7ab854c
TG		 1503 return 0;
1504}
1505
6fc25497 1506static int link_acquire_ipv4_conf(Link *link) {
ff254138
TG		 1507 int r;
1508
1509 assert(link);
ff254138
TG		 1510 assert(link->manager);
1511 assert(link->manager->event);
1512
910feb78 1513 if (link_ipv4ll_enabled(link, ADDRESS_FAMILY_IPV4)) {
eb34d4af 1514 assert(link->ipv4ll);
ff254138 1515
6a7a4e4d 1516 log_link_debug(link, "Acquiring IPv4 link-local address");
5c1d3fc9
UTL		 1517
1518 r = sd_ipv4ll_start(link->ipv4ll);
6a7a4e4d
LP		 1519 if (r < 0)
1520 return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
5c1d3fc9
UTL		 1521 }
1522
78c958f8 1523 if (link_dhcp4_enabled(link)) {
eb34d4af 1524 assert(link->dhcp_client);
ff254138 1525
6a7a4e4d 1526 log_link_debug(link, "Acquiring DHCPv4 lease");
ab47d620 1527
5c1d3fc9 1528 r = sd_dhcp_client_start(link->dhcp_client);
6a7a4e4d
LP		 1529 if (r < 0)
1530 return log_link_warning_errno(link, r, "Could not acquire DHCPv4 lease: %m");
5c1d3fc9 1531 }
ff254138 1532
6fc25497
SS		 1533 return 0;
1534}
1535
1536static int link_acquire_conf(Link *link) {
1537 int r;
1538
1539 assert(link);
1540
1541 r = link_acquire_ipv4_conf(link);
1542 if (r < 0)
1543 return r;
1544
3f7cc080 1545 if (!in_addr_is_null(AF_INET6, (const union in_addr_union*) &link->ipv6ll_address)) {
6fc25497
SS		 1546 r = link_acquire_ipv6_conf(link);
1547 if (r < 0)
1548 return r;
1549 }
1550
7272b25e
LP		 1551 if (link_lldp_emit_enabled(link)) {
1552 r = link_lldp_emit_start(link);
8e1ad1ea
LP		 1553 if (r < 0)
1554 return log_link_warning_errno(link, r, "Failed to start LLDP transmission: %m");
1555 }
1556
ff254138
TG		 1557 return 0;
1558}
1559
a61bb41c 1560bool link_has_carrier(Link *link) {
deb2e523
TG		 1561 /* see Documentation/networking/operstates.txt in the kernel sources */
1562
a61bb41c 1563 if (link->kernel_operstate == IF_OPER_UP)
deb2e523
TG		 1564 return true;
1565
a61bb41c 1566 if (link->kernel_operstate == IF_OPER_UNKNOWN)
deb2e523 1567 /* operstate may not be implemented, so fall back to flags */
b26ea308
YW		 1568 if (FLAGS_SET(link->flags, IFF_LOWER_UP | IFF_RUNNING) &&
1569 !FLAGS_SET(link->flags, IFF_DORMANT))
deb2e523
TG		 1570 return true;
1571
1572 return false;
1573}
1574
0e2fdb83
SS		 1575static int link_address_genmode_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1576 int r;
1577
1578 assert(link);
1579
1580 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1581 return 1;
1582
1583 r = sd_netlink_message_get_errno(m);
1584 if (r < 0)
5ecb131d 1585 log_link_message_warning_errno(link, m, r, "Could not set address genmode for interface, ignoring");
0e2fdb83
SS		 1586
1587 return 1;
1588}
1589
1590static int link_configure_addrgen_mode(Link *link) {
1591 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1592 uint8_t ipv6ll_mode;
1593 int r;
1594
1595 assert(link);
1596 assert(link->network);
1597 assert(link->manager);
1598 assert(link->manager->rtnl);
1599
9f6e82e6
YW		 1600 if (!socket_ipv6_is_supported())
1601 return 0;
1602
0e2fdb83
SS		 1603 log_link_debug(link, "Setting address genmode for link");
1604
1605 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1606 if (r < 0)
1607 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1608
1609 r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
1610 if (r < 0)
1611 return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
1612
1613 r = sd_netlink_message_open_container(req, AF_INET6);
1614 if (r < 0)
1615 return log_link_error_errno(link, r, "Could not open AF_INET6 container: %m");
1616
1617 if (!link_ipv6ll_enabled(link))
1618 ipv6ll_mode = IN6_ADDR_GEN_MODE_NONE;
826a3602 1619 else if (sysctl_read_ip_property(AF_INET6, link->ifname, "stable_secret", NULL) < 0)
0e2fdb83 1620 /* The file may not exist. And event if it exists, when stable_secret is unset,
826a3602
YW		 1621 * reading the file fails with EIO. */
1622 ipv6ll_mode = IN6_ADDR_GEN_MODE_EUI64;
1623 else
1624 ipv6ll_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
0e2fdb83
SS		 1625
1626 r = sd_netlink_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
1627 if (r < 0)
1628 return log_link_error_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
1629
1630 r = sd_netlink_message_close_container(req);
1631 if (r < 0)
1632 return log_link_error_errno(link, r, "Could not close AF_INET6 container: %m");
1633
1634 r = sd_netlink_message_close_container(req);
1635 if (r < 0)
1636 return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
1637
1638 r = netlink_call_async(link->manager->rtnl, NULL, req, link_address_genmode_handler,
1639 link_netlink_destroy_callback, link);
1640 if (r < 0)
1641 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1642
1643 link_ref(link);
1644
1645 return 0;
1646}
1647
302a796f 1648static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
dd3efc09
TG		 1649 int r;
1650
1746cf2a
TG		 1651 assert(link);
1652
5da8149f 1653 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1746cf2a
TG		 1654 return 1;
1655
1c4baffc 1656 r = sd_netlink_message_get_errno(m);
6a7a4e4d 1657 if (r < 0)
26d6b214 1658 /* we warn but don't fail the link, as it may be brought up later */
5ecb131d 1659 log_link_message_warning_errno(link, m, r, "Could not bring up interface");
45ad2c13 1660
f882c247
TG		 1661 return 1;
1662}
1663
1cc84f3b 1664static int link_up(Link *link) {
4afd3348 1665 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
f579559b
TG		 1666 int r;
1667
f882c247 1668 assert(link);
c106cc36 1669 assert(link->network);
f882c247
TG		 1670 assert(link->manager);
1671 assert(link->manager->rtnl);
1672
6a7a4e4d 1673 log_link_debug(link, "Bringing link up");
449f7554 1674
6a7a4e4d
LP		 1675 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1676 if (r < 0)
1677 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
f579559b 1678
2b2d8603 1679 /* set it free if not enslaved with networkd */
6cb955c6 1680 if (!link->network->bridge && !link->network->bond && !link->network->vrf) {
2b2d8603
TY		 1681 r = sd_netlink_message_append_u32(req, IFLA_MASTER, 0);
1682 if (r < 0)
1683 return log_link_error_errno(link, r, "Could not append IFLA_MASTER attribute: %m");
1684 }
1685
5d4795f3 1686 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
6a7a4e4d
LP		 1687 if (r < 0)
1688 return log_link_error_errno(link, r, "Could not set link flags: %m");
fc25d7f8 1689
c106cc36 1690 if (link->network->mac) {
1c4baffc 1691 r = sd_netlink_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
6a7a4e4d
LP		 1692 if (r < 0)
1693 return log_link_error_errno(link, r, "Could not set MAC address: %m");
c106cc36
TG		 1694 }
1695
302a796f
YW		 1696 r = netlink_call_async(link->manager->rtnl, NULL, req, link_up_handler,
1697 link_netlink_destroy_callback, link);
6a7a4e4d
LP		 1698 if (r < 0)
1699 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
f579559b 1700
b226d99b
TG		 1701 link_ref(link);
1702
f882c247
TG		 1703 return 0;
1704}
1705
302a796f 1706static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
0d4ad91d
AR		 1707 int r;
1708
1709 assert(link);
1710
1711 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1712 return 1;
1713
1c4baffc 1714 r = sd_netlink_message_get_errno(m);
0d4ad91d 1715 if (r < 0)
5ecb131d 1716 log_link_message_warning_errno(link, m, r, "Could not bring down interface");
0d4ad91d
AR		 1717
1718 return 1;
1719}
1720
8e54db83 1721int link_down(Link *link, link_netlink_message_handler_t callback) {
4afd3348 1722 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
0d4ad91d
AR		 1723 int r;
1724
1725 assert(link);
1726 assert(link->manager);
1727 assert(link->manager->rtnl);
1728
6a7a4e4d 1729 log_link_debug(link, "Bringing link down");
0d4ad91d
AR		 1730
1731 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1732 RTM_SETLINK, link->ifindex);
6a7a4e4d
LP		 1733 if (r < 0)
1734 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
0d4ad91d
AR		 1735
1736 r = sd_rtnl_message_link_set_flags(req, 0, IFF_UP);
6a7a4e4d
LP		 1737 if (r < 0)
1738 return log_link_error_errno(link, r, "Could not set link flags: %m");
0d4ad91d 1739
8e54db83
YW		 1740 r = netlink_call_async(link->manager->rtnl, NULL, req,
1741 callback ?: link_down_handler,
302a796f 1742 link_netlink_destroy_callback, link);
6a7a4e4d
LP		 1743 if (r < 0)
1744 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
0d4ad91d
AR		 1745
1746 link_ref(link);
1747
1748 return 0;
1749}
1750
1751static int link_handle_bound_to_list(Link *link) {
1752 Link *l;
1753 Iterator i;
1754 int r;
1755 bool required_up = false;
1756 bool link_is_up = false;
1757
1758 assert(link);
1759
1760 if (hashmap_isempty(link->bound_to_links))
1761 return 0;
1762
1763 if (link->flags & IFF_UP)
1764 link_is_up = true;
1765
1766 HASHMAP_FOREACH (l, link->bound_to_links, i)
1767 if (link_has_carrier(l)) {
1768 required_up = true;
1769 break;
1770 }
1771
1772 if (!required_up && link_is_up) {
8e54db83 1773 r = link_down(link, NULL);
0d4ad91d
AR		 1774 if (r < 0)
1775 return r;
1776 } else if (required_up && !link_is_up) {
1777 r = link_up(link);
1778 if (r < 0)
1779 return r;
1780 }
1781
1782 return 0;
1783}
1784
1785static int link_handle_bound_by_list(Link *link) {
1786 Iterator i;
1787 Link *l;
1788 int r;
1789
1790 assert(link);
1791
1792 if (hashmap_isempty(link->bound_by_links))
1793 return 0;
1794
1795 HASHMAP_FOREACH (l, link->bound_by_links, i) {
1796 r = link_handle_bound_to_list(l);
1797 if (r < 0)
1798 return r;
1799 }
1800
1801 return 0;
1802}
1803
1804static int link_put_carrier(Link *link, Link *carrier, Hashmap **h) {
1805 int r;
1806
1807 assert(link);
1808 assert(carrier);
1809
1810 if (link == carrier)
1811 return 0;
1812
1813 if (hashmap_get(*h, INT_TO_PTR(carrier->ifindex)))
1814 return 0;
1815
1816 r = hashmap_ensure_allocated(h, NULL);
1817 if (r < 0)
1818 return r;
1819
1820 r = hashmap_put(*h, INT_TO_PTR(carrier->ifindex), carrier);
1821 if (r < 0)
1822 return r;
1823
1824 return 0;
1825}
1826
1827static int link_new_bound_by_list(Link *link) {
1828 Manager *m;
1829 Link *carrier;
1830 Iterator i;
1831 int r;
1832 bool list_updated = false;
1833
1834 assert(link);
1835 assert(link->manager);
1836
1837 m = link->manager;
1838
b295beea 1839 HASHMAP_FOREACH(carrier, m->links, i) {
0d4ad91d
AR		 1840 if (!carrier->network)
1841 continue;
1842
1843 if (strv_isempty(carrier->network->bind_carrier))
1844 continue;
1845
1846 if (strv_fnmatch(carrier->network->bind_carrier, link->ifname, 0)) {
1847 r = link_put_carrier(link, carrier, &link->bound_by_links);
1848 if (r < 0)
1849 return r;
1850
1851 list_updated = true;
1852 }
1853 }
1854
1855 if (list_updated)
84de38c5 1856 link_dirty(link);
0d4ad91d 1857
b295beea 1858 HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
0d4ad91d
AR		 1859 r = link_put_carrier(carrier, link, &carrier->bound_to_links);
1860 if (r < 0)
1861 return r;
1862
84de38c5 1863 link_dirty(carrier);
0d4ad91d
AR		 1864 }
1865
1866 return 0;
1867}
1868
1869static int link_new_bound_to_list(Link *link) {
1870 Manager *m;
1871 Link *carrier;
1872 Iterator i;
1873 int r;
1874 bool list_updated = false;
1875
1876 assert(link);
1877 assert(link->manager);
1878
1879 if (!link->network)
1880 return 0;
1881
1882 if (strv_isempty(link->network->bind_carrier))
1883 return 0;
1884
1885 m = link->manager;
1886
1887 HASHMAP_FOREACH (carrier, m->links, i) {
1888 if (strv_fnmatch(link->network->bind_carrier, carrier->ifname, 0)) {
1889 r = link_put_carrier(link, carrier, &link->bound_to_links);
1890 if (r < 0)
1891 return r;
1892
1893 list_updated = true;
1894 }
1895 }
1896
1897 if (list_updated)
84de38c5 1898 link_dirty(link);
0d4ad91d
AR		 1899
1900 HASHMAP_FOREACH (carrier, link->bound_to_links, i) {
1901 r = link_put_carrier(carrier, link, &carrier->bound_by_links);
1902 if (r < 0)
1903 return r;
1904
84de38c5 1905 link_dirty(carrier);
0d4ad91d
AR		 1906 }
1907
1908 return 0;
1909}
1910
1911static int link_new_carrier_maps(Link *link) {
1912 int r;
1913
1914 r = link_new_bound_by_list(link);
1915 if (r < 0)
1916 return r;
1917
1918 r = link_handle_bound_by_list(link);
1919 if (r < 0)
1920 return r;
1921
1922 r = link_new_bound_to_list(link);
1923 if (r < 0)
1924 return r;
1925
1926 r = link_handle_bound_to_list(link);
1927 if (r < 0)
1928 return r;
1929
1930 return 0;
1931}
1932
1933static void link_free_bound_to_list(Link *link) {
1934 Link *bound_to;
1935 Iterator i;
1936
1937 HASHMAP_FOREACH (bound_to, link->bound_to_links, i) {
1938 hashmap_remove(link->bound_to_links, INT_TO_PTR(bound_to->ifindex));
1939
1940 if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
84de38c5 1941 link_dirty(bound_to);
0d4ad91d
AR		 1942 }
1943
1944 return;
1945}
1946
1947static void link_free_bound_by_list(Link *link) {
1948 Link *bound_by;
1949 Iterator i;
1950
1951 HASHMAP_FOREACH (bound_by, link->bound_by_links, i) {
1952 hashmap_remove(link->bound_by_links, INT_TO_PTR(bound_by->ifindex));
1953
1954 if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
84de38c5 1955 link_dirty(bound_by);
0d4ad91d
AR		 1956 link_handle_bound_to_list(bound_by);
1957 }
1958 }
1959
1960 return;
1961}
1962
1963static void link_free_carrier_maps(Link *link) {
1964 bool list_updated = false;
1965
1966 assert(link);
1967
1968 if (!hashmap_isempty(link->bound_to_links)) {
1969 link_free_bound_to_list(link);
1970 list_updated = true;
1971 }
1972
1973 if (!hashmap_isempty(link->bound_by_links)) {
1974 link_free_bound_by_list(link);
1975 list_updated = true;
1976 }
1977
1978 if (list_updated)
84de38c5 1979 link_dirty(link);
0d4ad91d
AR		 1980
1981 return;
1982}
1983
5f707e12
YW		 1984static int link_append_to_master(Link *link, NetDev *netdev) {
1985 Link *master;
1986 int r;
1987
1988 assert(link);
1989 assert(netdev);
1990
1991 r = link_get(link->manager, netdev->ifindex, &master);
1992 if (r < 0)
1993 return r;
1994
1995 r = set_ensure_allocated(&master->slaves, NULL);
1996 if (r < 0)
1997 return r;
1998
1999 r = set_put(master->slaves, link);
38288f0b 2000 if (r <= 0)
5f707e12
YW		 2001 return r;
2002
2003 link_ref(link);
2004 return 0;
2005}
2006
2007static void link_drop_from_master(Link *link, NetDev *netdev) {
2008 Link *master;
2009
2010 assert(link);
2011
2012 if (!link->manager || !netdev)
2013 return;
2014
2015 if (link_get(link->manager, netdev->ifindex, &master) < 0)
2016 return;
2017
2018 link_unref(set_remove(master->slaves, link));
2019}
2020
2021static void link_detach_from_manager(Link *link) {
2022 if (!link || !link->manager)
2023 return;
2024
2025 link_unref(set_remove(link->manager->links_requesting_uuid, link));
2026 link_clean(link);
2027
2028 /* The following must be called at last. */
2029 assert_se(hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex)) == link);
2030 link_unref(link);
2031}
2032
0d4ad91d
AR		 2033void link_drop(Link *link) {
2034 if (!link || link->state == LINK_STATE_LINGER)
2035 return;
2036
2037 link_set_state(link, LINK_STATE_LINGER);
2038
2039 link_free_carrier_maps(link);
2040
5f707e12
YW		 2041 if (link->network) {
2042 link_drop_from_master(link, link->network->bridge);
2043 link_drop_from_master(link, link->network->bond);
2044 }
2045
6a7a4e4d 2046 log_link_debug(link, "Link removed");
0d4ad91d 2047
db2f8a2e 2048 (void) unlink(link->state_file);
c4397d94 2049 link_detach_from_manager(link);
0d4ad91d
AR		 2050}
2051
3f265037 2052static int link_joined(Link *link) {
f882c247
TG		 2053 int r;
2054
ef1ba606 2055 assert(link);
f5be5601 2056 assert(link->network);
dd3efc09 2057
0d4ad91d
AR		 2058 if (!hashmap_isempty(link->bound_to_links)) {
2059 r = link_handle_bound_to_list(link);
2060 if (r < 0)
2061 return r;
2062 } else if (!(link->flags & IFF_UP)) {
505f8da7
TG		 2063 r = link_up(link);
2064 if (r < 0) {
2065 link_enter_failed(link);
2066 return r;
2067 }
ef1ba606 2068 }
f882c247 2069
9ed794a3 2070 if (link->network->bridge) {
e1853b00 2071 r = link_set_bridge(link);
6a7a4e4d
LP		 2072 if (r < 0)
2073 log_link_error_errno(link, r, "Could not set bridge message: %m");
45e11abf
YW		 2074
2075 r = link_append_to_master(link, link->network->bridge);
2076 if (r < 0)
2077 log_link_error_errno(link, r, "Failed to add to bridge master's slave list: %m");
e1853b00
SS		 2078 }
2079
eb64b435 2080 if (link->network->bond) {
7fcee284 2081 r = link_set_bond(link);
eb64b435
SS		 2082 if (r < 0)
2083 log_link_error_errno(link, r, "Could not set bond message: %m");
959f65d3 2084
45e11abf 2085 r = link_append_to_master(link, link->network->bond);
959f65d3
YW		 2086 if (r < 0)
2087 log_link_error_errno(link, r, "Failed to add to bond master's slave list: %m");
eb64b435
SS		 2088 }
2089
ffff9abe
TJ		 2090 if (link->network->use_br_vlan &&
2091 (link->network->bridge || streq_ptr("bridge", link->kind))) {
13b498f9
TJ		 2092 r = link_set_bridge_vlan(link);
2093 if (r < 0)
2094 log_link_error_errno(link, r, "Could not set bridge vlan: %m");
2095 }
2096
c1835a42
RM		 2097 /* Skip setting up addresses until it gets carrier,
2098 or it would try to set addresses twice,
2099 which is bad for non-idempotent steps. */
dad2d78e 2100 if (!link_has_carrier(link) && !link->network->configure_without_carrier)
c1835a42
RM		 2101 return 0;
2102
b425c3ae 2103 link_set_state(link, LINK_STATE_CONFIGURING);
289e6774 2104 return link_request_set_addresses(link);
02b59d57
TG		 2105}
2106
302a796f 2107static int netdev_join_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
02b59d57
TG		 2108 int r;
2109
1746cf2a 2110 assert(link);
ef1ba606 2111 assert(link->network);
34bf3c00 2112 assert(link->enslaving > 0);
02b59d57 2113
313cefa1 2114 link->enslaving--;
52433f6b 2115
5da8149f 2116 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
02b59d57
TG		 2117 return 1;
2118
1c4baffc 2119 r = sd_netlink_message_get_errno(m);
856f962c 2120 if (r < 0 && r != -EEXIST) {
5ecb131d 2121 log_link_message_warning_errno(link, m, r, "Could not join netdev");
ef1ba606
TG		 2122 link_enter_failed(link);
2123 return 1;
4ff296b0
YW		 2124 }
2125
2126 log_link_debug(link, "Joined netdev");
02b59d57 2127
34bf3c00 2128 if (link->enslaving == 0) {
4ff296b0
YW		 2129 r = link_joined(link);
2130 if (r < 0)
2131 link_enter_failed(link);
34bf3c00 2132 }
02b59d57
TG		 2133
2134 return 1;
2135}
2136
3f265037 2137static int link_enter_join_netdev(Link *link) {
6a0a2f86 2138 NetDev *netdev;
672682a6 2139 Iterator i;
02b59d57
TG		 2140 int r;
2141
2142 assert(link);
2143 assert(link->network);
bd08ce56 2144 assert(link->state == LINK_STATE_INITIALIZED);
02b59d57 2145
289e6774 2146 link_set_state(link, LINK_STATE_CONFIGURING);
02b59d57 2147
84de38c5 2148 link_dirty(link);
34bf3c00 2149 link->enslaving = 0;
02b59d57 2150
d9c67ea1 2151 if (link->network->bond) {
cbff7170
TJ		 2152 if (link->network->bond->state == NETDEV_STATE_READY &&
2153 link->network->bond->ifindex == link->master_ifindex)
2154 return link_joined(link);
2155
f2341e0a
LP		 2156 log_struct(LOG_DEBUG,
2157 LOG_LINK_INTERFACE(link),
2158 LOG_NETDEV_INTERFACE(link->network->bond),
a1230ff9 2159 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bond->ifname));
f2341e0a 2160
34bf3c00
YW		 2161 link->enslaving++;
2162
f2341e0a 2163 r = netdev_join(link->network->bond, link, netdev_join_handler);
52433f6b 2164 if (r < 0) {
f2341e0a
LP		 2165 log_struct_errno(LOG_WARNING, r,
2166 LOG_LINK_INTERFACE(link),
2167 LOG_NETDEV_INTERFACE(link->network->bond),
a1230ff9 2168 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bond->ifname));
52433f6b
TG		 2169 link_enter_failed(link);
2170 return r;
2171 }
0ad6148e
MO		 2172 }
2173
d9c67ea1 2174 if (link->network->bridge) {
f2341e0a
LP		 2175 log_struct(LOG_DEBUG,
2176 LOG_LINK_INTERFACE(link),
2177 LOG_NETDEV_INTERFACE(link->network->bridge),
a1230ff9 2178 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bridge->ifname));
f2341e0a 2179
34bf3c00
YW		 2180 link->enslaving++;
2181
f2341e0a 2182 r = netdev_join(link->network->bridge, link, netdev_join_handler);
0ad6148e 2183 if (r < 0) {
f2341e0a
LP		 2184 log_struct_errno(LOG_WARNING, r,
2185 LOG_LINK_INTERFACE(link),
2186 LOG_NETDEV_INTERFACE(link->network->bridge),
a1230ff9 2187 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bridge->ifname));
0ad6148e
MO		 2188 link_enter_failed(link);
2189 return r;
2190 }
52433f6b
TG		 2191 }
2192
6cb955c6
AR		 2193 if (link->network->vrf) {
2194 log_struct(LOG_DEBUG,
2195 LOG_LINK_INTERFACE(link),
2196 LOG_NETDEV_INTERFACE(link->network->vrf),
a1230ff9
ZJS		 2197 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->vrf->ifname));
2198
34bf3c00
YW		 2199 link->enslaving++;
2200
6cb955c6
AR		 2201 r = netdev_join(link->network->vrf, link, netdev_join_handler);
2202 if (r < 0) {
2203 log_struct_errno(LOG_WARNING, r,
2204 LOG_LINK_INTERFACE(link),
2205 LOG_NETDEV_INTERFACE(link->network->vrf),
a1230ff9 2206 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->vrf->ifname));
6cb955c6
AR		 2207 link_enter_failed(link);
2208 return r;
2209 }
6cb955c6
AR		 2210 }
2211
6a0a2f86 2212 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
7951dea2 2213
2b6db913
YW		 2214 if (netdev->ifindex > 0)
2215 /* Assume already enslaved. */
a63e5daa 2216 continue;
a63e5daa 2217
7033af49
YW		 2218 if (netdev_get_create_type(netdev) != NETDEV_CREATE_STACKED)
2219 continue;
2220
f2341e0a
LP		 2221 log_struct(LOG_DEBUG,
2222 LOG_LINK_INTERFACE(link),
2223 LOG_NETDEV_INTERFACE(netdev),
a1230ff9 2224 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname));
f2341e0a 2225
34bf3c00
YW		 2226 link->enslaving++;
2227
f2341e0a 2228 r = netdev_join(netdev, link, netdev_join_handler);
7951dea2 2229 if (r < 0) {
f2341e0a
LP		 2230 log_struct_errno(LOG_WARNING, r,
2231 LOG_LINK_INTERFACE(link),
2232 LOG_NETDEV_INTERFACE(netdev),
a1230ff9 2233 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname));
326cb406
SS		 2234 link_enter_failed(link);
2235 return r;
2236 }
326cb406
SS		 2237 }
2238
34bf3c00
YW		 2239 if (link->enslaving == 0)
2240 return link_joined(link);
2241
ef1ba606
TG		 2242 return 0;
2243}
2244
769d324c 2245static int link_set_ipv4_forward(Link *link) {
5a8bcb67
LP		 2246 int r;
2247
765afd5c 2248 if (!link_ipv4_forward_enabled(link))
15dee3f0
LP		 2249 return 0;
2250
765afd5c
LP		 2251 /* We propagate the forwarding flag from one interface to the
2252 * global setting one way. This means: as long as at least one
2253 * interface was configured at any time that had IP forwarding
2254 * enabled the setting will stay on for good. We do this
2255 * primarily to keep IPv4 and IPv6 packet forwarding behaviour
2256 * somewhat in sync (see below). */
15dee3f0 2257
62e021a9 2258 r = sysctl_write_ip_property(AF_INET, NULL, "ip_forward", "1");
eb3da901 2259 if (r < 0)
765afd5c 2260 log_link_warning_errno(link, r, "Cannot turn on IPv4 packet forwarding, ignoring: %m");
43c6d5ab 2261
769d324c
LP		 2262 return 0;
2263}
2264
2265static int link_set_ipv6_forward(Link *link) {
769d324c
LP		 2266 int r;
2267
765afd5c 2268 if (!link_ipv6_forward_enabled(link))
8add5f79
NO		 2269 return 0;
2270
61233823 2271 /* On Linux, the IPv6 stack does not know a per-interface
765afd5c
LP		 2272 * packet forwarding setting: either packet forwarding is on
2273 * for all, or off for all. We hence don't bother with a
2274 * per-interface setting, but simply propagate the interface
2275 * flag, if it is set, to the global flag, one-way. Note that
2276 * while IPv4 would allow a per-interface flag, we expose the
2277 * same behaviour there and also propagate the setting from
2278 * one to all, to keep things simple (see above). */
15dee3f0 2279
62e021a9 2280 r = sysctl_write_ip_property(AF_INET6, "all", "forwarding", "1");
eb3da901 2281 if (r < 0)
765afd5c 2282 log_link_warning_errno(link, r, "Cannot configure IPv6 packet forwarding, ignoring: %m");
5a8bcb67
LP		 2283
2284 return 0;
2285}
2286
49092e22 2287static int link_set_ipv6_privacy_extensions(Link *link) {
1f0d9695 2288 IPv6PrivacyExtensions s;
49092e22
SS		 2289 int r;
2290
1f0d9695 2291 s = link_ipv6_privacy_extensions(link);
66a6bd68 2292 if (s < 0)
49092e22
SS		 2293 return 0;
2294
62e021a9 2295 r = sysctl_write_ip_property_int(AF_INET6, link->ifname, "use_tempaddr", (int) link->network->ipv6_privacy_extensions);
eb3da901 2296 if (r < 0)
49092e22
SS		 2297 log_link_warning_errno(link, r, "Cannot configure IPv6 privacy extension for interface: %m");
2298
2299 return 0;
2300}
2301
4f2e437a 2302static int link_set_ipv6_accept_ra(Link *link) {
4f2e437a
SS		 2303 int r;
2304
2305 /* Make this a NOP if IPv6 is not available */
2306 if (!socket_ipv6_is_supported())
2307 return 0;
2308
2309 if (link->flags & IFF_LOOPBACK)
2310 return 0;
2311
d68e2e59
LP		 2312 if (!link->network)
2313 return 0;
2314
62e021a9 2315 r = sysctl_write_ip_property(AF_INET6, link->ifname, "accept_ra", "0");
eb3da901 2316 if (r < 0)
fe307276 2317 log_link_warning_errno(link, r, "Cannot disable kernel IPv6 accept_ra for interface: %m");
4f2e437a
SS		 2318
2319 return 0;
2320}
2321
8749cbcd 2322static int link_set_ipv6_dad_transmits(Link *link) {
8749cbcd
SS		 2323 int r;
2324
2325 /* Make this a NOP if IPv6 is not available */
2326 if (!socket_ipv6_is_supported())
2327 return 0;
2328
2329 if (link->flags & IFF_LOOPBACK)
2330 return 0;
2331
d68e2e59
LP		 2332 if (!link->network)
2333 return 0;
2334
8749cbcd
SS		 2335 if (link->network->ipv6_dad_transmits < 0)
2336 return 0;
2337
62e021a9 2338 r = sysctl_write_ip_property_int(AF_INET6, link->ifname, "dad_transmits", link->network->ipv6_dad_transmits);
eb3da901 2339 if (r < 0)
8749cbcd 2340 log_link_warning_errno(link, r, "Cannot set IPv6 dad transmits for interface: %m");
8749cbcd
SS		 2341
2342 return 0;
2343}
2344
b69c3180 2345static int link_set_ipv6_hop_limit(Link *link) {
b69c3180
SS		 2346 int r;
2347
2348 /* Make this a NOP if IPv6 is not available */
2349 if (!socket_ipv6_is_supported())
2350 return 0;
2351
2352 if (link->flags & IFF_LOOPBACK)
2353 return 0;
2354
d68e2e59
LP		 2355 if (!link->network)
2356 return 0;
2357
b69c3180
SS		 2358 if (link->network->ipv6_hop_limit < 0)
2359 return 0;
2360
62e021a9 2361 r = sysctl_write_ip_property_int(AF_INET6, link->ifname, "hop_limit", link->network->ipv6_hop_limit);
eb3da901 2362 if (r < 0)
b69c3180 2363 log_link_warning_errno(link, r, "Cannot set IPv6 hop limit for interface: %m");
b69c3180
SS		 2364
2365 return 0;
2366}
2367
11102cba 2368static int link_set_ipv6_mtu(Link *link) {
11102cba
SS		 2369 int r;
2370
2371 /* Make this a NOP if IPv6 is not available */
2372 if (!socket_ipv6_is_supported())
2373 return 0;
2374
2375 if (link->flags & IFF_LOOPBACK)
2376 return 0;
2377
2378 if (link->network->ipv6_mtu == 0)
2379 return 0;
2380
62e021a9 2381 r = sysctl_write_ip_property_uint32(AF_INET6, link->ifname, "mtu", link->network->ipv6_mtu);
11102cba
SS		 2382 if (r < 0)
2383 log_link_warning_errno(link, r, "Cannot set IPv6 MTU for interface: %m");
2384
2385 return 0;
2386}
2387
30226d27
TJ		 2388static bool link_is_static_address_configured(Link *link, Address *address) {
2389 Address *net_address;
2390
2391 assert(link);
2392 assert(address);
2393
2394 if (!link->network)
2395 return false;
2396
2397 LIST_FOREACH(addresses, net_address, link->network->static_addresses)
2398 if (address_equal(net_address, address))
2399 return true;
2400
2401 return false;
2402}
2403
d1bdafd2
WKI		 2404static bool link_is_neighbor_configured(Link *link, Neighbor *neighbor) {
2405 Neighbor *net_neighbor;
2406
2407 assert(link);
2408 assert(neighbor);
2409
2410 if (!link->network)
2411 return false;
2412
2413 LIST_FOREACH(neighbors, net_neighbor, link->network->neighbors)
2414 if (neighbor_equal(net_neighbor, neighbor))
2415 return true;
2416
2417 return false;
2418}
2419
7ecf0c3e
TJ		 2420static bool link_is_static_route_configured(Link *link, Route *route) {
2421 Route *net_route;
2422
2423 assert(link);
2424 assert(route);
2425
2426 if (!link->network)
2427 return false;
2428
2429 LIST_FOREACH(routes, net_route, link->network->static_routes)
2430 if (route_equal(net_route, route))
2431 return true;
2432
2433 return false;
2434}
2435
db51778f
YW		 2436static bool link_address_is_dynamic(Link *link, Address *address) {
2437 Route *route;
2438 Iterator i;
2439
2440 assert(link);
2441 assert(address);
2442
2443 if (address->cinfo.ifa_prefered != CACHE_INFO_INFINITY_LIFE_TIME)
2444 return true;
2445
2446 /* Even when the address is leased from a DHCP server, networkd assign the address
2447 * without lifetime when KeepConfiguration=dhcp. So, let's check that we have
2448 * corresponding routes with RTPROT_DHCP. */
2449 SET_FOREACH(route, link->routes_foreign, i) {
2450 if (route->protocol != RTPROT_DHCP)
2451 continue;
2452
2453 if (address->family != route->family)
2454 continue;
2455
2456 if (in_addr_equal(address->family, &address->in_addr, &route->prefsrc))
2457 return true;
2458 }
2459
2460 return false;
2461}
2462
5e5b137a
TG		 2463static int link_drop_foreign_config(Link *link) {
2464 Address *address;
d1bdafd2 2465 Neighbor *neighbor;
5e5b137a
TG		 2466 Route *route;
2467 Iterator i;
2468 int r;
2469
2470 SET_FOREACH(address, link->addresses_foreign, i) {
fe307276 2471 /* we consider IPv6LL addresses to be managed by the kernel */
5539fc0f 2472 if (address->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &address->in_addr) == 1 && link_ipv6ll_enabled(link))
5e5b137a
TG		 2473 continue;
2474
db51778f 2475 if (link_address_is_dynamic(link, address)) {
b1b0b42e 2476 if (link->network && FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP))
db51778f 2477 continue;
b1b0b42e 2478 } else if (link->network && FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_STATIC))
db51778f
YW		 2479 continue;
2480
30226d27
TJ		 2481 if (link_is_static_address_configured(link, address)) {
2482 r = address_add(link, address->family, &address->in_addr, address->prefixlen, NULL);
2483 if (r < 0)
2484 return log_link_error_errno(link, r, "Failed to add address: %m");
2485 } else {
63ae0569 2486 r = address_remove(address, link, NULL);
30226d27
TJ		 2487 if (r < 0)
2488 return r;
2489 }
5e5b137a
TG		 2490 }
2491
d1bdafd2
WKI		 2492 SET_FOREACH(neighbor, link->neighbors_foreign, i) {
2493 if (link_is_neighbor_configured(link, neighbor)) {
2494 r = neighbor_add(link, neighbor->family, &neighbor->in_addr, &neighbor->lladdr, neighbor->lladdr_size, NULL);
2495 if (r < 0)
2496 return r;
2497 } else {
2498 r = neighbor_remove(neighbor, link, NULL);
2499 if (r < 0)
2500 return r;
2501 }
2502 }
2503
5e5b137a 2504 SET_FOREACH(route, link->routes_foreign, i) {
fe307276 2505 /* do not touch routes managed by the kernel */
5e5b137a
TG		 2506 if (route->protocol == RTPROT_KERNEL)
2507 continue;
2508
bd7d6cec
YW		 2509 /* do not touch multicast route added by kernel */
2510 /* FIXME: Why the kernel adds this route with protocol RTPROT_BOOT??? We need to investigate that.
2511 * https://tools.ietf.org/html/rfc4862#section-5.4 may explain why. */
2512 if (route->protocol == RTPROT_BOOT &&
2513 route->family == AF_INET6 &&
2514 route->dst_prefixlen == 8 &&
2515 in_addr_equal(AF_INET6, &route->dst, &(union in_addr_union) { .in6 = {{{ 0xff,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 }}} }))
2516 continue;
2517
b1b0b42e 2518 if (route->protocol == RTPROT_STATIC && link->network &&
db51778f
YW		 2519 FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_STATIC))
2520 continue;
2521
b1b0b42e 2522 if (route->protocol == RTPROT_DHCP && link->network &&
db51778f
YW		 2523 FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP))
2524 continue;
2525
7ecf0c3e 2526 if (link_is_static_route_configured(link, route)) {
f1368755 2527 r = route_add(link, route, NULL);
7ecf0c3e
TJ		 2528 if (r < 0)
2529 return r;
2530 } else {
4645ad47 2531 r = route_remove(route, link, NULL);
7ecf0c3e
TJ		 2532 if (r < 0)
2533 return r;
2534 }
5e5b137a
TG		 2535 }
2536
2537 return 0;
2538}
2539
3104883d 2540static int link_drop_config(Link *link) {
410a7f15 2541 Address *address, *pool_address;
d1bdafd2 2542 Neighbor *neighbor;
3104883d
SS		 2543 Route *route;
2544 Iterator i;
2545 int r;
2546
2547 SET_FOREACH(address, link->addresses, i) {
2548 /* we consider IPv6LL addresses to be managed by the kernel */
5539fc0f 2549 if (address->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &address->in_addr) == 1 && link_ipv6ll_enabled(link))
3104883d
SS		 2550 continue;
2551
63ae0569 2552 r = address_remove(address, link, NULL);
3104883d
SS		 2553 if (r < 0)
2554 return r;
410a7f15
RM		 2555
2556 /* If this address came from an address pool, clean up the pool */
2557 LIST_FOREACH(addresses, pool_address, link->pool_addresses) {
2558 if (address_equal(address, pool_address)) {
2559 LIST_REMOVE(addresses, link->pool_addresses, pool_address);
2560 address_free(pool_address);
2561 break;
2562 }
2563 }
3104883d
SS		 2564 }
2565
d1bdafd2
WKI		 2566 SET_FOREACH(neighbor, link->neighbors, i) {
2567 r = neighbor_remove(neighbor, link, NULL);
2568 if (r < 0)
2569 return r;
2570 }
2571
3104883d
SS		 2572 SET_FOREACH(route, link->routes, i) {
2573 /* do not touch routes managed by the kernel */
2574 if (route->protocol == RTPROT_KERNEL)
2575 continue;
2576
4645ad47 2577 r = route_remove(route, link, NULL);
3104883d
SS		 2578 if (r < 0)
2579 return r;
2580 }
2581
c69305ff
LP		 2582 ndisc_flush(link);
2583
3104883d
SS		 2584 return 0;
2585}
2586
4ecdcb07 2587static int link_configure_qdiscs(Link *link) {
edc54f2f 2588 QDisc *qdisc;
0f5bd7fe 2589 Iterator i;
02b59d57
TG		 2590 int r;
2591
4ecdcb07
YW		 2592 link->qdiscs_configured = false;
2593 link->qdisc_messages = 0;
2594
2595 ORDERED_HASHMAP_FOREACH(qdisc, link->network->qdiscs_by_section, i) {
2596 r = qdisc_configure(link, qdisc);
2597 if (r < 0)
2598 return r;
2599 }
2600
2601 if (link->qdisc_messages == 0)
2602 link->qdiscs_configured = true;
2603 else
edc54f2f 2604 log_link_debug(link, "Configuring queuing discipline (qdisc)");
4ecdcb07
YW		 2605
2606 return 0;
2607}
2608
2609static int link_configure(Link *link) {
2610 int r;
2611
ef1ba606 2612 assert(link);
b22d8a00 2613 assert(link->network);
bd08ce56 2614 assert(link->state == LINK_STATE_INITIALIZED);
a748b692 2615
4ecdcb07
YW		 2616 r = link_configure_qdiscs(link);
2617 if (r < 0)
2618 return r;
2619
500b96eb 2620 if (link->iftype == ARPHRD_CAN)
93ea7750 2621 return link_configure_can(link);
92c918b0 2622
02e28621
ДГ		 2623 /* Drop foreign config, but ignore loopback or critical devices.
2624 * We do not want to remove loopback address or addresses used for root NFS. */
7da377ef 2625 if (!(link->flags & IFF_LOOPBACK) &&
db51778f 2626 link->network->keep_configuration != KEEP_CONFIGURATION_YES) {
e5d44b34
CH		 2627 r = link_drop_foreign_config(link);
2628 if (r < 0)
2629 return r;
2630 }
5e5b137a 2631
482efedc
SS		 2632 /* If IPv6 configured that is static IPv6 address and IPv6LL autoconfiguration is enabled
2633 * for this interface, then enable IPv6 */
57ad7607 2634 (void) link_update_ipv6_sysctl(link);
482efedc 2635
23d8b221
SS		 2636 r = link_set_proxy_arp(link);
2637 if (r < 0)
2638 return r;
2639
a0e5c15d
FK		 2640 r = ipv6_proxy_ndp_addresses_configure(link);
2641 if (r < 0)
2642 return r;
2643
769d324c
LP		 2644 r = link_set_ipv4_forward(link);
2645 if (r < 0)
2646 return r;
2647
2648 r = link_set_ipv6_forward(link);
5a8bcb67
LP		 2649 if (r < 0)
2650 return r;
2651
49092e22
SS		 2652 r = link_set_ipv6_privacy_extensions(link);
2653 if (r < 0)
2654 return r;
2655
4f2e437a
SS		 2656 r = link_set_ipv6_accept_ra(link);
2657 if (r < 0)
2658 return r;
2659
8749cbcd
SS		 2660 r = link_set_ipv6_dad_transmits(link);
2661 if (r < 0)
2662 return r;
b69c3180
SS		 2663
2664 r = link_set_ipv6_hop_limit(link);
2665 if (r < 0)
2666 return r;
8749cbcd 2667
99d2baa2
SS		 2668 r = link_set_flags(link);
2669 if (r < 0)
2670 return r;
2671
11102cba
SS		 2672 r = link_set_ipv6_mtu(link);
2673 if (r < 0)
2674 return r;
2675
910feb78 2676 if (link_ipv4ll_enabled(link, ADDRESS_FAMILY_IPV4 | ADDRESS_FAMILY_FALLBACK_IPV4)) {
b22d8a00 2677 r = ipv4ll_configure(link);
eb34d4af
TG		 2678 if (r < 0)
2679 return r;
2680 }
2681
78c958f8 2682 if (link_dhcp4_enabled(link)) {
64b21ece
MV		 2683 r = dhcp4_set_promote_secondaries(link);
2684 if (r < 0)
2685 return r;
2686
3c9b8860 2687 r = dhcp4_configure(link);
eb34d4af
TG		 2688 if (r < 0)
2689 return r;
eb34d4af
TG		 2690 }
2691
78c958f8 2692 if (link_dhcp4_server_enabled(link)) {
dd43110f
TG		 2693 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2694 if (r < 0)
2695 return r;
2696
2697 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2698 if (r < 0)
2699 return r;
dd43110f
TG		 2700 }
2701
62379e88
TG		 2702 if (link_dhcp6_enabled(link) ||
2703 link_ipv6_accept_ra_enabled(link)) {
f5a8c43f
TG		 2704 r = dhcp6_configure(link);
2705 if (r < 0)
2706 return r;
2707 }
2708
2709 if (link_ipv6_accept_ra_enabled(link)) {
de1e9928 2710 r = ndisc_configure(link);
4138fb2c
PF		 2711 if (r < 0)
2712 return r;
2713 }
2714
7465dd22
PF		 2715 if (link_radv_enabled(link)) {
2716 r = radv_configure(link);
2717 if (r < 0)
2718 return r;
2719 }
2720
8e1ad1ea 2721 if (link_lldp_rx_enabled(link)) {
7f853950 2722 r = link_lldp_rx_configure(link);
273eec24
LP		 2723 if (r < 0)
2724 return r;
ce43e484
SS		 2725 }
2726
f6fcc1c2 2727 r = link_configure_mtu(link);
40288ece
YW		 2728 if (r < 0)
2729 return r;
44b598a1 2730
9f6e82e6
YW		 2731 r = link_configure_addrgen_mode(link);
2732 if (r < 0)
2733 return r;
0e2fdb83 2734
55dc8c4a
YW		 2735 return link_configure_after_setting_mtu(link);
2736}
2737
2738static int link_configure_after_setting_mtu(Link *link) {
2739 int r;
2740
2741 assert(link);
2742 assert(link->network);
bd08ce56 2743 assert(link->state == LINK_STATE_INITIALIZED);
55dc8c4a
YW		 2744
2745 if (link->setting_mtu)
2746 return 0;
2747
dad2d78e 2748 if (link_has_carrier(link) || link->network->configure_without_carrier) {
1e9be60b
TG		 2749 r = link_acquire_conf(link);
2750 if (r < 0)
2751 return r;
cc544d5f 2752 }
1e9be60b 2753
3f265037 2754 return link_enter_join_netdev(link);
505f8da7
TG		 2755}
2756
27dfc982
YW		 2757static int duid_set_uuid(DUID *duid, sd_id128_t uuid) {
2758 assert(duid);
2759
2760 if (duid->raw_data_len > 0)
2761 return 0;
2762
2763 if (duid->type != DUID_TYPE_UUID)
2764 return -EINVAL;
2765
2766 memcpy(&duid->raw_data, &uuid, sizeof(sd_id128_t));
2767 duid->raw_data_len = sizeof(sd_id128_t);
2768
2769 return 1;
2770}
2771
2772int get_product_uuid_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
2773 Manager *manager = userdata;
2774 const sd_bus_error *e;
2775 const void *a;
2776 size_t sz;
2777 DUID *duid;
2778 Link *link;
2779 int r;
2780
2781 assert(m);
2782 assert(manager);
2783
2784 e = sd_bus_message_get_error(m);
2785 if (e) {
2786 log_error_errno(sd_bus_error_get_errno(e),
ab4dd984 2787 "Could not get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %s",
27dfc982
YW		 2788 e->message);
2789 goto configure;
2790 }
2791
2792 r = sd_bus_message_read_array(m, 'y', &a, &sz);
2793 if (r < 0)
2794 goto configure;
2795
2796 if (sz != sizeof(sd_id128_t)) {
ab4dd984 2797 log_error("Invalid product UUID. Falling back to use machine-app-specific ID as DUID-UUID.");
27dfc982
YW		 2798 goto configure;
2799 }
2800
2801 memcpy(&manager->product_uuid, a, sz);
2802 while ((duid = set_steal_first(manager->duids_requesting_uuid)))
2803 (void) duid_set_uuid(duid, manager->product_uuid);
2804
2805 manager->duids_requesting_uuid = set_free(manager->duids_requesting_uuid);
2806
2807configure:
2808 while ((link = set_steal_first(manager->links_requesting_uuid))) {
3dc2e7af
YW		 2809 link_unref(link);
2810
27dfc982
YW		 2811 r = link_configure(link);
2812 if (r < 0)
4ff296b0 2813 link_enter_failed(link);
27dfc982
YW		 2814 }
2815
2816 manager->links_requesting_uuid = set_free(manager->links_requesting_uuid);
2817
2818 /* To avoid calling GetProductUUID() bus method so frequently, set the flag below
2819 * even if the method fails. */
2820 manager->has_product_uuid = true;
2821
2822 return 1;
2823}
2824
2825static bool link_requires_uuid(Link *link) {
2826 const DUID *duid;
2827
2828 assert(link);
2829 assert(link->manager);
2830 assert(link->network);
2831
2832 duid = link_get_duid(link);
2833 if (duid->type != DUID_TYPE_UUID || duid->raw_data_len != 0)
2834 return false;
2835
2836 if (link_dhcp4_enabled(link) && IN_SET(link->network->dhcp_client_identifier, DHCP_CLIENT_ID_DUID, DHCP_CLIENT_ID_DUID_ONLY))
2837 return true;
2838
2839 if (link_dhcp6_enabled(link) || link_ipv6_accept_ra_enabled(link))
2840 return true;
2841
2842 return false;
2843}
2844
2845static int link_configure_duid(Link *link) {
2846 Manager *m;
2847 DUID *duid;
2848 int r;
2849
2850 assert(link);
2851 assert(link->manager);
2852 assert(link->network);
2853
2854 m = link->manager;
2855 duid = link_get_duid(link);
2856
2857 if (!link_requires_uuid(link))
2858 return 1;
2859
2860 if (m->has_product_uuid) {
2861 (void) duid_set_uuid(duid, m->product_uuid);
2862 return 1;
2863 }
2864
2865 if (!m->links_requesting_uuid) {
2866 r = manager_request_product_uuid(m, link);
2867 if (r < 0) {
2868 if (r == -ENOMEM)
2869 return r;
2870
ab4dd984
ZJS		 2871 log_link_warning_errno(link, r,
2872 "Failed to get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %m");
27dfc982
YW		 2873 return 1;
2874 }
2875 } else {
2876 r = set_put(m->links_requesting_uuid, link);
2877 if (r < 0)
2878 return log_oom();
2879
2880 r = set_put(m->duids_requesting_uuid, duid);
2881 if (r < 0)
2882 return log_oom();
3dc2e7af
YW		 2883
2884 link_ref(link);
27dfc982
YW		 2885 }
2886
2887 return 0;
2888}
2889
99b8517c 2890int link_reconfigure(Link *link, bool force) {
ad932b15
YW		 2891 Network *network;
2892 int r;
2893
2894 if (IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_LINGER))
2895 return 0;
2896
2897 r = network_get(link->manager, link->sd_device, link->ifname,
78404d22 2898 &link->mac, link->wlan_iftype, link->ssid, &link->bssid, &network);
ad932b15
YW		 2899 if (r == -ENOENT) {
2900 link_enter_unmanaged(link);
2901 return 0;
2902 } else if (r == 0 && network->unmanaged) {
2903 link_enter_unmanaged(link);
2904 return 0;
2905 } else if (r < 0)
2906 return r;
2907
99b8517c 2908 if (link->network == network && !force)
ad932b15
YW		 2909 return 0;
2910
2911 log_link_info(link, "Re-configuring with %s", network->filename);
2912
2913 /* Dropping old .network file */
2914 r = link_stop_clients(link, false);
2915 if (r < 0) {
2916 link_enter_failed(link);
2917 return r;
2918 }
2919
2920 if (link_dhcp4_server_enabled(link))
2921 (void) sd_dhcp_server_stop(link->dhcp_server);
2922
2923 r = link_drop_config(link);
2924 if (r < 0)
2925 return r;
2926
2927 if (!IN_SET(link->state, LINK_STATE_UNMANAGED, LINK_STATE_PENDING)) {
2928 log_link_debug(link, "State is %s, dropping config", link_state_to_string(link->state));
2929 r = link_drop_foreign_config(link);
2930 if (r < 0)
2931 return r;
2932 }
2933
2934 link_free_carrier_maps(link);
2935 link_free_engines(link);
2936 link->network = network_unref(link->network);
2937
2938 /* Then, apply new .network file */
2939 r = network_apply(network, link);
2940 if (r < 0)
2941 return r;
2942
2943 r = link_new_carrier_maps(link);
2944 if (r < 0)
2945 return r;
2946
2947 link_set_state(link, LINK_STATE_INITIALIZED);
2948
2949 /* link_configure_duid() returns 0 if it requests product UUID. In that case,
2950 * link_configure() is called later asynchronously. */
2951 r = link_configure_duid(link);
2952 if (r <= 0)
2953 return r;
2954
2955 r = link_configure(link);
2956 if (r < 0)
2957 return r;
2958
2959 return 0;
2960}
2961
e6bf7774 2962static int link_initialized_and_synced(Link *link) {
505f8da7 2963 Network *network;
505f8da7
TG		 2964 int r;
2965
2966 assert(link);
2967 assert(link->ifname);
2968 assert(link->manager);
2969
bd08ce56
YW		 2970 /* We may get called either from the asynchronous netlink callback,
2971 * or directly for link_add() if running in a container. See link_add(). */
2972 if (!IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_INITIALIZED))
4232cf04 2973 return 0;
505f8da7 2974
6a7a4e4d 2975 log_link_debug(link, "Link state is up-to-date");
bd08ce56 2976 link_set_state(link, LINK_STATE_INITIALIZED);
505f8da7 2977
0d4ad91d
AR		 2978 r = link_new_bound_by_list(link);
2979 if (r < 0)
2980 return r;
2981
2982 r = link_handle_bound_by_list(link);
2983 if (r < 0)
2984 return r;
2985
c4a03a56 2986 if (!link->network) {
0894cfe4 2987 r = wifi_get_info(link);
8d968fdd
YW		 2988 if (r < 0)
2989 return r;
2990
51517f9e 2991 r = network_get(link->manager, link->sd_device, link->ifname,
78404d22 2992 &link->mac, link->wlan_iftype, link->ssid, &link->bssid, &network);
c4a03a56
TG		 2993 if (r == -ENOENT) {
2994 link_enter_unmanaged(link);
4232cf04 2995 return 0;
a09dc546
DM		 2996 } else if (r == 0 && network->unmanaged) {
2997 link_enter_unmanaged(link);
2998 return 0;
c4a03a56
TG		 2999 } else if (r < 0)
3000 return r;
505f8da7 3001
c4a03a56
TG		 3002 if (link->flags & IFF_LOOPBACK) {
3003 if (network->link_local != ADDRESS_FAMILY_NO)
3004 log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
78c958f8 3005
c4a03a56
TG		 3006 if (network->dhcp != ADDRESS_FAMILY_NO)
3007 log_link_debug(link, "Ignoring DHCP clients for loopback link");
78c958f8 3008
c4a03a56
TG		 3009 if (network->dhcp_server)
3010 log_link_debug(link, "Ignoring DHCP server for loopback link");
3011 }
bd2efe92 3012
7d342c03 3013 r = network_apply(network, link);
c4a03a56
TG		 3014 if (r < 0)
3015 return r;
3016 }
505f8da7 3017
0d4ad91d
AR		 3018 r = link_new_bound_to_list(link);
3019 if (r < 0)
3020 return r;
3021
27dfc982
YW		 3022 /* link_configure_duid() returns 0 if it requests product UUID. In that case,
3023 * link_configure() is called later asynchronously. */
3024 r = link_configure_duid(link);
3025 if (r <= 0)
3026 return r;
3027
a748b692
TG		 3028 r = link_configure(link);
3029 if (r < 0)
3030 return r;
3031
4232cf04 3032 return 0;
505f8da7
TG		 3033}
3034
302a796f 3035static int link_initialized_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
4ff296b0
YW		 3036 int r;
3037
3038 r = link_initialized_and_synced(link);
3039 if (r < 0)
3040 link_enter_failed(link);
e6bf7774
YW		 3041 return 1;
3042}
3043
51517f9e 3044int link_initialized(Link *link, sd_device *device) {
4afd3348 3045 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
4f561e8e
TG		 3046 int r;
3047
3048 assert(link);
3049 assert(link->manager);
3050 assert(link->manager->rtnl);
3051 assert(device);
3052
8434fd5c 3053 if (link->state != LINK_STATE_PENDING)
4f561e8e
TG		 3054 return 0;
3055
51517f9e 3056 if (link->sd_device)
679b3605
TG		 3057 return 0;
3058
79008bdd 3059 log_link_debug(link, "udev initialized link");
bd08ce56 3060 link_set_state(link, LINK_STATE_INITIALIZED);
4f561e8e 3061
51517f9e 3062 link->sd_device = sd_device_ref(device);
4f561e8e 3063
3c9b8860
TG		 3064 /* udev has initialized the link, but we don't know if we have yet
3065 * processed the NEWLINK messages with the latest state. Do a GETLINK,
3066 * when it returns we know that the pending NEWLINKs have already been
3067 * processed and that we are up-to-date */
4f561e8e 3068
3c9b8860
TG		 3069 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
3070 link->ifindex);
4f561e8e
TG		 3071 if (r < 0)
3072 return r;
3073
302a796f
YW		 3074 r = netlink_call_async(link->manager->rtnl, NULL, req, link_initialized_handler,
3075 link_netlink_destroy_callback, link);
4f561e8e
TG		 3076 if (r < 0)
3077 return r;
3078
5da8149f
TG		 3079 link_ref(link);
3080
4f561e8e
TG		 3081 return 0;
3082}
3083
c4a03a56 3084static int link_load(Link *link) {
0bc70f1d
TG		 3085 _cleanup_free_ char *network_file = NULL,
3086 *addresses = NULL,
f703cc2c 3087 *routes = NULL,
0bc70f1d
TG		 3088 *dhcp4_address = NULL,
3089 *ipv4ll_address = NULL;
3090 union in_addr_union address;
c598ac76 3091 const char *p;
c4a03a56
TG		 3092 int r;
3093
3094 assert(link);
3095
aa8fbc74 3096 r = parse_env_file(NULL, link->state_file,
c4a03a56
TG		 3097 "NETWORK_FILE", &network_file,
3098 "ADDRESSES", &addresses,
f703cc2c 3099 "ROUTES", &routes,
0bc70f1d 3100 "DHCP4_ADDRESS", &dhcp4_address,
13df9c39 3101 "IPV4LL_ADDRESS", &ipv4ll_address);
c4a03a56
TG		 3102 if (r < 0 && r != -ENOENT)
3103 return log_link_error_errno(link, r, "Failed to read %s: %m", link->state_file);
3104
3105 if (network_file) {
3106 Network *network;
3107 char *suffix;
3108
3109 /* drop suffix */
3110 suffix = strrchr(network_file, '.');
3111 if (!suffix) {
3112 log_link_debug(link, "Failed to get network name from %s", network_file);
3113 goto network_file_fail;
3114 }
3115 *suffix = '\0';
3116
3117 r = network_get_by_name(link->manager, basename(network_file), &network);
3118 if (r < 0) {
3119 log_link_debug_errno(link, r, "Failed to get network %s: %m", basename(network_file));
3120 goto network_file_fail;
3121 }
3122
7d342c03 3123 r = network_apply(network, link);
c4a03a56
TG		 3124 if (r < 0)
3125 return log_link_error_errno(link, r, "Failed to apply network %s: %m", basename(network_file));
3126 }
3127
3128network_file_fail:
3129
3130 if (addresses) {
c598ac76 3131 p = addresses;
c4a03a56 3132
c598ac76
TG		 3133 for (;;) {
3134 _cleanup_free_ char *address_str = NULL;
c4a03a56
TG		 3135 char *prefixlen_str;
3136 int family;
3137 unsigned char prefixlen;
c4a03a56 3138
c598ac76
TG		 3139 r = extract_first_word(&p, &address_str, NULL, 0);
3140 if (r < 0) {
3141 log_link_debug_errno(link, r, "Failed to extract next address string: %m");
3142 continue;
928bc597
TA		 3143 }
3144 if (r == 0)
c598ac76
TG		 3145 break;
3146
3147 prefixlen_str = strchr(address_str, '/');
c4a03a56 3148 if (!prefixlen_str) {
c598ac76 3149 log_link_debug(link, "Failed to parse address and prefix length %s", address_str);
c4a03a56
TG		 3150 continue;
3151 }
3152
313cefa1 3153 *prefixlen_str++ = '\0';
c4a03a56
TG		 3154
3155 r = sscanf(prefixlen_str, "%hhu", &prefixlen);
3156 if (r != 1) {
3157 log_link_error(link, "Failed to parse prefixlen %s", prefixlen_str);
3158 continue;
3159 }
3160
c598ac76 3161 r = in_addr_from_string_auto(address_str, &family, &address);
c4a03a56 3162 if (r < 0) {
c598ac76 3163 log_link_debug_errno(link, r, "Failed to parse address %s: %m", address_str);
c4a03a56
TG		 3164 continue;
3165 }
3166
3167 r = address_add(link, family, &address, prefixlen, NULL);
3168 if (r < 0)
3169 return log_link_error_errno(link, r, "Failed to add address: %m");
3170 }
3171 }
3172
f703cc2c 3173 if (routes) {
74544b4e
TA		 3174 p = routes;
3175
c598ac76 3176 for (;;) {
4afd3348 3177 _cleanup_(sd_event_source_unrefp) sd_event_source *expire = NULL;
f1368755
YW		 3178 _cleanup_(route_freep) Route *tmp = NULL;
3179 _cleanup_free_ char *route_str = NULL;
f703cc2c 3180 char *prefixlen_str;
f1368755 3181 Route *route;
f703cc2c 3182
c598ac76
TG		 3183 r = extract_first_word(&p, &route_str, NULL, 0);
3184 if (r < 0) {
3185 log_link_debug_errno(link, r, "Failed to extract next route string: %m");
3186 continue;
928bc597
TA		 3187 }
3188 if (r == 0)
c598ac76
TG		 3189 break;
3190
3191 prefixlen_str = strchr(route_str, '/');
f703cc2c 3192 if (!prefixlen_str) {
c598ac76 3193 log_link_debug(link, "Failed to parse route %s", route_str);
f703cc2c
TG		 3194 continue;
3195 }
3196
313cefa1 3197 *prefixlen_str++ = '\0';
f703cc2c 3198
f1368755
YW		 3199 r = route_new(&tmp);
3200 if (r < 0)
3201 return log_oom();
3202
3203 r = sscanf(prefixlen_str, "%hhu/%hhu/%"SCNu32"/%"PRIu32"/"USEC_FMT, &tmp->dst_prefixlen, &tmp->tos, &tmp->priority, &tmp->table, &tmp->lifetime);
f833694d
TG		 3204 if (r != 5) {
3205 log_link_debug(link,
3206 "Failed to parse destination prefix length, tos, priority, table or expiration %s",
3207 prefixlen_str);
f703cc2c
TG		 3208 continue;
3209 }
3210
f1368755 3211 r = in_addr_from_string_auto(route_str, &tmp->family, &tmp->dst);
f703cc2c 3212 if (r < 0) {
c598ac76 3213 log_link_debug_errno(link, r, "Failed to parse route destination %s: %m", route_str);
f703cc2c
TG		 3214 continue;
3215 }
3216
f1368755 3217 r = route_add(link, tmp, &route);
f703cc2c
TG		 3218 if (r < 0)
3219 return log_link_error_errno(link, r, "Failed to add route: %m");
f833694d 3220
f1368755
YW		 3221 if (route->lifetime != USEC_INFINITY && !kernel_route_expiration_supported()) {
3222 r = sd_event_add_time(link->manager->event, &expire, clock_boottime_or_monotonic(), route->lifetime,
f833694d
TG		 3223 0, route_expire_handler, route);
3224 if (r < 0)
3225 log_link_warning_errno(link, r, "Could not arm route expiration handler: %m");
3226 }
3227
f833694d 3228 sd_event_source_unref(route->expire);
1cc6c93a 3229 route->expire = TAKE_PTR(expire);
f703cc2c
TG		 3230 }
3231 }
3232
0bc70f1d
TG		 3233 if (dhcp4_address) {
3234 r = in_addr_from_string(AF_INET, dhcp4_address, &address);
3235 if (r < 0) {
b68d26b8 3236 log_link_debug_errno(link, r, "Failed to parse DHCPv4 address %s: %m", dhcp4_address);
0bc70f1d
TG		 3237 goto dhcp4_address_fail;
3238 }
3239
b1c626f6 3240 r = sd_dhcp_client_new(&link->dhcp_client, link->network ? link->network->dhcp_anonymize : 0);
0bc70f1d 3241 if (r < 0)
b68d26b8 3242 return log_link_error_errno(link, r, "Failed to create DHCPv4 client: %m");
0bc70f1d
TG		 3243
3244 r = sd_dhcp_client_set_request_address(link->dhcp_client, &address.in);
3245 if (r < 0)
b68d26b8 3246 return log_link_error_errno(link, r, "Failed to set initial DHCPv4 address %s: %m", dhcp4_address);
0bc70f1d
TG		 3247 }
3248
3249dhcp4_address_fail:
3250
3251 if (ipv4ll_address) {
3252 r = in_addr_from_string(AF_INET, ipv4ll_address, &address);
3253 if (r < 0) {
b68d26b8 3254 log_link_debug_errno(link, r, "Failed to parse IPv4LL address %s: %m", ipv4ll_address);
0bc70f1d
TG		 3255 goto ipv4ll_address_fail;
3256 }
3257
3258 r = sd_ipv4ll_new(&link->ipv4ll);
3259 if (r < 0)
b68d26b8 3260 return log_link_error_errno(link, r, "Failed to create IPv4LL client: %m");
0bc70f1d
TG		 3261
3262 r = sd_ipv4ll_set_address(link->ipv4ll, &address.in);
3263 if (r < 0)
b68d26b8 3264 return log_link_error_errno(link, r, "Failed to set initial IPv4LL address %s: %m", ipv4ll_address);
0bc70f1d
TG		 3265 }
3266
3267ipv4ll_address_fail:
3268
c4a03a56
TG		 3269 return 0;
3270}
3271
1c4baffc 3272int link_add(Manager *m, sd_netlink_message *message, Link **ret) {
51517f9e 3273 _cleanup_(sd_device_unrefp) sd_device *device = NULL;
505f8da7 3274 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
51517f9e 3275 Link *link;
5a937ea2 3276 int r;
505f8da7
TG		 3277
3278 assert(m);
fbbeb65a 3279 assert(m->rtnl);
505f8da7
TG		 3280 assert(message);
3281 assert(ret);
3282
3283 r = link_new(m, message, ret);
3284 if (r < 0)
3285 return r;
3286
3287 link = *ret;
3288
6a7a4e4d 3289 log_link_debug(link, "Link %d added", link->ifindex);
505f8da7 3290
c4a03a56
TG		 3291 r = link_load(link);
3292 if (r < 0)
3293 return r;
3294
bf331d87
YW		 3295 if (path_is_read_only_fs("/sys") <= 0) {
3296 /* udev should be around */
ae06ab10 3297 sprintf(ifindex_str, "n%d", link->ifindex);
51517f9e
YW		 3298 r = sd_device_new_from_device_id(&device, ifindex_str);
3299 if (r < 0) {
4d59e14f
YW		 3300 log_link_warning_errno(link, r, "Could not find device, waiting for device initialization: %m");
3301 return 0;
5c416fc4 3302 }
505f8da7 3303
5a937ea2 3304 r = sd_device_get_is_initialized(device);
51517f9e 3305 if (r < 0) {
bf331d87 3306 log_link_warning_errno(link, r, "Could not determine whether the device is initialized: %m");
51517f9e
YW		 3307 goto failed;
3308 }
5a937ea2 3309 if (r == 0) {
505f8da7 3310 /* not yet ready */
79008bdd 3311 log_link_debug(link, "link pending udev initialization...");
505f8da7 3312 return 0;
3c4cb064 3313 }
505f8da7 3314
299ad32d
YW		 3315 r = device_is_renaming(device);
3316 if (r < 0) {
bf331d87 3317 log_link_warning_errno(link, r, "Failed to determine the device is being renamed: %m");
299ad32d
YW		 3318 goto failed;
3319 }
3320 if (r > 0) {
bf331d87 3321 log_link_debug(link, "Interface is being renamed, pending initialization.");
299ad32d
YW		 3322 return 0;
3323 }
3324
4f561e8e
TG		 3325 r = link_initialized(link, device);
3326 if (r < 0)
5c416fc4 3327 goto failed;
4f561e8e 3328 } else {
e6bf7774 3329 r = link_initialized_and_synced(link);
4f561e8e 3330 if (r < 0)
5c416fc4 3331 goto failed;
4f561e8e 3332 }
505f8da7 3333
a748b692 3334 return 0;
5c416fc4
TG		 3335failed:
3336 link_enter_failed(link);
3337 return r;
a748b692
TG		 3338}
3339
c601ebf7 3340int link_ipv6ll_gained(Link *link, const struct in6_addr *address) {
e7ab854c
TG		 3341 int r;
3342
3343 assert(link);
3344
3345 log_link_info(link, "Gained IPv6LL");
3346
c601ebf7 3347 link->ipv6ll_address = *address;
e7ab854c
TG		 3348 link_check_ready(link);
3349
b9ea3d2e 3350 if (IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED)) {
e7ab854c
TG		 3351 r = link_acquire_ipv6_conf(link);
3352 if (r < 0) {
3353 link_enter_failed(link);
3354 return r;
3355 }
3356 }
3357
3358 return 0;
3359}
3360
9c0a72f9
TG		 3361static int link_carrier_gained(Link *link) {
3362 int r;
3363
3364 assert(link);
3365
0894cfe4 3366 r = wifi_get_info(link);
8d968fdd
YW		 3367 if (r < 0)
3368 return r;
3369 if (r > 0) {
99b8517c 3370 r = link_reconfigure(link, false);
8d968fdd
YW		 3371 if (r < 0)
3372 return r;
3373 }
3374
b9ea3d2e 3375 if (IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED)) {
9c0a72f9
TG		 3376 r = link_acquire_conf(link);
3377 if (r < 0) {
3378 link_enter_failed(link);
3379 return r;
3380 }
6fc25497 3381
b425c3ae 3382 link_set_state(link, LINK_STATE_CONFIGURING);
289e6774 3383 r = link_request_set_addresses(link);
6fc25497
SS		 3384 if (r < 0)
3385 return r;
9c0a72f9
TG		 3386 }
3387
0d4ad91d
AR		 3388 r = link_handle_bound_by_list(link);
3389 if (r < 0)
3390 return r;
3391
9c0a72f9
TG		 3392 return 0;
3393}
3394
3395static int link_carrier_lost(Link *link) {
3396 int r;
3397
3398 assert(link);
3399
25e992ba 3400 if (link->network && link->network->ignore_carrier_loss)
93b4dab5
SS		 3401 return 0;
3402
fbdb6605 3403 /* Some devices reset itself while setting the MTU. This causes the DHCP client fall into a loop.
55dc8c4a
YW		 3404 * setting_mtu keep track whether the device got reset because of setting MTU and does not drop the
3405 * configuration and stop the clients as well. */
97e7fb39
SS		 3406 if (link->setting_mtu)
3407 return 0;
3408
95355a28 3409 r = link_stop_clients(link, false);
9c0a72f9
TG		 3410 if (r < 0) {
3411 link_enter_failed(link);
3412 return r;
3413 }
3414
28464ae0
SS		 3415 if (link_dhcp4_server_enabled(link))
3416 (void) sd_dhcp_server_stop(link->dhcp_server);
45a9eac9 3417
3104883d
SS		 3418 r = link_drop_config(link);
3419 if (r < 0)
3420 return r;
3421
f258e948
MP		 3422 if (!IN_SET(link->state, LINK_STATE_UNMANAGED, LINK_STATE_PENDING)) {
3423 log_link_debug(link, "State is %s, dropping config", link_state_to_string(link->state));
c436d553
MM		 3424 r = link_drop_foreign_config(link);
3425 if (r < 0)
3426 return r;
3427 }
3104883d 3428
0d4ad91d
AR		 3429 r = link_handle_bound_by_list(link);
3430 if (r < 0)
3431 return r;
3432
9c0a72f9
TG		 3433 return 0;
3434}
3435
3436int link_carrier_reset(Link *link) {
3437 int r;
3438
3439 assert(link);
3440
3441 if (link_has_carrier(link)) {
3442 r = link_carrier_lost(link);
3443 if (r < 0)
3444 return r;
3445
3446 r = link_carrier_gained(link);
3447 if (r < 0)
3448 return r;
3449
6a7a4e4d 3450 log_link_info(link, "Reset carrier");
9c0a72f9
TG		 3451 }
3452
3453 return 0;
3454}
3455
1c4baffc 3456int link_update(Link *link, sd_netlink_message *m) {
c49b33ac 3457 struct ether_addr mac;
ca4e095a 3458 const char *ifname;
afe7fd56 3459 uint32_t mtu;
a61bb41c 3460 bool had_carrier, carrier_gained, carrier_lost;
bb262ef0 3461 int old_master, r;
22936833 3462
dd3efc09 3463 assert(link);
b8941f74 3464 assert(link->ifname);
22936833
TG		 3465 assert(m);
3466
7619683b 3467 if (link->state == LINK_STATE_LINGER) {
5238e957 3468 log_link_info(link, "Link re-added");
289e6774 3469 link_set_state(link, LINK_STATE_CONFIGURING);
0d4ad91d
AR		 3470
3471 r = link_new_carrier_maps(link);
3472 if (r < 0)
3473 return r;
7619683b
TG		 3474 }
3475
1c4baffc 3476 r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
b8941f74 3477 if (r >= 0 && !streq(ifname, link->ifname)) {
30de2b89 3478 Manager *manager = link->manager;
b8941f74 3479
30de2b89 3480 log_link_info(link, "Interface name change detected, %s has been renamed to %s.", link->ifname, ifname);
0d4ad91d 3481
30de2b89
YW		 3482 link_drop(link);
3483 r = link_add(manager, m, &link);
3484 if (r < 0)
3485 return r;
b8941f74
TG		 3486 }
3487
1c4baffc 3488 r = sd_netlink_message_read_u32(m, IFLA_MTU, &mtu);
afe7fd56
TG		 3489 if (r >= 0 && mtu > 0) {
3490 link->mtu = mtu;
4e964aa0 3491 if (link->original_mtu == 0) {
afe7fd56 3492 link->original_mtu = mtu;
6a7a4e4d 3493 log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
afe7fd56
TG		 3494 }
3495
3496 if (link->dhcp_client) {
3c9b8860
TG		 3497 r = sd_dhcp_client_set_mtu(link->dhcp_client,
3498 link->mtu);
fc95c359
YW		 3499 if (r < 0)
3500 return log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
afe7fd56 3501 }
7465dd22
PF		 3502
3503 if (link->radv) {
3504 r = sd_radv_set_mtu(link->radv, link->mtu);
3505 if (r < 0)
3506 return log_link_warning_errno(link, r, "Could not set MTU for Router Advertisement: %m");
3507 }
9842de0d 3508 }
69629de9 3509
e9189a1f
TG		 3510 /* The kernel may broadcast NEWLINK messages without the MAC address
3511 set, simply ignore them. */
1c4baffc 3512 r = sd_netlink_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
e9189a1f 3513 if (r >= 0) {
3c9b8860
TG		 3514 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
3515 ETH_ALEN)) {
c49b33ac 3516
3c9b8860
TG		 3517 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
3518 ETH_ALEN);
c49b33ac 3519
79008bdd 3520 log_link_debug(link, "MAC address: "
20861203
TG		 3521 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
3522 mac.ether_addr_octet[0],
3523 mac.ether_addr_octet[1],
3524 mac.ether_addr_octet[2],
3525 mac.ether_addr_octet[3],
3526 mac.ether_addr_octet[4],
3527 mac.ether_addr_octet[5]);
c49b33ac 3528
20861203
TG		 3529 if (link->ipv4ll) {
3530 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
6a7a4e4d
LP		 3531 if (r < 0)
3532 return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
c49b33ac 3533 }
c49b33ac 3534
20861203 3535 if (link->dhcp_client) {
3c9b8860 3536 r = sd_dhcp_client_set_mac(link->dhcp_client,
76253e73
DW		 3537 (const uint8_t *) &link->mac,
3538 sizeof (link->mac),
3539 ARPHRD_ETHER);
6a7a4e4d
LP		 3540 if (r < 0)
3541 return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
413708d1 3542
fff1f40c
YW		 3543 r = dhcp4_set_client_identifier(link);
3544 if (r < 0)
3545 return r;
c49b33ac 3546 }
4138fb2c
PF		 3547
3548 if (link->dhcp6_client) {
f24648a6 3549 const DUID* duid = link_get_duid(link);
8341a5c3 3550
4138fb2c 3551 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
76253e73
DW		 3552 (const uint8_t *) &link->mac,
3553 sizeof (link->mac),
3554 ARPHRD_ETHER);
6a7a4e4d
LP		 3555 if (r < 0)
3556 return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
413708d1 3557
8217ed5e
TH		 3558 if (link->network->iaid_set) {
3559 r = sd_dhcp6_client_set_iaid(link->dhcp6_client,
3560 link->network->iaid);
3561 if (r < 0)
3562 return log_link_warning_errno(link, r, "Could not update DHCPv6 IAID: %m");
3563 }
413708d1 3564
8341a5c3
ZJS		 3565 r = sd_dhcp6_client_set_duid(link->dhcp6_client,
3566 duid->type,
3567 duid->raw_data_len > 0 ? duid->raw_data : NULL,
3568 duid->raw_data_len);
413708d1
VK		 3569 if (r < 0)
3570 return log_link_warning_errno(link, r, "Could not update DHCPv6 DUID: %m");
4138fb2c 3571 }
7465dd22
PF		 3572
3573 if (link->radv) {
3574 r = sd_radv_set_mac(link->radv, &link->mac);
3575 if (r < 0)
3576 return log_link_warning_errno(link, r, "Could not update MAC for Router Advertisement: %m");
3577 }
420d2058
SS		 3578
3579 if (link->ndisc) {
3580 r = sd_ndisc_set_mac(link->ndisc, &link->mac);
3581 if (r < 0)
3582 return log_link_warning_errno(link, r, "Could not update MAC for ndisc: %m");
3583 }
c49b33ac 3584 }
4f882b2a
TG		 3585 }
3586
bb262ef0
YW		 3587 old_master = link->master_ifindex;
3588 (void) sd_netlink_message_read_u32(m, IFLA_MASTER, (uint32_t *) &link->master_ifindex);
3589
a61bb41c
TG		 3590 had_carrier = link_has_carrier(link);
3591
bb262ef0 3592 r = link_update_flags(link, m, old_master != link->master_ifindex);
a61bb41c
TG		 3593 if (r < 0)
3594 return r;
3595
273eec24
LP		 3596 r = link_update_lldp(link);
3597 if (r < 0)
3598 return r;
3599
a61bb41c
TG		 3600 carrier_gained = !had_carrier && link_has_carrier(link);
3601 carrier_lost = had_carrier && !link_has_carrier(link);
3602
3603 if (carrier_gained) {
6a7a4e4d 3604 log_link_info(link, "Gained carrier");
a61bb41c 3605
9c0a72f9
TG		 3606 r = link_carrier_gained(link);
3607 if (r < 0)
3608 return r;
a61bb41c 3609 } else if (carrier_lost) {
6a7a4e4d 3610 log_link_info(link, "Lost carrier");
a61bb41c 3611
9c0a72f9
TG		 3612 r = link_carrier_lost(link);
3613 if (r < 0)
a61bb41c 3614 return r;
a61bb41c
TG		 3615 }
3616
3617 return 0;
dd3efc09 3618}
fe8db0c5 3619
b295beea
LP		 3620static void print_link_hashmap(FILE *f, const char *prefix, Hashmap* h) {
3621 bool space = false;
3622 Iterator i;
3623 Link *link;
3624
3625 assert(f);
3626 assert(prefix);
3627
3628 if (hashmap_isempty(h))
3629 return;
3630
0d536673 3631 fputs(prefix, f);
b295beea
LP		 3632 HASHMAP_FOREACH(link, h, i) {
3633 if (space)
0d536673 3634 fputc(' ', f);
b295beea
LP		 3635
3636 fprintf(f, "%i", link->ifindex);
3637 space = true;
3638 }
3639
0d536673 3640 fputc('\n', f);
b295beea
LP		 3641}
3642
15761549
YW		 3643static void link_save_dns(FILE *f, struct in_addr_data *dns, unsigned n_dns, bool *space) {
3644 unsigned j;
3645 int r;
3646
3647 for (j = 0; j < n_dns; j++) {
3648 _cleanup_free_ char *b = NULL;
3649
3650 r = in_addr_to_string(dns[j].family, &dns[j].address, &b);
3651 if (r < 0) {
3652 log_debug_errno(r, "Failed to format address, ignoring: %m");
3653 continue;
3654 }
3655
3656 if (*space)
3657 fputc(' ', f);
3658 fputs(b, f);
3659 *space = true;
3660 }
3661}
3662
fe8db0c5 3663int link_save(Link *link) {
68a8723c 3664 _cleanup_free_ char *temp_path = NULL;
fe8db0c5 3665 _cleanup_fclose_ FILE *f = NULL;
ac999bf0 3666 const char *admin_state, *oper_state, *carrier_state, *address_state;
e7780c8d 3667 Address *a;
c1eb9872 3668 Route *route;
e7780c8d 3669 Iterator i;
fe8db0c5
TG		 3670 int r;
3671
3672 assert(link);
3673 assert(link->state_file);
68a8723c 3674 assert(link->lease_file);
bbf7c048
TG		 3675 assert(link->manager);
3676
370e9930 3677 if (link->state == LINK_STATE_LINGER) {
6990fb6b 3678 (void) unlink(link->state_file);
370e9930
TG		 3679 return 0;
3680 }
3681
34437b4f
LP		 3682 link_lldp_save(link);
3683
deb2e523
TG		 3684 admin_state = link_state_to_string(link->state);
3685 assert(admin_state);
3686
e375dcde
TG		 3687 oper_state = link_operstate_to_string(link->operstate);
3688 assert(oper_state);
deb2e523 3689
ac999bf0
YW		 3690 carrier_state = link_carrier_state_to_string(link->carrier_state);
3691 assert(carrier_state);
3692
3693 address_state = link_address_state_to_string(link->address_state);
3694 assert(address_state);
3695
fe8db0c5
TG		 3696 r = fopen_temporary(link->state_file, &f, &temp_path);
3697 if (r < 0)
6a7a4e4d 3698 goto fail;
fe8db0c5 3699
5512a963 3700 (void) fchmod(fileno(f), 0644);
fe8db0c5
TG		 3701
3702 fprintf(f,
3703 "# This is private data. Do not parse.\n"
deb2e523 3704 "ADMIN_STATE=%s\n"
ac999bf0
YW		 3705 "OPER_STATE=%s\n"
3706 "CARRIER_STATE=%s\n"
3707 "ADDRESS_STATE=%s\n",
3708 admin_state, oper_state, carrier_state, address_state);
fe8db0c5 3709
bcb7a07e 3710 if (link->network) {
fe0e16db
YW		 3711 char **dhcp6_domains = NULL, **dhcp_domains = NULL;
3712 const char *dhcp_domainname = NULL, *p;
07bdc70d 3713 sd_dhcp6_lease *dhcp6_lease = NULL;
fe0e16db 3714 bool space;
07bdc70d 3715
c1a38904
MTL		 3716 fprintf(f, "REQUIRED_FOR_ONLINE=%s\n",
3717 yes_no(link->network->required_for_online));
3718
4ac77d63
YW		 3719 fprintf(f, "REQUIRED_OPER_STATE_FOR_ONLINE=%s\n",
3720 strempty(link_operstate_to_string(link->network->required_operstate_for_online)));
3721
07bdc70d 3722 if (link->dhcp6_client) {
4058d339
TG		 3723 r = sd_dhcp6_client_get_lease(link->dhcp6_client, &dhcp6_lease);
3724 if (r < 0 && r != -ENOMSG)
07bdc70d
PF		 3725 log_link_debug(link, "No DHCPv6 lease");
3726 }
b0e39c82 3727
adc5b2e2
TG		 3728 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
3729
0d536673 3730 fputs("DNS=", f);
ea352b40 3731 space = false;
5512a963 3732
15761549
YW		 3733 if (link->n_dns != (unsigned) -1)
3734 link_save_dns(f, link->dns, link->n_dns, &space);
3735 else
3736 link_save_dns(f, link->network->dns, link->network->n_dns, &space);
d5314fff 3737
27cb34f5 3738 if (link->network->dhcp_use_dns &&
b0e39c82
TG		 3739 link->dhcp_lease) {
3740 const struct in_addr *addresses;
3741
3742 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
072320ea
TH		 3743 if (r > 0)
3744 if (serialize_in_addrs(f, addresses, r, space, in4_addr_is_non_local) > 0)
3745 space = true;
07bdc70d
PF		 3746 }
3747
caa8ca42 3748 if (link->network->dhcp6_use_dns && dhcp6_lease) {
07bdc70d
PF		 3749 struct in6_addr *in6_addrs;
3750
3751 r = sd_dhcp6_lease_get_dns(dhcp6_lease, &in6_addrs);
3752 if (r > 0) {
3753 if (space)
0d536673 3754 fputc(' ', f);
07bdc70d 3755 serialize_in6_addrs(f, in6_addrs, r);
1e7a0e21
LP		 3756 space = true;
3757 }
3758 }
3759
3760 /* Make sure to flush out old entries before we use the NDISC data */
3761 ndisc_vacuum(link);
3762
b296797f 3763 if (link->network->ipv6_accept_ra_use_dns && link->ndisc_rdnss) {
1e7a0e21
LP		 3764 NDiscRDNSS *dd;
3765
3766 SET_FOREACH(dd, link->ndisc_rdnss, i) {
3767 if (space)
0d536673 3768 fputc(' ', f);
1e7a0e21
LP		 3769
3770 serialize_in6_addrs(f, &dd->address, 1);
3771 space = true;
b0e39c82
TG		 3772 }
3773 }
3774
0d536673 3775 fputc('\n', f);
b0e39c82 3776
0d536673 3777 fputs("NTP=", f);
ea352b40 3778 space = false;
15761549 3779 fputstrv(f, link->ntp ?: link->network->ntp, NULL, &space);
d5314fff 3780
27cb34f5 3781 if (link->network->dhcp_use_ntp &&
b0e39c82
TG		 3782 link->dhcp_lease) {
3783 const struct in_addr *addresses;
3784
3785 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
299d578f
SS		 3786 if (r > 0)
3787 if (serialize_in_addrs(f, addresses, r, space, in4_addr_is_non_local) > 0)
3788 space = true;
3789 }
3790
3791 fputc('\n', f);
3792
3793 fputs("SIP=", f);
3794 space = false;
3795 fputstrv(f, link->network->sip, NULL, &space);
3796
3797 if (link->network->dhcp_use_sip &&
3798 link->dhcp_lease) {
3799 const struct in_addr *addresses;
3800
3801 r = sd_dhcp_lease_get_sip(link->dhcp_lease, &addresses);
072320ea
TH		 3802 if (r > 0)
3803 if (serialize_in_addrs(f, addresses, r, space, in4_addr_is_non_local) > 0)
3804 space = true;
07bdc70d
PF		 3805 }
3806
caa8ca42 3807 if (link->network->dhcp6_use_ntp && dhcp6_lease) {
07bdc70d
PF		 3808 struct in6_addr *in6_addrs;
3809 char **hosts;
07bdc70d
PF		 3810
3811 r = sd_dhcp6_lease_get_ntp_addrs(dhcp6_lease,
3812 &in6_addrs);
3813 if (r > 0) {
3814 if (space)
0d536673 3815 fputc(' ', f);
07bdc70d
PF		 3816 serialize_in6_addrs(f, in6_addrs, r);
3817 space = true;
3818 }
3819
3820 r = sd_dhcp6_lease_get_ntp_fqdn(dhcp6_lease, &hosts);
3df9bec5
LP		 3821 if (r > 0)
3822 fputstrv(f, hosts, NULL, &space);
b0e39c82
TG		 3823 }
3824
0d536673 3825 fputc('\n', f);
bd8f6538 3826
b2a81c0b 3827 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
b85bc551 3828 if (link->dhcp_lease) {
b2a81c0b 3829 (void) sd_dhcp_lease_get_domainname(link->dhcp_lease, &dhcp_domainname);
b85bc551
DW		 3830 (void) sd_dhcp_lease_get_search_domains(link->dhcp_lease, &dhcp_domains);
3831 }
b2a81c0b
LP		 3832 if (dhcp6_lease)
3833 (void) sd_dhcp6_lease_get_domains(dhcp6_lease, &dhcp6_domains);
07bdc70d
PF		 3834 }
3835
fe0e16db
YW		 3836 fputs("DOMAINS=", f);
3837 space = false;
15761549 3838 ORDERED_SET_FOREACH(p, link->search_domains ?: link->network->search_domains, i)
fe0e16db 3839 fputs_with_space(f, p, NULL, &space);
07bdc70d 3840
1e7a0e21 3841 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES) {
1e7a0e21
LP		 3842 if (dhcp_domainname)
3843 fputs_with_space(f, dhcp_domainname, NULL, &space);
b85bc551
DW		 3844 if (dhcp_domains)
3845 fputstrv(f, dhcp_domains, NULL, &space);
1e7a0e21
LP		 3846 if (dhcp6_domains)
3847 fputstrv(f, dhcp6_domains, NULL, &space);
a0cd6da5
YW		 3848 }
3849
3850 if (link->network->ipv6_accept_ra_use_domains == DHCP_USE_DOMAINS_YES) {
3851 NDiscDNSSL *dd;
1e7a0e21
LP		 3852
3853 SET_FOREACH(dd, link->ndisc_dnssl, i)
3854 fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
3855 }
b2a81c0b 3856
0d536673 3857 fputc('\n', f);
6192b846 3858
fe0e16db
YW		 3859 fputs("ROUTE_DOMAINS=", f);
3860 space = false;
15761549 3861 ORDERED_SET_FOREACH(p, link->route_domains ?: link->network->route_domains, i)
fe0e16db 3862 fputs_with_space(f, p, NULL, &space);
b2a81c0b 3863
1e7a0e21 3864 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_ROUTE) {
1e7a0e21
LP		 3865 if (dhcp_domainname)
3866 fputs_with_space(f, dhcp_domainname, NULL, &space);
b85bc551
DW		 3867 if (dhcp_domains)
3868 fputstrv(f, dhcp_domains, NULL, &space);
1e7a0e21
LP		 3869 if (dhcp6_domains)
3870 fputstrv(f, dhcp6_domains, NULL, &space);
a0cd6da5
YW		 3871 }
3872
3873 if (link->network->ipv6_accept_ra_use_domains == DHCP_USE_DOMAINS_ROUTE) {
3874 NDiscDNSSL *dd;
1e7a0e21
LP		 3875
3876 SET_FOREACH(dd, link->ndisc_dnssl, i)
3877 fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
3878 }
b2a81c0b 3879
0d536673 3880 fputc('\n', f);
67272d15 3881
3c9b8860 3882 fprintf(f, "LLMNR=%s\n",
15761549 3883 resolve_support_to_string(link->llmnr >= 0 ? link->llmnr : link->network->llmnr));
aaa297d4 3884 fprintf(f, "MDNS=%s\n",
15761549
YW		 3885 resolve_support_to_string(link->mdns >= 0 ? link->mdns : link->network->mdns));
3886 if (link->dns_default_route >= 0)
3887 fprintf(f, "DNS_DEFAULT_ROUTE=%s\n", yes_no(link->dns_default_route));
3888 else if (link->network->dns_default_route >= 0)
7ece6f58 3889 fprintf(f, "DNS_DEFAULT_ROUTE=%s\n", yes_no(link->network->dns_default_route));
e7780c8d 3890
15761549
YW		 3891 if (link->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
3892 fprintf(f, "DNS_OVER_TLS=%s\n",
3893 dns_over_tls_mode_to_string(link->dns_over_tls_mode));
3894 else if (link->network->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
c9299be2
IT		 3895 fprintf(f, "DNS_OVER_TLS=%s\n",
3896 dns_over_tls_mode_to_string(link->network->dns_over_tls_mode));
d050561a 3897
15761549
YW		 3898 if (link->dnssec_mode != _DNSSEC_MODE_INVALID)
3899 fprintf(f, "DNSSEC=%s\n",
3900 dnssec_mode_to_string(link->dnssec_mode));
3901 else if (link->network->dnssec_mode != _DNSSEC_MODE_INVALID)
ad6c0475
LP		 3902 fprintf(f, "DNSSEC=%s\n",
3903 dnssec_mode_to_string(link->network->dnssec_mode));
3904
15761549
YW		 3905 if (!set_isempty(link->dnssec_negative_trust_anchors)) {
3906 const char *n;
3907
3908 fputs("DNSSEC_NTA=", f);
3909 space = false;
3910 SET_FOREACH(n, link->dnssec_negative_trust_anchors, i)
3911 fputs_with_space(f, n, NULL, &space);
3912 fputc('\n', f);
3913 } else if (!set_isempty(link->network->dnssec_negative_trust_anchors)) {
8a516214
LP		 3914 const char *n;
3915
0d536673 3916 fputs("DNSSEC_NTA=", f);
8a516214 3917 space = false;
d390f8ef
LP		 3918 SET_FOREACH(n, link->network->dnssec_negative_trust_anchors, i)
3919 fputs_with_space(f, n, NULL, &space);
0d536673 3920 fputc('\n', f);
8a516214
LP		 3921 }
3922
0d536673 3923 fputs("ADDRESSES=", f);
e7780c8d
TG		 3924 space = false;
3925 SET_FOREACH(a, link->addresses, i) {
3926 _cleanup_free_ char *address_str = NULL;
3927
3928 r = in_addr_to_string(a->family, &a->in_addr, &address_str);
3929 if (r < 0)
3930 goto fail;
3931
e7780c8d
TG		 3932 fprintf(f, "%s%s/%u", space ? " " : "", address_str, a->prefixlen);
3933 space = true;
3934 }
0d536673 3935 fputc('\n', f);
c1eb9872 3936
0d536673 3937 fputs("ROUTES=", f);
c1eb9872
TG		 3938 space = false;
3939 SET_FOREACH(route, link->routes, i) {
3940 _cleanup_free_ char *route_str = NULL;
3941
3942 r = in_addr_to_string(route->family, &route->dst, &route_str);
3943 if (r < 0)
3944 goto fail;
3945
ecc3f340
ZJS		 3946 fprintf(f, "%s%s/%hhu/%hhu/%"PRIu32"/%"PRIu32"/"USEC_FMT,
3947 space ? " " : "", route_str,
f833694d 3948 route->dst_prefixlen, route->tos, route->priority, route->table, route->lifetime);
c1eb9872
TG		 3949 space = true;
3950 }
3951
0d536673 3952 fputc('\n', f);
bcb7a07e 3953 }
7374f9d8 3954
b295beea
LP		 3955 print_link_hashmap(f, "CARRIER_BOUND_TO=", link->bound_to_links);
3956 print_link_hashmap(f, "CARRIER_BOUND_BY=", link->bound_by_links);
0d4ad91d 3957
8eb9058d 3958 if (link->dhcp_lease) {
0bc70f1d 3959 struct in_addr address;
8eb9058d
LP		 3960 const char *tz = NULL;
3961
0bc70f1d
TG		 3962 assert(link->network);
3963
8eb9058d
LP		 3964 r = sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
3965 if (r >= 0)
3966 fprintf(f, "TIMEZONE=%s\n", tz);
8eb9058d 3967
0bc70f1d
TG		 3968 r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
3969 if (r >= 0) {
0d536673 3970 fputs("DHCP4_ADDRESS=", f);
072320ea 3971 serialize_in_addrs(f, &address, 1, false, NULL);
0d536673 3972 fputc('\n', f);
0bc70f1d 3973 }
d9876a52 3974
bd91b83e 3975 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
fe8db0c5 3976 if (r < 0)
c2d6bd61 3977 goto fail;
fe8db0c5 3978
7374f9d8 3979 fprintf(f,
b0e39c82
TG		 3980 "DHCP_LEASE=%s\n",
3981 link->lease_file);
deb2e523 3982 } else
6990fb6b 3983 (void) unlink(link->lease_file);
fe8db0c5 3984
0bc70f1d
TG		 3985 if (link->ipv4ll) {
3986 struct in_addr address;
3987
3988 r = sd_ipv4ll_get_address(link->ipv4ll, &address);
3989 if (r >= 0) {
0d536673 3990 fputs("IPV4LL_ADDRESS=", f);
072320ea 3991 serialize_in_addrs(f, &address, 1, false, NULL);
0d536673 3992 fputc('\n', f);
0bc70f1d
TG		 3993 }
3994 }
3995
c2d6bd61
LP		 3996 r = fflush_and_check(f);
3997 if (r < 0)
3998 goto fail;
fe8db0c5 3999
c2d6bd61 4000 if (rename(temp_path, link->state_file) < 0) {
fe8db0c5 4001 r = -errno;
c2d6bd61 4002 goto fail;
fe8db0c5
TG		 4003 }
4004
c2d6bd61 4005 return 0;
dacd6cee 4006
c2d6bd61 4007fail:
6a7a4e4d 4008 (void) unlink(link->state_file);
6a7a4e4d
LP		 4009 if (temp_path)
4010 (void) unlink(temp_path);
4011
dacd6cee 4012 return log_link_error_errno(link, r, "Failed to save link data to %s: %m", link->state_file);
fe8db0c5
TG		 4013}
4014
84de38c5
TG		 4015/* The serialized state in /run is no longer up-to-date. */
4016void link_dirty(Link *link) {
4017 int r;
4018
4019 assert(link);
4020
0c241a37
SS		 4021 /* mark manager dirty as link is dirty */
4022 manager_dirty(link->manager);
4023
84de38c5
TG		 4024 r = set_ensure_allocated(&link->manager->dirty_links, NULL);
4025 if (r < 0)
4026 /* allocation errors are ignored */
4027 return;
4028
4029 r = set_put(link->manager->dirty_links, link);
0c241a37
SS		 4030 if (r <= 0)
4031 /* don't take another ref if the link was already dirty */
84de38c5
TG		 4032 return;
4033
4034 link_ref(link);
4035}
4036
4037/* The serialized state in /run is up-to-date */
4038void link_clean(Link *link) {
4039 assert(link);
4040 assert(link->manager);
4041
1046bf9b 4042 link_unref(set_remove(link->manager->dirty_links, link));
84de38c5
TG		 4043}
4044
fe8db0c5 4045static const char* const link_state_table[_LINK_STATE_MAX] = {
8434fd5c 4046 [LINK_STATE_PENDING] = "pending",
bd08ce56 4047 [LINK_STATE_INITIALIZED] = "initialized",
289e6774 4048 [LINK_STATE_CONFIGURING] = "configuring",
fe8db0c5 4049 [LINK_STATE_CONFIGURED] = "configured",
57bd6899 4050 [LINK_STATE_UNMANAGED] = "unmanaged",
fe8db0c5 4051 [LINK_STATE_FAILED] = "failed",
370e9930 4052 [LINK_STATE_LINGER] = "linger",
fe8db0c5
TG		 4053};
4054
4055DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
5ecb131d
YW		 4056
4057int log_link_message_full_errno(Link *link, sd_netlink_message *m, int level, int err, const char *msg) {
4058 const char *err_msg = NULL;
4059
4060 (void) sd_netlink_message_read_string(m, NLMSGERR_ATTR_MSG, &err_msg);
4061 return log_link_full(link, level, err, "%s: %s%s%m", msg, strempty(err_msg), err_msg ? " " : "");
4062}
Unnamed repository; edit this file 'description' to name the repository.