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