]> 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
fileio: add 'enforce_newline' argument to write_string_stream()
[thirdparty/systemd.git] / src / network / networkd-link.c
CommitLineData
f579559b
TG		 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2013 Tom Gundersen <teg@jklm.no>
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
22#include <netinet/ether.h>
23#include <linux/if.h>
4cc7a82c 24#include <unistd.h>
f579559b 25
f579559b 26#include "util.h"
505f8da7 27#include "virt.h"
5a8bcb67 28#include "fileio.h"
fe027299 29#include "socket-util.h"
1346b1f0 30#include "bus-util.h"
5a8bcb67 31#include "udev-util.h"
c6f7c917 32#include "network-internal.h"
5a8bcb67
LP		 33#include "networkd-link.h"
34#include "networkd-netdev.h"
fe8db0c5 35
a97dcc12 36bool link_dhcp6_enabled(Link *link) {
78c958f8
TG		 37 if (link->flags & IFF_LOOPBACK)
38 return false;
39
40 if (!link->network)
41 return false;
42
e0ee46f2 43 return link->network->dhcp & ADDRESS_FAMILY_IPV6;
78c958f8
TG		 44}
45
a97dcc12 46bool link_dhcp4_enabled(Link *link) {
78c958f8
TG		 47 if (link->flags & IFF_LOOPBACK)
48 return false;
49
50 if (!link->network)
51 return false;
52
e0ee46f2 53 return link->network->dhcp & ADDRESS_FAMILY_IPV4;
78c958f8
TG		 54}
55
a97dcc12 56bool link_dhcp4_server_enabled(Link *link) {
78c958f8
TG		 57 if (link->flags & IFF_LOOPBACK)
58 return false;
59
60 if (!link->network)
61 return false;
62
63 return link->network->dhcp_server;
64}
65
a97dcc12 66bool link_ipv4ll_enabled(Link *link) {
78c958f8
TG		 67 if (link->flags & IFF_LOOPBACK)
68 return false;
69
70 if (!link->network)
71 return false;
72
e0ee46f2 73 return link->network->link_local & ADDRESS_FAMILY_IPV4;
d0d6a4cd
TG		 74}
75
76bool link_ipv6ll_enabled(Link *link) {
77 if (link->flags & IFF_LOOPBACK)
78 return false;
79
80 if (!link->network)
81 return false;
82
e0ee46f2 83 return link->network->link_local & ADDRESS_FAMILY_IPV6;
78c958f8
TG		 84}
85
a97dcc12 86bool link_lldp_enabled(Link *link) {
ce43e484
SS		 87 if (link->flags & IFF_LOOPBACK)
88 return false;
89
90 if (!link->network)
91 return false;
92
5a8bcb67 93 if (link->network->bridge)
ce43e484
SS		 94 return false;
95
96 return link->network->lldp;
97}
98
769d324c 99static bool link_ipv4_forward_enabled(Link *link) {
5a8bcb67
LP		 100 if (link->flags & IFF_LOOPBACK)
101 return false;
102
103 if (!link->network)
104 return false;
105
e0ee46f2 106 return link->network->ip_forward & ADDRESS_FAMILY_IPV4;
769d324c
LP		 107}
108
109static bool link_ipv6_forward_enabled(Link *link) {
110 if (link->flags & IFF_LOOPBACK)
111 return false;
112
113 if (!link->network)
114 return false;
115
e0ee46f2 116 return link->network->ip_forward & ADDRESS_FAMILY_IPV6;
5a8bcb67
LP		 117}
118
1f0d9695 119static IPv6PrivacyExtensions link_ipv6_privacy_extensions(Link *link) {
49092e22 120 if (link->flags & IFF_LOOPBACK)
1f0d9695 121 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
49092e22
SS		 122
123 if (!link->network)
1f0d9695 124 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
49092e22
SS		 125
126 return link->network->ipv6_privacy_extensions;
127}
128
51d18171
TG		 129#define FLAG_STRING(string, flag, old, new) \
130 (((old ^ new) & flag) \
131 ? ((old & flag) ? (" -" string) : (" +" string)) \
132 : "")
133
1c4baffc 134static int link_update_flags(Link *link, sd_netlink_message *m) {
51d18171
TG		 135 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
136 uint8_t operstate;
137 int r;
138
139 assert(link);
140
141 r = sd_rtnl_message_link_get_flags(m, &flags);
6a7a4e4d
LP		 142 if (r < 0)
143 return log_link_warning_errno(link, r, "Could not get link flags: %m");
51d18171 144
1c4baffc 145 r = sd_netlink_message_read_u8(m, IFLA_OPERSTATE, &operstate);
51d18171
TG		 146 if (r < 0)
147 /* if we got a message without operstate, take it to mean
148 the state was unchanged */
149 operstate = link->kernel_operstate;
150
151 if ((link->flags == flags) && (link->kernel_operstate == operstate))
152 return 0;
153
154 if (link->flags != flags) {
6a7a4e4d 155 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		 156 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
157 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
158 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
159 FLAG_STRING("UP", IFF_UP, link->flags, flags),
160 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
161 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
162 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
163 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
164 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
165 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
166 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
167 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
168 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
169 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
170 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
171 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
172 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
173 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
174 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
175
176 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
177 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
178 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
179 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
180 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
181 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
182 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
183 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
184
185 /* link flags are currently at most 18 bits, let's align to
186 * printing 20 */
187 if (unknown_flags_added)
79008bdd 188 log_link_debug(link,
6a7a4e4d 189 "Unknown link flags gained: %#.5x (ignoring)",
51d18171
TG		 190 unknown_flags_added);
191
192 if (unknown_flags_removed)
79008bdd 193 log_link_debug(link,
6a7a4e4d 194 "Unknown link flags lost: %#.5x (ignoring)",
51d18171
TG		 195 unknown_flags_removed);
196 }
197
198 link->flags = flags;
199 link->kernel_operstate = operstate;
200
201 link_save(link);
202
203 return 0;
204}
205
1c4baffc 206static int link_new(Manager *manager, sd_netlink_message *message, Link **ret) {
14b746f7 207 _cleanup_link_unref_ Link *link = NULL;
505f8da7 208 uint16_t type;
ca4e095a 209 const char *ifname;
505f8da7 210 int r, ifindex;
f579559b 211
0c2f9b84 212 assert(manager);
505f8da7 213 assert(message);
f579559b
TG		 214 assert(ret);
215
1c4baffc 216 r = sd_netlink_message_get_type(message, &type);
505f8da7
TG		 217 if (r < 0)
218 return r;
219 else if (type != RTM_NEWLINK)
220 return -EINVAL;
221
222 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
223 if (r < 0)
224 return r;
225 else if (ifindex <= 0)
226 return -EINVAL;
227
1c4baffc 228 r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
505f8da7
TG		 229 if (r < 0)
230 return r;
231
f579559b
TG		 232 link = new0(Link, 1);
233 if (!link)
234 return -ENOMEM;
235
14b746f7 236 link->n_ref = 1;
5a3eb5a7 237 link->manager = manager;
8434fd5c 238 link->state = LINK_STATE_PENDING;
be3a09b7 239 link->rtnl_extended_attrs = true;
505f8da7
TG		 240 link->ifindex = ifindex;
241 link->ifname = strdup(ifname);
242 if (!link->ifname)
243 return -ENOMEM;
f579559b 244
1c4baffc 245 r = sd_netlink_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
512922f8 246 if (r < 0)
79008bdd 247 log_link_debug(link, "MAC address not found for new device, continuing without");
512922f8 248
3c9b8860
TG		 249 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
250 link->ifindex);
fe8db0c5 251 if (r < 0)
315db1a8 252 return -ENOMEM;
fe8db0c5 253
3c9b8860
TG		 254 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
255 link->ifindex);
68a8723c
TG		 256 if (r < 0)
257 return -ENOMEM;
258
49699bac
SS		 259 r = asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d",
260 link->ifindex);
261 if (r < 0)
262 return -ENOMEM;
263
264
d5099efc 265 r = hashmap_ensure_allocated(&manager->links, NULL);
ae06ab10
TG		 266 if (r < 0)
267 return r;
268
269 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
f579559b
TG		 270 if (r < 0)
271 return r;
272
51d18171
TG		 273 r = link_update_flags(link, message);
274 if (r < 0)
275 return r;
276
f579559b
TG		 277 *ret = link;
278 link = NULL;
279
280 return 0;
281}
282
14b746f7 283static void link_free(Link *link) {
428fd0a7 284 Address *address;
0d4ad91d
AR		 285 Iterator i;
286 Link *carrier;
428fd0a7 287
f579559b
TG		 288 if (!link)
289 return;
290
428fd0a7
TG		 291 while ((address = link->addresses)) {
292 LIST_REMOVE(addresses, link->addresses, address);
293 address_free(address);
294 }
295
11bf3cce
LP		 296 while ((address = link->pool_addresses)) {
297 LIST_REMOVE(addresses, link->pool_addresses, address);
298 address_free(address);
299 }
300
bfcdba8d 301 sd_dhcp_server_unref(link->dhcp_server);
e5b04c8d 302 sd_dhcp_client_unref(link->dhcp_client);
a6cc569e 303 sd_dhcp_lease_unref(link->dhcp_lease);
f5be5601 304
68a8723c
TG		 305 free(link->lease_file);
306
07e10d1a
TG		 307 sd_lldp_free(link->lldp);
308
49699bac
SS		 309 free(link->lldp_file);
310
56cd007a 311 sd_ipv4ll_unref(link->ipv4ll);
4138fb2c 312 sd_dhcp6_client_unref(link->dhcp6_client);
6b66097b 313 sd_icmp6_nd_unref(link->icmp6_router_discovery);
4138fb2c 314
28aeb07f 315 if (link->manager)
ae06ab10 316 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
f579559b 317
c166a070 318 free(link->ifname);
68a8723c 319
fe8db0c5 320 free(link->state_file);
c166a070 321
b5db00e5
UTL		 322 udev_device_unref(link->udev_device);
323
0d4ad91d
AR		 324 HASHMAP_FOREACH (carrier, link->bound_to_links, i)
325 hashmap_remove(link->bound_to_links, INT_TO_PTR(carrier->ifindex));
326 hashmap_free(link->bound_to_links);
327
328 HASHMAP_FOREACH (carrier, link->bound_by_links, i)
329 hashmap_remove(link->bound_by_links, INT_TO_PTR(carrier->ifindex));
330 hashmap_free(link->bound_by_links);
331
f579559b
TG		 332 free(link);
333}
334
14b746f7
TG		 335Link *link_unref(Link *link) {
336 if (link && (-- link->n_ref <= 0))
337 link_free(link);
338
339 return NULL;
340}
341
342Link *link_ref(Link *link) {
343 if (link)
344 assert_se(++ link->n_ref >= 2);
345
346 return link;
347}
348
11a7f229
TG		 349int link_get(Manager *m, int ifindex, Link **ret) {
350 Link *link;
11a7f229
TG		 351
352 assert(m);
11a7f229
TG		 353 assert(ifindex);
354 assert(ret);
355
ae06ab10 356 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
11a7f229
TG		 357 if (!link)
358 return -ENODEV;
359
360 *ret = link;
361
362 return 0;
363}
364
e331e246
TG		 365static void link_set_state(Link *link, LinkState state) {
366 assert(link);
367
368 if (link->state == state)
369 return;
370
371 link->state = state;
372
373 link_send_changed(link, "AdministrativeState", NULL);
374
375 return;
376}
377
57bd6899
TG		 378static void link_enter_unmanaged(Link *link) {
379 assert(link);
380
6a7a4e4d 381 log_link_debug(link, "Unmanaged");
57bd6899 382
e331e246 383 link_set_state(link, LINK_STATE_UNMANAGED);
57bd6899
TG		 384
385 link_save(link);
386}
387
111bb8f9
TG		 388static int link_stop_clients(Link *link) {
389 int r = 0, k;
390
391 assert(link);
392 assert(link->manager);
393 assert(link->manager->event);
394
395 if (!link->network)
396 return 0;
397
ba179154 398 if (link->dhcp_client) {
111bb8f9 399 k = sd_dhcp_client_stop(link->dhcp_client);
6a7a4e4d
LP		 400 if (k < 0)
401 r = log_link_warning_errno(link, r, "Could not stop DHCPv4 client: %m");
111bb8f9
TG		 402 }
403
ba179154 404 if (link->ipv4ll) {
111bb8f9 405 k = sd_ipv4ll_stop(link->ipv4ll);
6a7a4e4d
LP		 406 if (k < 0)
407 r = log_link_warning_errno(link, r, "Could not stop IPv4 link-local: %m");
dd43110f
TG		 408 }
409
ba179154 410 if(link->icmp6_router_discovery) {
1873a3d3
PF		 411 if (link->dhcp6_client) {
412 k = sd_dhcp6_client_stop(link->dhcp6_client);
6a7a4e4d
LP		 413 if (k < 0)
414 r = log_link_warning_errno(link, r, "Could not stop DHCPv6 client: %m");
1873a3d3 415 }
4138fb2c 416
1873a3d3 417 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
6a7a4e4d
LP		 418 if (k < 0)
419 r = log_link_warning_errno(link, r, "Could not stop ICMPv6 router discovery: %m");
4138fb2c
PF		 420 }
421
ce43e484 422 if (link->lldp) {
ce43e484 423 k = sd_lldp_stop(link->lldp);
6a7a4e4d
LP		 424 if (k < 0)
425 r = log_link_warning_errno(link, r, "Could not stop LLDP: %m");
ce43e484
SS		 426 }
427
111bb8f9
TG		 428 return r;
429}
430
b22d8a00 431void link_enter_failed(Link *link) {
ef1ba606 432 assert(link);
f882c247 433
370e9930 434 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
2139694e
TG		 435 return;
436
6a7a4e4d 437 log_link_warning(link, "Failed");
449f7554 438
e331e246 439 link_set_state(link, LINK_STATE_FAILED);
fe8db0c5 440
111bb8f9
TG		 441 link_stop_clients(link);
442
fe8db0c5 443 link_save(link);
f882c247
TG		 444}
445
4f434938
LP		 446static Address* link_find_dhcp_server_address(Link *link) {
447 Address *address;
448
449 assert(link);
450 assert(link->network);
451
d4cdbea5 452 /* The first statically configured address if there is any */
4f434938
LP		 453 LIST_FOREACH(addresses, address, link->network->static_addresses) {
454
455 if (address->family != AF_INET)
456 continue;
457
af93291c 458 if (in_addr_is_null(address->family, &address->in_addr))
4f434938
LP		 459 continue;
460
461 return address;
462 }
463
464 /* If that didn't work, find a suitable address we got from the pool */
465 LIST_FOREACH(addresses, address, link->pool_addresses) {
466 if (address->family != AF_INET)
467 continue;
468
469 return address;
470 }
471
472 return NULL;
473}
474
dd43110f 475static int link_enter_configured(Link *link) {
dd43110f
TG		 476 assert(link);
477 assert(link->network);
478 assert(link->state == LINK_STATE_SETTING_ROUTES);
479
6a7a4e4d 480 log_link_info(link, "Configured");
dd43110f 481
e331e246 482 link_set_state(link, LINK_STATE_CONFIGURED);
dd43110f
TG		 483
484 link_save(link);
485
486 return 0;
487}
488
3c9b8860
TG		 489void link_client_handler(Link *link) {
490 assert(link);
491 assert(link->network);
492
493 if (!link->static_configured)
494 return;
495
78c958f8 496 if (link_ipv4ll_enabled(link))
3c9b8860
TG		 497 if (!link->ipv4ll_address ||
498 !link->ipv4ll_route)
499 return;
500
78c958f8 501 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
3c9b8860
TG		 502 return;
503
9fdaa992
TG		 504 if (link->state != LINK_STATE_CONFIGURED)
505 link_enter_configured(link);
3c9b8860
TG		 506
507 return;
508}
509
1c4baffc 510static int route_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
5da8149f 511 _cleanup_link_unref_ Link *link = userdata;
f882c247
TG		 512 int r;
513
3c9b8860 514 assert(link->link_messages > 0);
370e9930
TG		 515 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
516 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
517 LINK_STATE_LINGER));
f882c247 518
3c9b8860 519 link->link_messages --;
f882c247 520
77a008c0 521 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
f882c247
TG		 522 return 1;
523
1c4baffc 524 r = sd_netlink_message_get_errno(m);
c166a070 525 if (r < 0 && r != -EEXIST)
6a7a4e4d 526 log_link_warning_errno(link, r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
f882c247 527
3c9b8860 528 if (link->link_messages == 0) {
6a7a4e4d 529 log_link_debug(link, "Routes set");
3c9b8860
TG		 530 link->static_configured = true;
531 link_client_handler(link);
dd3efc09 532 }
f882c247
TG		 533
534 return 1;
535}
536
537static int link_enter_set_routes(Link *link) {
a6cc569e 538 Route *rt;
f882c247
TG		 539 int r;
540
541 assert(link);
542 assert(link->network);
ef1ba606 543 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
f882c247 544
e331e246 545 link_set_state(link, LINK_STATE_SETTING_ROUTES);
f882c247 546
3d3d4255 547 LIST_FOREACH(routes, rt, link->network->static_routes) {
a6cc569e 548 r = route_configure(rt, link, &route_handler);
dd3efc09 549 if (r < 0) {
6a7a4e4d 550 log_link_warning_errno(link, r, "Could not set routes: %m");
3c9b8860 551 link_enter_failed(link);
a6cc569e
TG		 552 return r;
553 }
554
3c9b8860 555 link->link_messages ++;
8ddbeaa2 556 }
f5be5601 557
3c9b8860
TG		 558 if (link->link_messages == 0) {
559 link->static_configured = true;
560 link_client_handler(link);
431ca2ce 561 } else
6a7a4e4d 562 log_link_debug(link, "Setting routes");
f882c247
TG		 563
564 return 0;
565}
566
1c4baffc 567int link_route_drop_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
5da8149f 568 _cleanup_link_unref_ Link *link = userdata;
5c1d3fc9
UTL		 569 int r;
570
571 assert(m);
572 assert(link);
573 assert(link->ifname);
574
5da8149f 575 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
5c1d3fc9
UTL		 576 return 1;
577
1c4baffc 578 r = sd_netlink_message_get_errno(m);
b90b025a 579 if (r < 0 && r != -ESRCH)
6a7a4e4d 580 log_link_warning_errno(link, r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
5c1d3fc9 581
5bdd314c 582 return 1;
5c1d3fc9
UTL		 583}
584
1c4baffc 585static int address_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
5da8149f 586 _cleanup_link_unref_ Link *link = userdata;
f882c247
TG		 587 int r;
588
4958aee4 589 assert(rtnl);
f5be5601
TG		 590 assert(m);
591 assert(link);
592 assert(link->ifname);
3c9b8860 593 assert(link->link_messages > 0);
370e9930
TG		 594 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
595 LINK_STATE_FAILED, LINK_STATE_LINGER));
f882c247 596
3c9b8860 597 link->link_messages --;
f882c247 598
5da8149f 599 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
f882c247
TG		 600 return 1;
601
1c4baffc 602 r = sd_netlink_message_get_errno(m);
c166a070 603 if (r < 0 && r != -EEXIST)
6a7a4e4d 604 log_link_warning_errno(link, r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
45af44d4
TG		 605 else if (r >= 0)
606 link_rtnl_process_address(rtnl, m, link->manager);
f882c247 607
3c9b8860 608 if (link->link_messages == 0) {
6a7a4e4d 609 log_link_debug(link, "Addresses set");
ef1ba606 610 link_enter_set_routes(link);
dd3efc09 611 }
f882c247
TG		 612
613 return 1;
614}
615
616static int link_enter_set_addresses(Link *link) {
a6cc569e 617 Address *ad;
f882c247
TG		 618 int r;
619
620 assert(link);
621 assert(link->network);
f5be5601 622 assert(link->state != _LINK_STATE_INVALID);
f882c247 623
e331e246 624 link_set_state(link, LINK_STATE_SETTING_ADDRESSES);
f882c247 625
3d3d4255 626 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
a6cc569e 627 r = address_configure(ad, link, &address_handler);
dd3efc09 628 if (r < 0) {
5a8bcb67 629 log_link_warning_errno(link, r, "Could not set addresses: %m");
f5be5601
TG		 630 link_enter_failed(link);
631 return r;
632 }
633
3c9b8860 634 link->link_messages ++;
f882c247
TG		 635 }
636
d4cdbea5
TG		 637 /* now that we can figure out a default address for the dhcp server,
638 start it */
639 if (link_dhcp4_server_enabled(link)) {
640 struct in_addr pool_start;
641 Address *address;
642
643 address = link_find_dhcp_server_address(link);
644 if (!address) {
6a7a4e4d 645 log_link_warning(link, "Failed to find suitable address for DHCPv4 server instance.");
d4cdbea5
TG		 646 link_enter_failed(link);
647 return 0;
648 }
649
650 r = sd_dhcp_server_set_address(link->dhcp_server,
651 &address->in_addr.in,
652 address->prefixlen);
653 if (r < 0)
654 return r;
655
656 /* offer 32 addresses starting from the address following the server address */
657 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
658 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
659 &pool_start, 32);
660 if (r < 0)
661 return r;
662
663 /* TODO:
664 r = sd_dhcp_server_set_router(link->dhcp_server,
665 &main_address->in_addr.in);
666 if (r < 0)
667 return r;
668
669 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
670 main_address->prefixlen);
671 if (r < 0)
672 return r;
673 */
674
675 r = sd_dhcp_server_start(link->dhcp_server);
676 if (r < 0) {
6a7a4e4d 677 log_link_warning_errno(link, r, "Could not start DHCPv4 server instance: %m");
d4cdbea5
TG		 678
679 link_enter_failed(link);
680
681 return 0;
682 }
683
6a7a4e4d 684 log_link_debug(link, "Offering DHCPv4 leases");
d4cdbea5
TG		 685 }
686
6a7a4e4d 687 if (link->link_messages == 0)
431ca2ce 688 link_enter_set_routes(link);
6a7a4e4d
LP		 689 else
690 log_link_debug(link, "Setting addresses");
431ca2ce 691
f882c247
TG		 692 return 0;
693}
694
1c4baffc 695int link_address_drop_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
5da8149f 696 _cleanup_link_unref_ Link *link = userdata;
ff254138
TG		 697 int r;
698
699 assert(m);
700 assert(link);
701 assert(link->ifname);
702
5da8149f 703 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
ff254138
TG		 704 return 1;
705
1c4baffc 706 r = sd_netlink_message_get_errno(m);
b90b025a 707 if (r < 0 && r != -EADDRNOTAVAIL)
6a7a4e4d 708 log_link_warning_errno(link, r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
ff254138 709
5bdd314c 710 return 1;
ff254138
TG		 711}
712
a245ced0 713static int link_set_bridge_fdb(Link *const link) {
b98b483b
AR		 714 FdbEntry *fdb_entry;
715 int r = 0;
716
717 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
ea6ec096 718 r = fdb_entry_configure(link, fdb_entry);
b98b483b 719 if(r < 0) {
6a7a4e4d 720 log_link_error_errno(link, r, "Failed to add MAC entry to static MAC table: %m");
b98b483b
AR		 721 break;
722 }
723 }
724
725 return r;
726}
727
1c4baffc 728static int link_set_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
e1853b00
SS		 729 _cleanup_link_unref_ Link *link = userdata;
730 int r;
731
6a7a4e4d 732 log_link_debug(link, "Set link");
e1853b00 733
1c4baffc 734 r = sd_netlink_message_get_errno(m);
e1853b00 735 if (r < 0 && r != -EEXIST) {
f2341e0a 736 log_link_error_errno(link, r, "Could not join netdev: %m");
e1853b00
SS		 737 link_enter_failed(link);
738 return 1;
739 }
740
741 return 0;
742}
743
19070062 744static int set_hostname_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
5da8149f 745 _cleanup_link_unref_ Link *link = userdata;
1346b1f0
TG		 746 int r;
747
19070062 748 assert(m);
b226d99b
TG		 749 assert(link);
750
5da8149f 751 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
370e9930 752 return 1;
370e9930 753
1346b1f0 754 r = sd_bus_message_get_errno(m);
70b34f5d 755 if (r > 0)
6a7a4e4d 756 log_link_warning_errno(link, r, "Could not set hostname: %m");
1346b1f0
TG		 757
758 return 1;
759}
760
3c9b8860 761int link_set_hostname(Link *link, const char *hostname) {
1346b1f0
TG		 762 int r = 0;
763
b226d99b
TG		 764 assert(link);
765 assert(link->manager);
1346b1f0
TG		 766 assert(hostname);
767
79008bdd 768 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
1346b1f0 769
3c9b8860
TG		 770 if (!link->manager->bus) {
771 /* TODO: replace by assert when we can rely on kdbus */
6a7a4e4d 772 log_link_info(link, "Not connected to system bus, ignoring transient hostname.");
bcbca829
TG		 773 return 0;
774 }
775
9c34154a 776 r = sd_bus_call_method_async(
b226d99b 777 link->manager->bus,
9c34154a 778 NULL,
1346b1f0
TG		 779 "org.freedesktop.hostname1",
780 "/org/freedesktop/hostname1",
781 "org.freedesktop.hostname1",
9c34154a
UTL		 782 "SetHostname",
783 set_hostname_handler,
784 link,
785 "sb",
786 hostname,
787 false);
1346b1f0 788
6a7a4e4d
LP		 789 if (r < 0)
790 return log_link_error_errno(link, r, "Could not set transient hostname: %m");
b226d99b
TG		 791
792 link_ref(link);
1346b1f0 793
5da8149f 794 return 0;
1346b1f0
TG		 795}
796
1c4baffc 797static int set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
5da8149f 798 _cleanup_link_unref_ Link *link = userdata;
4f882b2a
TG		 799 int r;
800
801 assert(m);
802 assert(link);
803 assert(link->ifname);
804
5da8149f 805 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
4f882b2a
TG		 806 return 1;
807
1c4baffc 808 r = sd_netlink_message_get_errno(m);
c9ccc19f 809 if (r < 0)
6a7a4e4d 810 log_link_warning_errno(link, r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
4f882b2a
TG		 811
812 return 1;
813}
814
3c9b8860 815int link_set_mtu(Link *link, uint32_t mtu) {
1c4baffc 816 _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
4f882b2a
TG		 817 int r;
818
819 assert(link);
820 assert(link->manager);
821 assert(link->manager->rtnl);
822
6a7a4e4d 823 log_link_debug(link, "Setting MTU: %" PRIu32, mtu);
4f882b2a 824
6a7a4e4d
LP		 825 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
826 if (r < 0)
827 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
4f882b2a 828
1c4baffc 829 r = sd_netlink_message_append_u32(req, IFLA_MTU, mtu);
6a7a4e4d
LP		 830 if (r < 0)
831 return log_link_error_errno(link, r, "Could not append MTU: %m");
4f882b2a 832
1c4baffc 833 r = sd_netlink_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
6a7a4e4d
LP		 834 if (r < 0)
835 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
4f882b2a 836
ae941762 837 link_ref(link);
b226d99b 838
4f882b2a
TG		 839 return 0;
840}
841
e1853b00 842static int link_set_bridge(Link *link) {
1c4baffc 843 _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
e1853b00
SS		 844 int r;
845
846 assert(link);
847 assert(link->network);
848
849 if(link->network->cost == 0)
850 return 0;
851
6a7a4e4d
LP		 852 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
853 if (r < 0)
854 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
e1853b00
SS		 855
856 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
6a7a4e4d
LP		 857 if (r < 0)
858 return log_link_error_errno(link, r, "Could not set message family: %m");
e1853b00 859
1c4baffc 860 r = sd_netlink_message_open_container(req, IFLA_PROTINFO);
6a7a4e4d
LP		 861 if (r < 0)
862 return log_link_error_errno(link, r, "Could not append IFLA_PROTINFO attribute: %m");
e1853b00
SS		 863
864 if(link->network->cost != 0) {
1c4baffc 865 r = sd_netlink_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
6a7a4e4d
LP		 866 if (r < 0)
867 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_COST attribute: %m");
e1853b00
SS		 868 }
869
1c4baffc 870 r = sd_netlink_message_close_container(req);
6a7a4e4d
LP		 871 if (r < 0)
872 return log_link_error_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m");
e1853b00 873
1c4baffc 874 r = sd_netlink_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
6a7a4e4d
LP		 875 if (r < 0)
876 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
e1853b00
SS		 877
878 link_ref(link);
879
880 return r;
881}
882
49699bac
SS		 883static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
884 Link *link = userdata;
885 int r;
886
887 assert(link);
888 assert(link->network);
889 assert(link->manager);
890
891 if (event != UPDATE_INFO)
892 return;
893
894 r = sd_lldp_save(link->lldp, link->lldp_file);
895 if (r < 0)
6a7a4e4d 896 log_link_warning_errno(link, r, "Could not save LLDP: %m");
49699bac
SS		 897
898}
899
ff254138
TG		 900static int link_acquire_conf(Link *link) {
901 int r;
902
903 assert(link);
904 assert(link->network);
ff254138
TG		 905 assert(link->manager);
906 assert(link->manager->event);
907
78c958f8 908 if (link_ipv4ll_enabled(link)) {
eb34d4af 909 assert(link->ipv4ll);
ff254138 910
6a7a4e4d 911 log_link_debug(link, "Acquiring IPv4 link-local address");
5c1d3fc9
UTL		 912
913 r = sd_ipv4ll_start(link->ipv4ll);
6a7a4e4d
LP		 914 if (r < 0)
915 return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
5c1d3fc9
UTL		 916 }
917
78c958f8 918 if (link_dhcp4_enabled(link)) {
eb34d4af 919 assert(link->dhcp_client);
ff254138 920
6a7a4e4d 921 log_link_debug(link, "Acquiring DHCPv4 lease");
ab47d620 922
5c1d3fc9 923 r = sd_dhcp_client_start(link->dhcp_client);
6a7a4e4d
LP		 924 if (r < 0)
925 return log_link_warning_errno(link, r, "Could not acquire DHCPv4 lease: %m");
5c1d3fc9 926 }
ff254138 927
78c958f8 928 if (link_dhcp6_enabled(link)) {
4138fb2c
PF		 929 assert(link->icmp6_router_discovery);
930
6a7a4e4d 931 log_link_debug(link, "Discovering IPv6 routers");
4138fb2c
PF		 932
933 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
6a7a4e4d
LP		 934 if (r < 0)
935 return log_link_warning_errno(link, r, "Could not start IPv6 router discovery: %m");
4138fb2c
PF		 936 }
937
ce43e484
SS		 938 if (link_lldp_enabled(link)) {
939 assert(link->lldp);
940
941 log_link_debug(link, "Starting LLDP");
942
943 r = sd_lldp_start(link->lldp);
6a7a4e4d
LP		 944 if (r < 0)
945 return log_link_warning_errno(link, r, "Could not start LLDP: %m");
ce43e484
SS		 946 }
947
ff254138
TG		 948 return 0;
949}
950
a61bb41c 951bool link_has_carrier(Link *link) {
deb2e523
TG		 952 /* see Documentation/networking/operstates.txt in the kernel sources */
953
a61bb41c 954 if (link->kernel_operstate == IF_OPER_UP)
deb2e523
TG		 955 return true;
956
a61bb41c 957 if (link->kernel_operstate == IF_OPER_UNKNOWN)
deb2e523 958 /* operstate may not be implemented, so fall back to flags */
a61bb41c 959 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
deb2e523
TG		 960 return true;
961
962 return false;
963}
964
1c4baffc 965static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
5da8149f 966 _cleanup_link_unref_ Link *link = userdata;
dd3efc09
TG		 967 int r;
968
1746cf2a
TG		 969 assert(link);
970
5da8149f 971 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1746cf2a
TG		 972 return 1;
973
1c4baffc 974 r = sd_netlink_message_get_errno(m);
6a7a4e4d
LP		 975 if (r < 0)
976 /* we warn but don't fail the link, as it may be
977 brought up later */
978 log_link_warning_errno(link, r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
45ad2c13 979
f882c247
TG		 980 return 1;
981}
982
983static int link_up(Link *link) {
1c4baffc 984 _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
5c3072ea 985 uint8_t ipv6ll_mode;
f579559b
TG		 986 int r;
987
f882c247 988 assert(link);
c106cc36 989 assert(link->network);
f882c247
TG		 990 assert(link->manager);
991 assert(link->manager->rtnl);
992
6a7a4e4d 993 log_link_debug(link, "Bringing link up");
449f7554 994
6a7a4e4d
LP		 995 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
996 if (r < 0)
997 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
f579559b 998
5d4795f3 999 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
6a7a4e4d
LP		 1000 if (r < 0)
1001 return log_link_error_errno(link, r, "Could not set link flags: %m");
fc25d7f8 1002
c106cc36 1003 if (link->network->mac) {
1c4baffc 1004 r = sd_netlink_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
6a7a4e4d
LP		 1005 if (r < 0)
1006 return log_link_error_errno(link, r, "Could not set MAC address: %m");
c106cc36
TG		 1007 }
1008
1009 if (link->network->mtu) {
1c4baffc 1010 r = sd_netlink_message_append_u32(req, IFLA_MTU, link->network->mtu);
6a7a4e4d
LP		 1011 if (r < 0)
1012 return log_link_error_errno(link, r, "Could not set MTU: %m");
c106cc36
TG		 1013 }
1014
1c4baffc 1015 r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
6a7a4e4d
LP		 1016 if (r < 0)
1017 return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
d0d6a4cd 1018
01d28f81
TG		 1019 if (socket_ipv6_is_supported()) {
1020 /* if the kernel lacks ipv6 support setting IFF_UP fails if any ipv6 options are passed */
1c4baffc 1021 r = sd_netlink_message_open_container(req, AF_INET6);
01d28f81
TG		 1022 if (r < 0)
1023 return log_link_error_errno(link, r, "Could not open AF_INET6 container: %m");
d0d6a4cd 1024
01d28f81 1025 ipv6ll_mode = link_ipv6ll_enabled(link) ? IN6_ADDR_GEN_MODE_EUI64 : IN6_ADDR_GEN_MODE_NONE;
1c4baffc 1026 r = sd_netlink_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
01d28f81
TG		 1027 if (r < 0)
1028 return log_link_error_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
d0d6a4cd 1029
01d28f81 1030 if (!in_addr_is_null(AF_INET6, &link->network->ipv6_token)) {
1c4baffc 1031 r = sd_netlink_message_append_in6_addr(req, IFLA_INET6_TOKEN, &link->network->ipv6_token.in6);
01d28f81
TG		 1032 if (r < 0)
1033 return log_link_error_errno(link, r, "Could not append IFLA_INET6_TOKEN: %m");
1034 }
1035
1c4baffc 1036 r = sd_netlink_message_close_container(req);
6a7a4e4d 1037 if (r < 0)
01d28f81 1038 return log_link_error_errno(link, r, "Could not close AF_INET6 container: %m");
7f77697a 1039 }
d0d6a4cd 1040
1c4baffc 1041 r = sd_netlink_message_close_container(req);
6a7a4e4d
LP		 1042 if (r < 0)
1043 return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
d0d6a4cd 1044
1c4baffc 1045 r = sd_netlink_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
6a7a4e4d
LP		 1046 if (r < 0)
1047 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
f579559b 1048
b226d99b
TG		 1049 link_ref(link);
1050
f882c247
TG		 1051 return 0;
1052}
1053
1c4baffc 1054static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
0d4ad91d
AR		 1055 _cleanup_link_unref_ Link *link = userdata;
1056 int r;
1057
1058 assert(link);
1059
1060 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1061 return 1;
1062
1c4baffc 1063 r = sd_netlink_message_get_errno(m);
0d4ad91d 1064 if (r < 0)
6a7a4e4d 1065 log_link_warning_errno(link, r, "%-*s: could not bring down interface: %m", IFNAMSIZ, link->ifname);
0d4ad91d
AR		 1066
1067 return 1;
1068}
1069
1070static int link_down(Link *link) {
1c4baffc 1071 _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
0d4ad91d
AR		 1072 int r;
1073
1074 assert(link);
1075 assert(link->manager);
1076 assert(link->manager->rtnl);
1077
6a7a4e4d 1078 log_link_debug(link, "Bringing link down");
0d4ad91d
AR		 1079
1080 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1081 RTM_SETLINK, link->ifindex);
6a7a4e4d
LP		 1082 if (r < 0)
1083 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
0d4ad91d
AR		 1084
1085 r = sd_rtnl_message_link_set_flags(req, 0, IFF_UP);
6a7a4e4d
LP		 1086 if (r < 0)
1087 return log_link_error_errno(link, r, "Could not set link flags: %m");
0d4ad91d 1088
1c4baffc 1089 r = sd_netlink_call_async(link->manager->rtnl, req, link_down_handler, link, 0, NULL);
6a7a4e4d
LP		 1090 if (r < 0)
1091 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
0d4ad91d
AR		 1092
1093 link_ref(link);
1094
1095 return 0;
1096}
1097
1098static int link_handle_bound_to_list(Link *link) {
1099 Link *l;
1100 Iterator i;
1101 int r;
1102 bool required_up = false;
1103 bool link_is_up = false;
1104
1105 assert(link);
1106
1107 if (hashmap_isempty(link->bound_to_links))
1108 return 0;
1109
1110 if (link->flags & IFF_UP)
1111 link_is_up = true;
1112
1113 HASHMAP_FOREACH (l, link->bound_to_links, i)
1114 if (link_has_carrier(l)) {
1115 required_up = true;
1116 break;
1117 }
1118
1119 if (!required_up && link_is_up) {
1120 r = link_down(link);
1121 if (r < 0)
1122 return r;
1123 } else if (required_up && !link_is_up) {
1124 r = link_up(link);
1125 if (r < 0)
1126 return r;
1127 }
1128
1129 return 0;
1130}
1131
1132static int link_handle_bound_by_list(Link *link) {
1133 Iterator i;
1134 Link *l;
1135 int r;
1136
1137 assert(link);
1138
1139 if (hashmap_isempty(link->bound_by_links))
1140 return 0;
1141
1142 HASHMAP_FOREACH (l, link->bound_by_links, i) {
1143 r = link_handle_bound_to_list(l);
1144 if (r < 0)
1145 return r;
1146 }
1147
1148 return 0;
1149}
1150
1151static int link_put_carrier(Link *link, Link *carrier, Hashmap **h) {
1152 int r;
1153
1154 assert(link);
1155 assert(carrier);
1156
1157 if (link == carrier)
1158 return 0;
1159
1160 if (hashmap_get(*h, INT_TO_PTR(carrier->ifindex)))
1161 return 0;
1162
1163 r = hashmap_ensure_allocated(h, NULL);
1164 if (r < 0)
1165 return r;
1166
1167 r = hashmap_put(*h, INT_TO_PTR(carrier->ifindex), carrier);
1168 if (r < 0)
1169 return r;
1170
1171 return 0;
1172}
1173
1174static int link_new_bound_by_list(Link *link) {
1175 Manager *m;
1176 Link *carrier;
1177 Iterator i;
1178 int r;
1179 bool list_updated = false;
1180
1181 assert(link);
1182 assert(link->manager);
1183
1184 m = link->manager;
1185
1186 HASHMAP_FOREACH (carrier, m->links, i) {
1187 if (!carrier->network)
1188 continue;
1189
1190 if (strv_isempty(carrier->network->bind_carrier))
1191 continue;
1192
1193 if (strv_fnmatch(carrier->network->bind_carrier, link->ifname, 0)) {
1194 r = link_put_carrier(link, carrier, &link->bound_by_links);
1195 if (r < 0)
1196 return r;
1197
1198 list_updated = true;
1199 }
1200 }
1201
1202 if (list_updated)
1203 link_save(link);
1204
1205 HASHMAP_FOREACH (carrier, link->bound_by_links, i) {
1206 r = link_put_carrier(carrier, link, &carrier->bound_to_links);
1207 if (r < 0)
1208 return r;
1209
1210 link_save(carrier);
1211 }
1212
1213 return 0;
1214}
1215
1216static int link_new_bound_to_list(Link *link) {
1217 Manager *m;
1218 Link *carrier;
1219 Iterator i;
1220 int r;
1221 bool list_updated = false;
1222
1223 assert(link);
1224 assert(link->manager);
1225
1226 if (!link->network)
1227 return 0;
1228
1229 if (strv_isempty(link->network->bind_carrier))
1230 return 0;
1231
1232 m = link->manager;
1233
1234 HASHMAP_FOREACH (carrier, m->links, i) {
1235 if (strv_fnmatch(link->network->bind_carrier, carrier->ifname, 0)) {
1236 r = link_put_carrier(link, carrier, &link->bound_to_links);
1237 if (r < 0)
1238 return r;
1239
1240 list_updated = true;
1241 }
1242 }
1243
1244 if (list_updated)
1245 link_save(link);
1246
1247 HASHMAP_FOREACH (carrier, link->bound_to_links, i) {
1248 r = link_put_carrier(carrier, link, &carrier->bound_by_links);
1249 if (r < 0)
1250 return r;
1251
1252 link_save(carrier);
1253 }
1254
1255 return 0;
1256}
1257
1258static int link_new_carrier_maps(Link *link) {
1259 int r;
1260
1261 r = link_new_bound_by_list(link);
1262 if (r < 0)
1263 return r;
1264
1265 r = link_handle_bound_by_list(link);
1266 if (r < 0)
1267 return r;
1268
1269 r = link_new_bound_to_list(link);
1270 if (r < 0)
1271 return r;
1272
1273 r = link_handle_bound_to_list(link);
1274 if (r < 0)
1275 return r;
1276
1277 return 0;
1278}
1279
1280static void link_free_bound_to_list(Link *link) {
1281 Link *bound_to;
1282 Iterator i;
1283
1284 HASHMAP_FOREACH (bound_to, link->bound_to_links, i) {
1285 hashmap_remove(link->bound_to_links, INT_TO_PTR(bound_to->ifindex));
1286
1287 if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
1288 link_save(bound_to);
1289 }
1290
1291 return;
1292}
1293
1294static void link_free_bound_by_list(Link *link) {
1295 Link *bound_by;
1296 Iterator i;
1297
1298 HASHMAP_FOREACH (bound_by, link->bound_by_links, i) {
1299 hashmap_remove(link->bound_by_links, INT_TO_PTR(bound_by->ifindex));
1300
1301 if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
1302 link_save(bound_by);
1303 link_handle_bound_to_list(bound_by);
1304 }
1305 }
1306
1307 return;
1308}
1309
1310static void link_free_carrier_maps(Link *link) {
1311 bool list_updated = false;
1312
1313 assert(link);
1314
1315 if (!hashmap_isempty(link->bound_to_links)) {
1316 link_free_bound_to_list(link);
1317 list_updated = true;
1318 }
1319
1320 if (!hashmap_isempty(link->bound_by_links)) {
1321 link_free_bound_by_list(link);
1322 list_updated = true;
1323 }
1324
1325 if (list_updated)
1326 link_save(link);
1327
1328 return;
1329}
1330
1331void link_drop(Link *link) {
1332 if (!link || link->state == LINK_STATE_LINGER)
1333 return;
1334
1335 link_set_state(link, LINK_STATE_LINGER);
1336
1337 link_free_carrier_maps(link);
1338
6a7a4e4d 1339 log_link_debug(link, "Link removed");
0d4ad91d
AR		 1340
1341 link_unref(link);
1342
1343 return;
1344}
1345
3f265037 1346static int link_joined(Link *link) {
f882c247
TG		 1347 int r;
1348
ef1ba606 1349 assert(link);
f5be5601 1350 assert(link->network);
dd3efc09 1351
0d4ad91d
AR		 1352 if (!hashmap_isempty(link->bound_to_links)) {
1353 r = link_handle_bound_to_list(link);
1354 if (r < 0)
1355 return r;
1356 } else if (!(link->flags & IFF_UP)) {
505f8da7
TG		 1357 r = link_up(link);
1358 if (r < 0) {
1359 link_enter_failed(link);
1360 return r;
1361 }
ef1ba606 1362 }
f882c247 1363
e1853b00
SS		 1364 if(link->network->bridge) {
1365 r = link_set_bridge(link);
6a7a4e4d
LP		 1366 if (r < 0)
1367 log_link_error_errno(link, r, "Could not set bridge message: %m");
e1853b00
SS		 1368 }
1369
fb6730c4 1370 return link_enter_set_addresses(link);
02b59d57
TG		 1371}
1372
62e2d5bb 1373static int netdev_join_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
5da8149f 1374 _cleanup_link_unref_ Link *link = userdata;
02b59d57
TG		 1375 int r;
1376
1746cf2a 1377 assert(link);
ef1ba606 1378 assert(link->network);
02b59d57 1379
52433f6b
TG		 1380 link->enslaving --;
1381
5da8149f 1382 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
02b59d57
TG		 1383 return 1;
1384
1c4baffc 1385 r = sd_netlink_message_get_errno(m);
856f962c 1386 if (r < 0 && r != -EEXIST) {
6a7a4e4d 1387 log_link_error_errno(link, r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
ef1ba606
TG		 1388 link_enter_failed(link);
1389 return 1;
ba179154 1390 } else
6a7a4e4d 1391 log_link_debug(link, "Joined netdev");
02b59d57 1392
856f962c 1393 if (link->enslaving <= 0)
3f265037 1394 link_joined(link);
02b59d57
TG		 1395
1396 return 1;
1397}
1398
3f265037 1399static int link_enter_join_netdev(Link *link) {
6a0a2f86 1400 NetDev *netdev;
672682a6 1401 Iterator i;
02b59d57
TG		 1402 int r;
1403
1404 assert(link);
1405 assert(link->network);
8434fd5c 1406 assert(link->state == LINK_STATE_PENDING);
02b59d57 1407
e331e246 1408 link_set_state(link, LINK_STATE_ENSLAVING);
02b59d57 1409
fe8db0c5
TG		 1410 link_save(link);
1411
7951dea2
SS		 1412 if (!link->network->bridge &&
1413 !link->network->bond &&
6a0a2f86 1414 hashmap_isempty(link->network->stacked_netdevs))
3f265037 1415 return link_joined(link);
02b59d57 1416
d9c67ea1 1417 if (link->network->bond) {
f2341e0a
LP		 1418 log_struct(LOG_DEBUG,
1419 LOG_LINK_INTERFACE(link),
1420 LOG_NETDEV_INTERFACE(link->network->bond),
1421 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bond->ifname),
1422 NULL);
1423
1424 r = netdev_join(link->network->bond, link, netdev_join_handler);
52433f6b 1425 if (r < 0) {
f2341e0a
LP		 1426 log_struct_errno(LOG_WARNING, r,
1427 LOG_LINK_INTERFACE(link),
1428 LOG_NETDEV_INTERFACE(link->network->bond),
1429 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bond->ifname),
1430 NULL);
1431
52433f6b
TG		 1432 link_enter_failed(link);
1433 return r;
1434 }
1435
0ad6148e
MO		 1436 link->enslaving ++;
1437 }
1438
d9c67ea1 1439 if (link->network->bridge) {
f2341e0a
LP		 1440 log_struct(LOG_DEBUG,
1441 LOG_LINK_INTERFACE(link),
1442 LOG_NETDEV_INTERFACE(link->network->bridge),
1443 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bridge->ifname),
1444 NULL);
1445
1446 r = netdev_join(link->network->bridge, link, netdev_join_handler);
0ad6148e 1447 if (r < 0) {
f2341e0a
LP		 1448 log_struct_errno(LOG_WARNING, r,
1449 LOG_LINK_INTERFACE(link),
1450 LOG_NETDEV_INTERFACE(link->network->bridge),
1451 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bridge->ifname),
1452 NULL),
0ad6148e
MO		 1453 link_enter_failed(link);
1454 return r;
1455 }
1456
52433f6b
TG		 1457 link->enslaving ++;
1458 }
1459
6a0a2f86 1460 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
7951dea2 1461
f2341e0a
LP		 1462 log_struct(LOG_DEBUG,
1463 LOG_LINK_INTERFACE(link),
1464 LOG_NETDEV_INTERFACE(netdev),
1465 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname),
1466 NULL);
1467
1468 r = netdev_join(netdev, link, netdev_join_handler);
7951dea2 1469 if (r < 0) {
f2341e0a
LP		 1470 log_struct_errno(LOG_WARNING, r,
1471 LOG_LINK_INTERFACE(link),
1472 LOG_NETDEV_INTERFACE(netdev),
1473 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname),
1474 NULL);
326cb406
SS		 1475 link_enter_failed(link);
1476 return r;
1477 }
1478
326cb406
SS		 1479 link->enslaving ++;
1480 }
1481
ef1ba606
TG		 1482 return 0;
1483}
1484
769d324c 1485static int link_set_ipv4_forward(Link *link) {
15dee3f0 1486 const char *p = NULL, *v;
5a8bcb67
LP		 1487 int r;
1488
15dee3f0
LP		 1489 if (link->flags & IFF_LOOPBACK)
1490 return 0;
1491
8add5f79
NO		 1492 if (link->network->ip_forward == _ADDRESS_FAMILY_BOOLEAN_INVALID)
1493 return 0;
1494
63c372cb 1495 p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
15dee3f0
LP		 1496 v = one_zero(link_ipv4_forward_enabled(link));
1497
1498 r = write_string_file_no_create(p, v);
1499 if (r < 0) {
1500 /* If the right value is set anyway, don't complain */
1501 if (verify_one_line_file(p, v) > 0)
1502 return 0;
1503
43c6d5ab 1504 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
15dee3f0 1505 }
43c6d5ab 1506
769d324c
LP		 1507 return 0;
1508}
1509
1510static int link_set_ipv6_forward(Link *link) {
15dee3f0 1511 const char *p = NULL, *v = NULL;
769d324c
LP		 1512 int r;
1513
fe027299
LP		 1514 /* Make this a NOP if IPv6 is not available */
1515 if (!socket_ipv6_is_supported())
1516 return 0;
1517
15dee3f0
LP		 1518 if (link->flags & IFF_LOOPBACK)
1519 return 0;
1520
8add5f79
NO		 1521 if (link->network->ip_forward == _ADDRESS_FAMILY_BOOLEAN_INVALID)
1522 return 0;
1523
63c372cb 1524 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
15dee3f0
LP		 1525 v = one_zero(link_ipv6_forward_enabled(link));
1526
1527 r = write_string_file_no_create(p, v);
1528 if (r < 0) {
1529 /* If the right value is set anyway, don't complain */
1530 if (verify_one_line_file(p, v) > 0)
1531 return 0;
1532
769d324c 1533 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
15dee3f0 1534 }
5a8bcb67
LP		 1535
1536 return 0;
1537}
1538
49092e22 1539static int link_set_ipv6_privacy_extensions(Link *link) {
1f0d9695
LP		 1540 char buf[DECIMAL_STR_MAX(unsigned) + 1];
1541 IPv6PrivacyExtensions s;
49092e22
SS		 1542 const char *p = NULL;
1543 int r;
1544
1545 /* Make this a NOP if IPv6 is not available */
1546 if (!socket_ipv6_is_supported())
1547 return 0;
1548
1f0d9695
LP		 1549 s = link_ipv6_privacy_extensions(link);
1550 if (s == _IPV6_PRIVACY_EXTENSIONS_INVALID)
49092e22
SS		 1551 return 0;
1552
1553 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/use_tempaddr");
1554 xsprintf(buf, "%u", link->network->ipv6_privacy_extensions);
1555
1556 r = write_string_file_no_create(p, buf);
1f0d9695
LP		 1557 if (r < 0) {
1558 /* If the right value is set anyway, don't complain */
1559 if (verify_one_line_file(p, buf) > 0)
1560 return 0;
1561
49092e22 1562 log_link_warning_errno(link, r, "Cannot configure IPv6 privacy extension for interface: %m");
1f0d9695 1563 }
49092e22
SS		 1564
1565 return 0;
1566}
1567
a748b692 1568static int link_configure(Link *link) {
02b59d57
TG		 1569 int r;
1570
ef1ba606 1571 assert(link);
b22d8a00 1572 assert(link->network);
8434fd5c 1573 assert(link->state == LINK_STATE_PENDING);
a748b692 1574
b98b483b
AR		 1575 r = link_set_bridge_fdb(link);
1576 if (r < 0)
1577 return r;
1578
769d324c
LP		 1579 r = link_set_ipv4_forward(link);
1580 if (r < 0)
1581 return r;
1582
1583 r = link_set_ipv6_forward(link);
5a8bcb67
LP		 1584 if (r < 0)
1585 return r;
1586
49092e22
SS		 1587 r = link_set_ipv6_privacy_extensions(link);
1588 if (r < 0)
1589 return r;
1590
78c958f8 1591 if (link_ipv4ll_enabled(link)) {
b22d8a00 1592 r = ipv4ll_configure(link);
eb34d4af
TG		 1593 if (r < 0)
1594 return r;
1595 }
1596
78c958f8 1597 if (link_dhcp4_enabled(link)) {
3c9b8860 1598 r = dhcp4_configure(link);
eb34d4af
TG		 1599 if (r < 0)
1600 return r;
eb34d4af
TG		 1601 }
1602
78c958f8 1603 if (link_dhcp4_server_enabled(link)) {
dd43110f
TG		 1604 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1605 if (r < 0)
1606 return r;
1607
1608 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1609 if (r < 0)
1610 return r;
dd43110f
TG		 1611 }
1612
78c958f8 1613 if (link_dhcp6_enabled(link)) {
5c79bd79 1614 r = icmp6_configure(link);
4138fb2c
PF		 1615 if (r < 0)
1616 return r;
1617 }
1618
ce43e484
SS		 1619 if (link_lldp_enabled(link)) {
1620 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1621 if (r < 0)
1622 return r;
1623
1624 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1625 if (r < 0)
1626 return r;
49699bac
SS		 1627
1628 r = sd_lldp_set_callback(link->lldp,
1629 lldp_handler, link);
1630 if (r < 0)
1631 return r;
ce43e484
SS		 1632 }
1633
a61bb41c 1634 if (link_has_carrier(link)) {
1e9be60b
TG		 1635 r = link_acquire_conf(link);
1636 if (r < 0)
1637 return r;
cc544d5f 1638 }
1e9be60b 1639
3f265037 1640 return link_enter_join_netdev(link);
505f8da7
TG		 1641}
1642
1c4baffc 1643static int link_initialized_and_synced(sd_netlink *rtnl, sd_netlink_message *m,
3c9b8860 1644 void *userdata) {
5da8149f 1645 _cleanup_link_unref_ Link *link = userdata;
505f8da7 1646 Network *network;
505f8da7
TG		 1647 int r;
1648
1649 assert(link);
1650 assert(link->ifname);
1651 assert(link->manager);
1652
8434fd5c 1653 if (link->state != LINK_STATE_PENDING)
5da8149f 1654 return 1;
505f8da7 1655
6a7a4e4d 1656 log_link_debug(link, "Link state is up-to-date");
505f8da7 1657
0d4ad91d
AR		 1658 r = link_new_bound_by_list(link);
1659 if (r < 0)
1660 return r;
1661
1662 r = link_handle_bound_by_list(link);
1663 if (r < 0)
1664 return r;
1665
3c9b8860
TG		 1666 r = network_get(link->manager, link->udev_device, link->ifname,
1667 &link->mac, &network);
57bd6899
TG		 1668 if (r == -ENOENT) {
1669 link_enter_unmanaged(link);
5da8149f 1670 return 1;
57bd6899
TG		 1671 } else if (r < 0)
1672 return r;
505f8da7 1673
bd2efe92 1674 if (link->flags & IFF_LOOPBACK) {
d0d6a4cd 1675 if (network->link_local != ADDRESS_FAMILY_NO)
6a7a4e4d 1676 log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
78c958f8 1677
cb9fc36a 1678 if (network->dhcp != ADDRESS_FAMILY_NO)
6a7a4e4d 1679 log_link_debug(link, "Ignoring DHCP clients for loopback link");
78c958f8
TG		 1680
1681 if (network->dhcp_server)
6a7a4e4d 1682 log_link_debug(link, "Ignoring DHCP server for loopback link");
bd2efe92
TG		 1683 }
1684
505f8da7
TG		 1685 r = network_apply(link->manager, network, link);
1686 if (r < 0)
1687 return r;
1688
0d4ad91d
AR		 1689 r = link_new_bound_to_list(link);
1690 if (r < 0)
1691 return r;
1692
a748b692
TG		 1693 r = link_configure(link);
1694 if (r < 0)
1695 return r;
1696
5da8149f 1697 return 1;
505f8da7
TG		 1698}
1699
4f561e8e 1700int link_initialized(Link *link, struct udev_device *device) {
1c4baffc 1701 _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
4f561e8e
TG		 1702 int r;
1703
1704 assert(link);
1705 assert(link->manager);
1706 assert(link->manager->rtnl);
1707 assert(device);
1708
8434fd5c 1709 if (link->state != LINK_STATE_PENDING)
4f561e8e
TG		 1710 return 0;
1711
679b3605
TG		 1712 if (link->udev_device)
1713 return 0;
1714
79008bdd 1715 log_link_debug(link, "udev initialized link");
4f561e8e
TG		 1716
1717 link->udev_device = udev_device_ref(device);
1718
3c9b8860
TG		 1719 /* udev has initialized the link, but we don't know if we have yet
1720 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1721 * when it returns we know that the pending NEWLINKs have already been
1722 * processed and that we are up-to-date */
4f561e8e 1723
3c9b8860
TG		 1724 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1725 link->ifindex);
4f561e8e
TG		 1726 if (r < 0)
1727 return r;
1728
1c4baffc 1729 r = sd_netlink_call_async(link->manager->rtnl, req,
3c9b8860 1730 link_initialized_and_synced, link, 0, NULL);
4f561e8e
TG		 1731 if (r < 0)
1732 return r;
1733
5da8149f
TG		 1734 link_ref(link);
1735
4f561e8e
TG		 1736 return 0;
1737}
1738
5a8bcb67
LP		 1739static Address* link_get_equal_address(Link *link, Address *needle) {
1740 Address *i;
1741
1742 assert(link);
1743 assert(needle);
1744
1745 LIST_FOREACH(addresses, i, link->addresses)
1746 if (address_equal(i, needle))
1747 return i;
1748
1749 return NULL;
1750}
1751
1c4baffc 1752int link_rtnl_process_address(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
fbbeb65a
TG		 1753 Manager *m = userdata;
1754 Link *link = NULL;
1755 uint16_t type;
1756 _cleanup_address_free_ Address *address = NULL;
851c9f82 1757 unsigned char flags;
5a8bcb67
LP		 1758 Address *existing;
1759 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
c6d3b303 1760 const char *valid_str = NULL;
fbbeb65a
TG		 1761 int r, ifindex;
1762
1763 assert(rtnl);
1764 assert(message);
1765 assert(m);
1766
1c4baffc
TG		 1767 if (sd_netlink_message_is_error(message)) {
1768 r = sd_netlink_message_get_errno(message);
45af44d4
TG		 1769 if (r < 0)
1770 log_warning_errno(r, "rtnl: failed to receive address: %m");
1771
1772 return 0;
1773 }
1774
1c4baffc 1775 r = sd_netlink_message_get_type(message, &type);
fbbeb65a 1776 if (r < 0) {
6a7a4e4d 1777 log_warning_errno(r, "rtnl: could not get message type: %m");
fbbeb65a 1778 return 0;
cdfee943
TG		 1779 } else if (type != RTM_NEWADDR && type != RTM_DELADDR) {
1780 log_warning("rtnl: received unexpected message type when processing address");
1781 return 0;
fbbeb65a
TG		 1782 }
1783
1784 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
45af44d4 1785 if (r < 0) {
cdfee943 1786 log_warning_errno(r, "rtnl: could not get ifindex from address: %m");
45af44d4
TG		 1787 return 0;
1788 } else if (ifindex <= 0) {
1789 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
fbbeb65a
TG		 1790 return 0;
1791 } else {
1792 r = link_get(m, ifindex, &link);
1793 if (r < 0 || !link) {
6a24f148
TG		 1794 /* when enumerating we might be out of sync, but we will
1795 * get the address again, so just ignore it */
1796 if (!m->enumerating)
1797 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
fbbeb65a
TG		 1798 return 0;
1799 }
1800 }
1801
1802 r = address_new_dynamic(&address);
1803 if (r < 0)
393c0c5e 1804 return r;
fbbeb65a
TG		 1805
1806 r = sd_rtnl_message_addr_get_family(message, &address->family);
1807 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
6a7a4e4d 1808 log_link_warning(link, "rtnl: received address with invalid family, ignoring.");
fbbeb65a
TG		 1809 return 0;
1810 }
1811
1812 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1813 if (r < 0) {
6a7a4e4d 1814 log_link_warning_errno(link, r, "rtnl: received address with invalid prefixlen, ignoring: %m");
e375dcde
TG		 1815 return 0;
1816 }
1817
1818 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1819 if (r < 0) {
6a7a4e4d 1820 log_link_warning_errno(link, r, "rtnl: received address with invalid scope, ignoring: %m");
fbbeb65a
TG		 1821 return 0;
1822 }
1823
851c9f82 1824 r = sd_rtnl_message_addr_get_flags(message, &flags);
81163121 1825 if (r < 0) {
6a7a4e4d 1826 log_link_warning_errno(link, r, "rtnl: received address with invalid flags, ignoring: %m");
81163121
TG		 1827 return 0;
1828 }
851c9f82 1829 address->flags = flags;
81163121 1830
fbbeb65a
TG		 1831 switch (address->family) {
1832 case AF_INET:
1c4baffc 1833 r = sd_netlink_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
fbbeb65a 1834 if (r < 0) {
6a7a4e4d 1835 log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
fbbeb65a
TG		 1836 return 0;
1837 }
1838
1839 break;
1840
1841 case AF_INET6:
1c4baffc 1842 r = sd_netlink_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
fbbeb65a 1843 if (r < 0) {
6a7a4e4d 1844 log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
fbbeb65a
TG		 1845 return 0;
1846 }
1847
1848 break;
1849
1850 default:
1851 assert_not_reached("invalid address family");
1852 }
1853
5a8bcb67 1854 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
6a7a4e4d 1855 log_link_warning(link, "Could not print address");
fbbeb65a
TG		 1856 return 0;
1857 }
1858
1c4baffc 1859 r = sd_netlink_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
c6d3b303
TG		 1860 if (r >= 0) {
1861 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1862 valid_str = "ever";
1863 else
1864 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1865 address->cinfo.ifa_valid * USEC_PER_SEC,
1866 USEC_PER_SEC);
1867 }
1868
5a8bcb67
LP		 1869 existing = link_get_equal_address(link, address);
1870
1871 switch (type) {
1872 case RTM_NEWADDR:
1873 if (existing) {
1874 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
428fd0a7 1875
428fd0a7 1876
5a8bcb67
LP		 1877 existing->scope = address->scope;
1878 existing->flags = address->flags;
1879 existing->cinfo = address->cinfo;
428fd0a7 1880
5a8bcb67
LP		 1881 } else {
1882 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
428fd0a7 1883
5a8bcb67
LP		 1884 LIST_PREPEND(addresses, link->addresses, address);
1885 address_establish(address, link);
fbbeb65a 1886
5a8bcb67 1887 address = NULL;
428fd0a7 1888
5a8bcb67
LP		 1889 link_save(link);
1890 }
f5602be9 1891
428fd0a7 1892 break;
5a8bcb67 1893
fbbeb65a 1894 case RTM_DELADDR:
428fd0a7 1895
5a8bcb67
LP		 1896 if (existing) {
1897 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1898 address_release(existing, link);
1899 LIST_REMOVE(addresses, link->addresses, existing);
1900 address_free(existing);
393c0c5e 1901 } else
5a8bcb67 1902 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
f5602be9 1903
fbbeb65a
TG		 1904 break;
1905 default:
1906 assert_not_reached("Received invalid RTNL message type");
1907 }
1908
1909 return 1;
1910}
1911
1c4baffc 1912int link_add(Manager *m, sd_netlink_message *message, Link **ret) {
505f8da7
TG		 1913 Link *link;
1914 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1915 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1916 int r;
1917
1918 assert(m);
fbbeb65a 1919 assert(m->rtnl);
505f8da7
TG		 1920 assert(message);
1921 assert(ret);
1922
1923 r = link_new(m, message, ret);
1924 if (r < 0)
1925 return r;
1926
1927 link = *ret;
1928
6a7a4e4d 1929 log_link_debug(link, "Link %d added", link->ifindex);
505f8da7
TG		 1930
1931 if (detect_container(NULL) <= 0) {
1932 /* not in a container, udev will be around */
ae06ab10 1933 sprintf(ifindex_str, "n%d", link->ifindex);
505f8da7 1934 device = udev_device_new_from_device_id(m->udev, ifindex_str);
6a7a4e4d
LP		 1935 if (!device)
1936 return log_link_warning_errno(link, errno, "Could not find udev device: %m");
505f8da7 1937
3c4cb064 1938 if (udev_device_get_is_initialized(device) <= 0) {
505f8da7 1939 /* not yet ready */
79008bdd 1940 log_link_debug(link, "link pending udev initialization...");
505f8da7 1941 return 0;
3c4cb064 1942 }
505f8da7 1943
4f561e8e
TG		 1944 r = link_initialized(link, device);
1945 if (r < 0)
1946 return r;
1947 } else {
5da8149f
TG		 1948 /* we are calling a callback directly, so must take a ref */
1949 link_ref(link);
1950
4f561e8e
TG		 1951 r = link_initialized_and_synced(m->rtnl, NULL, link);
1952 if (r < 0)
1953 return r;
1954 }
505f8da7 1955
a748b692
TG		 1956 return 0;
1957}
1958
9c0a72f9
TG		 1959static int link_carrier_gained(Link *link) {
1960 int r;
1961
1962 assert(link);
1963
1964 if (link->network) {
1965 r = link_acquire_conf(link);
1966 if (r < 0) {
1967 link_enter_failed(link);
1968 return r;
1969 }
1970 }
1971
0d4ad91d
AR		 1972 r = link_handle_bound_by_list(link);
1973 if (r < 0)
1974 return r;
1975
9c0a72f9
TG		 1976 return 0;
1977}
1978
1979static int link_carrier_lost(Link *link) {
1980 int r;
1981
1982 assert(link);
1983
1984 r = link_stop_clients(link);
1985 if (r < 0) {
1986 link_enter_failed(link);
1987 return r;
1988 }
1989
0d4ad91d
AR		 1990 r = link_handle_bound_by_list(link);
1991 if (r < 0)
1992 return r;
1993
9c0a72f9
TG		 1994 return 0;
1995}
1996
1997int link_carrier_reset(Link *link) {
1998 int r;
1999
2000 assert(link);
2001
2002 if (link_has_carrier(link)) {
2003 r = link_carrier_lost(link);
2004 if (r < 0)
2005 return r;
2006
2007 r = link_carrier_gained(link);
2008 if (r < 0)
2009 return r;
2010
6a7a4e4d 2011 log_link_info(link, "Reset carrier");
9c0a72f9
TG		 2012 }
2013
2014 return 0;
2015}
2016
2017
1c4baffc 2018int link_update(Link *link, sd_netlink_message *m) {
c49b33ac 2019 struct ether_addr mac;
ca4e095a 2020 const char *ifname;
afe7fd56 2021 uint32_t mtu;
a61bb41c 2022 bool had_carrier, carrier_gained, carrier_lost;
22936833
TG		 2023 int r;
2024
dd3efc09 2025 assert(link);
b8941f74 2026 assert(link->ifname);
22936833
TG		 2027 assert(m);
2028
7619683b
TG		 2029 if (link->state == LINK_STATE_LINGER) {
2030 link_ref(link);
6a7a4e4d 2031 log_link_info(link, "Link readded");
e331e246 2032 link_set_state(link, LINK_STATE_ENSLAVING);
0d4ad91d
AR		 2033
2034 r = link_new_carrier_maps(link);
2035 if (r < 0)
2036 return r;
7619683b
TG		 2037 }
2038
1c4baffc 2039 r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
b8941f74 2040 if (r >= 0 && !streq(ifname, link->ifname)) {
6a7a4e4d 2041 log_link_info(link, "Renamed to %s", ifname);
b8941f74 2042
0d4ad91d
AR		 2043 link_free_carrier_maps(link);
2044
b8941f74
TG		 2045 free(link->ifname);
2046 link->ifname = strdup(ifname);
2047 if (!link->ifname)
2048 return -ENOMEM;
0d4ad91d
AR		 2049
2050 r = link_new_carrier_maps(link);
2051 if (r < 0)
2052 return r;
b8941f74
TG		 2053 }
2054
1c4baffc 2055 r = sd_netlink_message_read_u32(m, IFLA_MTU, &mtu);
afe7fd56
TG		 2056 if (r >= 0 && mtu > 0) {
2057 link->mtu = mtu;
2058 if (!link->original_mtu) {
2059 link->original_mtu = mtu;
6a7a4e4d 2060 log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
afe7fd56
TG		 2061 }
2062
2063 if (link->dhcp_client) {
3c9b8860
TG		 2064 r = sd_dhcp_client_set_mtu(link->dhcp_client,
2065 link->mtu);
afe7fd56 2066 if (r < 0) {
6a7a4e4d 2067 log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
afe7fd56
TG		 2068 return r;
2069 }
2070 }
9842de0d 2071 }
69629de9 2072
e9189a1f
TG		 2073 /* The kernel may broadcast NEWLINK messages without the MAC address
2074 set, simply ignore them. */
1c4baffc 2075 r = sd_netlink_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
e9189a1f 2076 if (r >= 0) {
3c9b8860
TG		 2077 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
2078 ETH_ALEN)) {
c49b33ac 2079
3c9b8860
TG		 2080 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
2081 ETH_ALEN);
c49b33ac 2082
79008bdd 2083 log_link_debug(link, "MAC address: "
20861203
TG		 2084 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2085 mac.ether_addr_octet[0],
2086 mac.ether_addr_octet[1],
2087 mac.ether_addr_octet[2],
2088 mac.ether_addr_octet[3],
2089 mac.ether_addr_octet[4],
2090 mac.ether_addr_octet[5]);
c49b33ac 2091
20861203
TG		 2092 if (link->ipv4ll) {
2093 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
6a7a4e4d
LP		 2094 if (r < 0)
2095 return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
c49b33ac 2096 }
c49b33ac 2097
20861203 2098 if (link->dhcp_client) {
3c9b8860 2099 r = sd_dhcp_client_set_mac(link->dhcp_client,
76253e73
DW		 2100 (const uint8_t *) &link->mac,
2101 sizeof (link->mac),
2102 ARPHRD_ETHER);
6a7a4e4d
LP		 2103 if (r < 0)
2104 return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
c49b33ac 2105 }
4138fb2c
PF		 2106
2107 if (link->dhcp6_client) {
2108 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
76253e73
DW		 2109 (const uint8_t *) &link->mac,
2110 sizeof (link->mac),
2111 ARPHRD_ETHER);
6a7a4e4d
LP		 2112 if (r < 0)
2113 return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
4138fb2c 2114 }
c49b33ac 2115 }
4f882b2a
TG		 2116 }
2117
a61bb41c
TG		 2118 had_carrier = link_has_carrier(link);
2119
2120 r = link_update_flags(link, m);
2121 if (r < 0)
2122 return r;
2123
2124 carrier_gained = !had_carrier && link_has_carrier(link);
2125 carrier_lost = had_carrier && !link_has_carrier(link);
2126
2127 if (carrier_gained) {
6a7a4e4d 2128 log_link_info(link, "Gained carrier");
a61bb41c 2129
9c0a72f9
TG		 2130 r = link_carrier_gained(link);
2131 if (r < 0)
2132 return r;
a61bb41c 2133 } else if (carrier_lost) {
6a7a4e4d 2134 log_link_info(link, "Lost carrier");
a61bb41c 2135
9c0a72f9
TG		 2136 r = link_carrier_lost(link);
2137 if (r < 0)
a61bb41c 2138 return r;
9c0a72f9 2139
a61bb41c
TG		 2140 }
2141
2142 return 0;
dd3efc09 2143}
fe8db0c5 2144
e375dcde 2145static void link_update_operstate(Link *link) {
e331e246 2146 LinkOperationalState operstate;
e375dcde
TG		 2147 assert(link);
2148
2149 if (link->kernel_operstate == IF_OPER_DORMANT)
e331e246 2150 operstate = LINK_OPERSTATE_DORMANT;
a61bb41c 2151 else if (link_has_carrier(link)) {
e375dcde
TG		 2152 Address *address;
2153 uint8_t scope = RT_SCOPE_NOWHERE;
2154
2155 /* if we have carrier, check what addresses we have */
2156 LIST_FOREACH(addresses, address, link->addresses) {
81163121
TG		 2157 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
2158 continue;
2159
e375dcde
TG		 2160 if (address->scope < scope)
2161 scope = address->scope;
2162 }
2163
2164 if (scope < RT_SCOPE_SITE)
2165 /* universally accessible addresses found */
e331e246 2166 operstate = LINK_OPERSTATE_ROUTABLE;
e375dcde
TG		 2167 else if (scope < RT_SCOPE_HOST)
2168 /* only link or site local addresses found */
e331e246 2169 operstate = LINK_OPERSTATE_DEGRADED;
e375dcde
TG		 2170 else
2171 /* no useful addresses found */
e331e246 2172 operstate = LINK_OPERSTATE_CARRIER;
54cba0b1 2173 } else if (link->flags & IFF_UP)
e331e246 2174 operstate = LINK_OPERSTATE_NO_CARRIER;
54cba0b1 2175 else
e331e246
TG		 2176 operstate = LINK_OPERSTATE_OFF;
2177
2178 if (link->operstate != operstate) {
2179 link->operstate = operstate;
2180 link_send_changed(link, "OperationalState", NULL);
2181 }
e375dcde
TG		 2182}
2183
fe8db0c5 2184int link_save(Link *link) {
68a8723c 2185 _cleanup_free_ char *temp_path = NULL;
fe8db0c5 2186 _cleanup_fclose_ FILE *f = NULL;
e375dcde 2187 const char *admin_state, *oper_state;
fe8db0c5
TG		 2188 int r;
2189
2190 assert(link);
2191 assert(link->state_file);
68a8723c 2192 assert(link->lease_file);
bbf7c048
TG		 2193 assert(link->manager);
2194
e375dcde
TG		 2195 link_update_operstate(link);
2196
bbf7c048
TG		 2197 r = manager_save(link->manager);
2198 if (r < 0)
2199 return r;
fe8db0c5 2200
370e9930
TG		 2201 if (link->state == LINK_STATE_LINGER) {
2202 unlink(link->state_file);
2203 return 0;
2204 }
2205
deb2e523
TG		 2206 admin_state = link_state_to_string(link->state);
2207 assert(admin_state);
2208
e375dcde
TG		 2209 oper_state = link_operstate_to_string(link->operstate);
2210 assert(oper_state);
deb2e523 2211
fe8db0c5
TG		 2212 r = fopen_temporary(link->state_file, &f, &temp_path);
2213 if (r < 0)
6a7a4e4d 2214 goto fail;
fe8db0c5
TG		 2215
2216 fchmod(fileno(f), 0644);
2217
2218 fprintf(f,
2219 "# This is private data. Do not parse.\n"
deb2e523 2220 "ADMIN_STATE=%s\n"
6dcaa6f5
TG		 2221 "OPER_STATE=%s\n",
2222 admin_state, oper_state);
fe8db0c5 2223
bcb7a07e 2224 if (link->network) {
ea352b40
LP		 2225 char **address, **domain;
2226 bool space;
b0e39c82 2227
adc5b2e2
TG		 2228 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
2229
b0e39c82 2230 fputs("DNS=", f);
ea352b40
LP		 2231 space = false;
2232 STRV_FOREACH(address, link->network->dns) {
2233 if (space)
2234 fputc(' ', f);
2235 fputs(*address, f);
2236 space = true;
2237 }
d5314fff 2238
b0e39c82
TG		 2239 if (link->network->dhcp_dns &&
2240 link->dhcp_lease) {
2241 const struct in_addr *addresses;
2242
2243 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2244 if (r > 0) {
ea352b40
LP		 2245 if (space)
2246 fputc(' ', f);
b0e39c82 2247 serialize_in_addrs(f, addresses, r);
b0e39c82
TG		 2248 }
2249 }
2250
b0e39c82
TG		 2251 fputs("\n", f);
2252
2253 fprintf(f, "NTP=");
ea352b40
LP		 2254 space = false;
2255 STRV_FOREACH(address, link->network->ntp) {
2256 if (space)
2257 fputc(' ', f);
2258 fputs(*address, f);
2259 space = true;
2260 }
d5314fff 2261
b0e39c82
TG		 2262 if (link->network->dhcp_ntp &&
2263 link->dhcp_lease) {
2264 const struct in_addr *addresses;
2265
2266 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2267 if (r > 0) {
ea352b40
LP		 2268 if (space)
2269 fputc(' ', f);
b0e39c82 2270 serialize_in_addrs(f, addresses, r);
b0e39c82
TG		 2271 }
2272 }
2273
b0e39c82 2274 fputs("\n", f);
bd8f6538 2275
6192b846 2276 fprintf(f, "DOMAINS=");
ea352b40
LP		 2277 space = false;
2278 STRV_FOREACH(domain, link->network->domains) {
2279 if (space)
2280 fputc(' ', f);
2281 fputs(*domain, f);
2282 space = true;
2283 }
d5314fff 2284
ad0734e8 2285 if (link->network->dhcp_domains &&
9b4d1882
TG		 2286 link->dhcp_lease) {
2287 const char *domainname;
2288
2289 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
6192b846 2290 if (r >= 0) {
ea352b40
LP		 2291 if (space)
2292 fputc(' ', f);
6192b846 2293 fputs(domainname, f);
6192b846 2294 }
9b4d1882
TG		 2295 }
2296
6192b846
TG		 2297 fputs("\n", f);
2298
67272d15
TG		 2299 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2300 yes_no(link->network->wildcard_domain));
2301
3c9b8860
TG		 2302 fprintf(f, "LLMNR=%s\n",
2303 llmnr_support_to_string(link->network->llmnr));
bcb7a07e 2304 }
7374f9d8 2305
0d4ad91d
AR		 2306 if (!hashmap_isempty(link->bound_to_links)) {
2307 Link *carrier;
2308 Iterator i;
2309 bool space = false;
2310
2311 fputs("CARRIER_BOUND_TO=", f);
2312 HASHMAP_FOREACH(carrier, link->bound_to_links, i) {
2313 if (space)
2314 fputc(' ', f);
2315 fputs(carrier->ifname, f);
2316 space = true;
2317 }
2318
2319 fputs("\n", f);
2320 }
2321
2322 if (!hashmap_isempty(link->bound_by_links)) {
2323 Link *carrier;
2324 Iterator i;
2325 bool space = false;
2326
2327 fputs("CARRIER_BOUND_BY=", f);
0d4ad91d
AR		 2328 HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
2329 if (space)
2330 fputc(' ', f);
2331 fputs(carrier->ifname, f);
2332 space = true;
2333 }
2334
2335 fputs("\n", f);
2336 }
2337
fe8db0c5 2338 if (link->dhcp_lease) {
d9876a52
TG		 2339 assert(link->network);
2340
1dc24d5f 2341 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
fe8db0c5 2342 if (r < 0)
c2d6bd61 2343 goto fail;
fe8db0c5 2344
7374f9d8 2345 fprintf(f,
b0e39c82
TG		 2346 "DHCP_LEASE=%s\n",
2347 link->lease_file);
deb2e523 2348 } else
68a8723c 2349 unlink(link->lease_file);
fe8db0c5 2350
49699bac
SS		 2351 if (link->lldp) {
2352 assert(link->network);
2353
2354 r = sd_lldp_save(link->lldp, link->lldp_file);
2355 if (r < 0)
2356 goto fail;
2357
2358 fprintf(f,
2359 "LLDP_FILE=%s\n",
2360 link->lldp_file);
2361 } else
2362 unlink(link->lldp_file);
2363
c2d6bd61
LP		 2364 r = fflush_and_check(f);
2365 if (r < 0)
2366 goto fail;
fe8db0c5 2367
c2d6bd61 2368 if (rename(temp_path, link->state_file) < 0) {
fe8db0c5 2369 r = -errno;
c2d6bd61 2370 goto fail;
fe8db0c5
TG		 2371 }
2372
c2d6bd61 2373 return 0;
c2d6bd61 2374fail:
6a7a4e4d
LP		 2375 log_link_error_errno(link, r, "Failed to save link data to %s: %m", link->state_file);
2376 (void) unlink(link->state_file);
2377
2378 if (temp_path)
2379 (void) unlink(temp_path);
2380
fe8db0c5
TG		 2381 return r;
2382}
2383
2384static const char* const link_state_table[_LINK_STATE_MAX] = {
8434fd5c 2385 [LINK_STATE_PENDING] = "pending",
fe8db0c5
TG		 2386 [LINK_STATE_ENSLAVING] = "configuring",
2387 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2388 [LINK_STATE_SETTING_ROUTES] = "configuring",
2389 [LINK_STATE_CONFIGURED] = "configured",
57bd6899 2390 [LINK_STATE_UNMANAGED] = "unmanaged",
fe8db0c5 2391 [LINK_STATE_FAILED] = "failed",
370e9930 2392 [LINK_STATE_LINGER] = "linger",
fe8db0c5
TG		 2393};
2394
2395DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
e375dcde
TG		 2396
2397static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
d3df0e39
TG		 2398 [LINK_OPERSTATE_OFF] = "off",
2399 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
e375dcde
TG		 2400 [LINK_OPERSTATE_DORMANT] = "dormant",
2401 [LINK_OPERSTATE_CARRIER] = "carrier",
2402 [LINK_OPERSTATE_DEGRADED] = "degraded",
2403 [LINK_OPERSTATE_ROUTABLE] = "routable",
2404};
2405
2406DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
Unnamed repository; edit this file 'description' to name the repository.