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