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