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