]> 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 #63 from arvidjaar/issue/50
[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
cb9fc36a 43 return IN_SET(link->network->dhcp, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
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
cb9fc36a 53 return IN_SET(link->network->dhcp, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
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
d0d6a4cd
TG		 73 return IN_SET(link->network->link_local, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
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
83 return IN_SET(link->network->link_local, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
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
769d324c
LP		 106 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
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
116 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
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
124static int link_update_flags(Link *link, sd_rtnl_message *m) {
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
TG		 134
135 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
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
505f8da7 196static int link_new(Manager *manager, sd_rtnl_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
505f8da7
TG		 206 r = sd_rtnl_message_get_type(message, &type);
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
218 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
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
512922f8
TG		 235 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
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
f882c247 500static int route_handler(sd_rtnl *rtnl, sd_rtnl_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
514 r = sd_rtnl_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
b22d8a00 557int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_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
568 r = sd_rtnl_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
f882c247 575static int address_handler(sd_rtnl *rtnl, sd_rtnl_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
592 r = sd_rtnl_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
b22d8a00 685int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_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
696 r = sd_rtnl_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
e1853b00
SS		 718static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
719 _cleanup_link_unref_ Link *link = userdata;
720 int r;
721
6a7a4e4d 722 log_link_debug(link, "Set link");
e1853b00
SS		 723
724 r = sd_rtnl_message_get_errno(m);
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 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
753 int r = 0;
754
b226d99b
TG		 755 assert(link);
756 assert(link->manager);
1346b1f0
TG		 757 assert(hostname);
758
79008bdd 759 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
1346b1f0 760
3c9b8860
TG		 761 if (!link->manager->bus) {
762 /* TODO: replace by assert when we can rely on kdbus */
6a7a4e4d 763 log_link_info(link, "Not connected to system bus, ignoring transient hostname.");
bcbca829
TG		 764 return 0;
765 }
766
1346b1f0 767 r = sd_bus_message_new_method_call(
b226d99b 768 link->manager->bus,
151b9b96 769 &m,
1346b1f0
TG		 770 "org.freedesktop.hostname1",
771 "/org/freedesktop/hostname1",
772 "org.freedesktop.hostname1",
151b9b96 773 "SetHostname");
1346b1f0
TG		 774 if (r < 0)
775 return r;
776
777 r = sd_bus_message_append(m, "sb", hostname, false);
778 if (r < 0)
779 return r;
780
3c9b8860
TG		 781 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
782 link, 0);
6a7a4e4d
LP		 783 if (r < 0)
784 return log_link_error_errno(link, r, "Could not set transient hostname: %m");
b226d99b
TG		 785
786 link_ref(link);
1346b1f0 787
5da8149f 788 return 0;
1346b1f0
TG		 789}
790
4f882b2a 791static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
5da8149f 792 _cleanup_link_unref_ Link *link = userdata;
4f882b2a
TG		 793 int r;
794
795 assert(m);
796 assert(link);
797 assert(link->ifname);
798
5da8149f 799 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
4f882b2a
TG		 800 return 1;
801
802 r = sd_rtnl_message_get_errno(m);
c9ccc19f 803 if (r < 0)
6a7a4e4d 804 log_link_warning_errno(link, r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
4f882b2a
TG		 805
806 return 1;
807}
808
3c9b8860 809int link_set_mtu(Link *link, uint32_t mtu) {
cf6a8911 810 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
4f882b2a
TG		 811 int r;
812
813 assert(link);
814 assert(link->manager);
815 assert(link->manager->rtnl);
816
6a7a4e4d 817 log_link_debug(link, "Setting MTU: %" PRIu32, mtu);
4f882b2a 818
6a7a4e4d
LP		 819 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
820 if (r < 0)
821 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
4f882b2a
TG		 822
823 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
6a7a4e4d
LP		 824 if (r < 0)
825 return log_link_error_errno(link, r, "Could not append MTU: %m");
4f882b2a 826
6a7a4e4d
LP		 827 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
828 if (r < 0)
829 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
4f882b2a 830
ae941762 831 link_ref(link);
b226d99b 832
4f882b2a
TG		 833 return 0;
834}
835
e1853b00
SS		 836static int link_set_bridge(Link *link) {
837 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
838 int r;
839
840 assert(link);
841 assert(link->network);
842
843 if(link->network->cost == 0)
844 return 0;
845
6a7a4e4d
LP		 846 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
847 if (r < 0)
848 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
e1853b00
SS		 849
850 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
6a7a4e4d
LP		 851 if (r < 0)
852 return log_link_error_errno(link, r, "Could not set message family: %m");
e1853b00
SS		 853
854 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
6a7a4e4d
LP		 855 if (r < 0)
856 return log_link_error_errno(link, r, "Could not append IFLA_PROTINFO attribute: %m");
e1853b00
SS		 857
858 if(link->network->cost != 0) {
859 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
6a7a4e4d
LP		 860 if (r < 0)
861 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_COST attribute: %m");
e1853b00
SS		 862 }
863
864 r = sd_rtnl_message_close_container(req);
6a7a4e4d
LP		 865 if (r < 0)
866 return log_link_error_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m");
e1853b00
SS		 867
868 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
6a7a4e4d
LP		 869 if (r < 0)
870 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
e1853b00
SS		 871
872 link_ref(link);
873
874 return r;
875}
876
49699bac
SS		 877static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
878 Link *link = userdata;
879 int r;
880
881 assert(link);
882 assert(link->network);
883 assert(link->manager);
884
885 if (event != UPDATE_INFO)
886 return;
887
888 r = sd_lldp_save(link->lldp, link->lldp_file);
889 if (r < 0)
6a7a4e4d 890 log_link_warning_errno(link, r, "Could not save LLDP: %m");
49699bac
SS		 891
892}
893
ff254138
TG		 894static int link_acquire_conf(Link *link) {
895 int r;
896
897 assert(link);
898 assert(link->network);
ff254138
TG		 899 assert(link->manager);
900 assert(link->manager->event);
901
78c958f8 902 if (link_ipv4ll_enabled(link)) {
eb34d4af 903 assert(link->ipv4ll);
ff254138 904
6a7a4e4d 905 log_link_debug(link, "Acquiring IPv4 link-local address");
5c1d3fc9
UTL		 906
907 r = sd_ipv4ll_start(link->ipv4ll);
6a7a4e4d
LP		 908 if (r < 0)
909 return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
5c1d3fc9
UTL		 910 }
911
78c958f8 912 if (link_dhcp4_enabled(link)) {
eb34d4af 913 assert(link->dhcp_client);
ff254138 914
6a7a4e4d 915 log_link_debug(link, "Acquiring DHCPv4 lease");
ab47d620 916
5c1d3fc9 917 r = sd_dhcp_client_start(link->dhcp_client);
6a7a4e4d
LP		 918 if (r < 0)
919 return log_link_warning_errno(link, r, "Could not acquire DHCPv4 lease: %m");
5c1d3fc9 920 }
ff254138 921
78c958f8 922 if (link_dhcp6_enabled(link)) {
4138fb2c
PF		 923 assert(link->icmp6_router_discovery);
924
6a7a4e4d 925 log_link_debug(link, "Discovering IPv6 routers");
4138fb2c
PF		 926
927 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
6a7a4e4d
LP		 928 if (r < 0)
929 return log_link_warning_errno(link, r, "Could not start IPv6 router discovery: %m");
4138fb2c
PF		 930 }
931
ce43e484
SS		 932 if (link_lldp_enabled(link)) {
933 assert(link->lldp);
934
935 log_link_debug(link, "Starting LLDP");
936
937 r = sd_lldp_start(link->lldp);
6a7a4e4d
LP		 938 if (r < 0)
939 return log_link_warning_errno(link, r, "Could not start LLDP: %m");
ce43e484
SS		 940 }
941
ff254138
TG		 942 return 0;
943}
944
a61bb41c 945bool link_has_carrier(Link *link) {
deb2e523
TG		 946 /* see Documentation/networking/operstates.txt in the kernel sources */
947
a61bb41c 948 if (link->kernel_operstate == IF_OPER_UP)
deb2e523
TG		 949 return true;
950
a61bb41c 951 if (link->kernel_operstate == IF_OPER_UNKNOWN)
deb2e523 952 /* operstate may not be implemented, so fall back to flags */
a61bb41c 953 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
deb2e523
TG		 954 return true;
955
956 return false;
957}
958
dd3efc09 959static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
5da8149f 960 _cleanup_link_unref_ Link *link = userdata;
dd3efc09
TG		 961 int r;
962
1746cf2a
TG		 963 assert(link);
964
5da8149f 965 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1746cf2a
TG		 966 return 1;
967
dd3efc09 968 r = sd_rtnl_message_get_errno(m);
6a7a4e4d
LP		 969 if (r < 0)
970 /* we warn but don't fail the link, as it may be
971 brought up later */
972 log_link_warning_errno(link, r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
45ad2c13 973
f882c247
TG		 974 return 1;
975}
976
977static int link_up(Link *link) {
cf6a8911 978 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
5c3072ea 979 uint8_t ipv6ll_mode;
f579559b
TG		 980 int r;
981
f882c247 982 assert(link);
c106cc36 983 assert(link->network);
f882c247
TG		 984 assert(link->manager);
985 assert(link->manager->rtnl);
986
6a7a4e4d 987 log_link_debug(link, "Bringing link up");
449f7554 988
6a7a4e4d
LP		 989 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
990 if (r < 0)
991 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
f579559b 992
5d4795f3 993 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
6a7a4e4d
LP		 994 if (r < 0)
995 return log_link_error_errno(link, r, "Could not set link flags: %m");
fc25d7f8 996
c106cc36
TG		 997 if (link->network->mac) {
998 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
6a7a4e4d
LP		 999 if (r < 0)
1000 return log_link_error_errno(link, r, "Could not set MAC address: %m");
c106cc36
TG		 1001 }
1002
1003 if (link->network->mtu) {
1004 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
6a7a4e4d
LP		 1005 if (r < 0)
1006 return log_link_error_errno(link, r, "Could not set MTU: %m");
c106cc36
TG		 1007 }
1008
7f77697a 1009 r = sd_rtnl_message_open_container(req, IFLA_AF_SPEC);
6a7a4e4d
LP		 1010 if (r < 0)
1011 return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
d0d6a4cd 1012
01d28f81
TG		 1013 if (socket_ipv6_is_supported()) {
1014 /* if the kernel lacks ipv6 support setting IFF_UP fails if any ipv6 options are passed */
1015 r = sd_rtnl_message_open_container(req, AF_INET6);
1016 if (r < 0)
1017 return log_link_error_errno(link, r, "Could not open AF_INET6 container: %m");
d0d6a4cd 1018
01d28f81
TG		 1019 ipv6ll_mode = link_ipv6ll_enabled(link) ? IN6_ADDR_GEN_MODE_EUI64 : IN6_ADDR_GEN_MODE_NONE;
1020 r = sd_rtnl_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
1021 if (r < 0)
1022 return log_link_error_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
d0d6a4cd 1023
01d28f81
TG		 1024 if (!in_addr_is_null(AF_INET6, &link->network->ipv6_token)) {
1025 r = sd_rtnl_message_append_in6_addr(req, IFLA_INET6_TOKEN, &link->network->ipv6_token.in6);
1026 if (r < 0)
1027 return log_link_error_errno(link, r, "Could not append IFLA_INET6_TOKEN: %m");
1028 }
1029
1030 r = sd_rtnl_message_close_container(req);
6a7a4e4d 1031 if (r < 0)
01d28f81 1032 return log_link_error_errno(link, r, "Could not close AF_INET6 container: %m");
7f77697a 1033 }
d0d6a4cd 1034
7f77697a 1035 r = sd_rtnl_message_close_container(req);
6a7a4e4d
LP		 1036 if (r < 0)
1037 return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
d0d6a4cd 1038
6a7a4e4d
LP		 1039 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1040 if (r < 0)
1041 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
f579559b 1042
b226d99b
TG		 1043 link_ref(link);
1044
f882c247
TG		 1045 return 0;
1046}
1047
0d4ad91d
AR		 1048static int link_down_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1049 _cleanup_link_unref_ Link *link = userdata;
1050 int r;
1051
1052 assert(link);
1053
1054 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1055 return 1;
1056
1057 r = sd_rtnl_message_get_errno(m);
1058 if (r < 0)
6a7a4e4d 1059 log_link_warning_errno(link, r, "%-*s: could not bring down interface: %m", IFNAMSIZ, link->ifname);
0d4ad91d
AR		 1060
1061 return 1;
1062}
1063
1064static int link_down(Link *link) {
1065 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1066 int r;
1067
1068 assert(link);
1069 assert(link->manager);
1070 assert(link->manager->rtnl);
1071
6a7a4e4d 1072 log_link_debug(link, "Bringing link down");
0d4ad91d
AR		 1073
1074 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1075 RTM_SETLINK, link->ifindex);
6a7a4e4d
LP		 1076 if (r < 0)
1077 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
0d4ad91d
AR		 1078
1079 r = sd_rtnl_message_link_set_flags(req, 0, IFF_UP);
6a7a4e4d
LP		 1080 if (r < 0)
1081 return log_link_error_errno(link, r, "Could not set link flags: %m");
0d4ad91d 1082
6a7a4e4d
LP		 1083 r = sd_rtnl_call_async(link->manager->rtnl, req, link_down_handler, link, 0, NULL);
1084 if (r < 0)
1085 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
0d4ad91d
AR		 1086
1087 link_ref(link);
1088
1089 return 0;
1090}
1091
1092static int link_handle_bound_to_list(Link *link) {
1093 Link *l;
1094 Iterator i;
1095 int r;
1096 bool required_up = false;
1097 bool link_is_up = false;
1098
1099 assert(link);
1100
1101 if (hashmap_isempty(link->bound_to_links))
1102 return 0;
1103
1104 if (link->flags & IFF_UP)
1105 link_is_up = true;
1106
1107 HASHMAP_FOREACH (l, link->bound_to_links, i)
1108 if (link_has_carrier(l)) {
1109 required_up = true;
1110 break;
1111 }
1112
1113 if (!required_up && link_is_up) {
1114 r = link_down(link);
1115 if (r < 0)
1116 return r;
1117 } else if (required_up && !link_is_up) {
1118 r = link_up(link);
1119 if (r < 0)
1120 return r;
1121 }
1122
1123 return 0;
1124}
1125
1126static int link_handle_bound_by_list(Link *link) {
1127 Iterator i;
1128 Link *l;
1129 int r;
1130
1131 assert(link);
1132
1133 if (hashmap_isempty(link->bound_by_links))
1134 return 0;
1135
1136 HASHMAP_FOREACH (l, link->bound_by_links, i) {
1137 r = link_handle_bound_to_list(l);
1138 if (r < 0)
1139 return r;
1140 }
1141
1142 return 0;
1143}
1144
1145static int link_put_carrier(Link *link, Link *carrier, Hashmap **h) {
1146 int r;
1147
1148 assert(link);
1149 assert(carrier);
1150
1151 if (link == carrier)
1152 return 0;
1153
1154 if (hashmap_get(*h, INT_TO_PTR(carrier->ifindex)))
1155 return 0;
1156
1157 r = hashmap_ensure_allocated(h, NULL);
1158 if (r < 0)
1159 return r;
1160
1161 r = hashmap_put(*h, INT_TO_PTR(carrier->ifindex), carrier);
1162 if (r < 0)
1163 return r;
1164
1165 return 0;
1166}
1167
1168static int link_new_bound_by_list(Link *link) {
1169 Manager *m;
1170 Link *carrier;
1171 Iterator i;
1172 int r;
1173 bool list_updated = false;
1174
1175 assert(link);
1176 assert(link->manager);
1177
1178 m = link->manager;
1179
1180 HASHMAP_FOREACH (carrier, m->links, i) {
1181 if (!carrier->network)
1182 continue;
1183
1184 if (strv_isempty(carrier->network->bind_carrier))
1185 continue;
1186
1187 if (strv_fnmatch(carrier->network->bind_carrier, link->ifname, 0)) {
1188 r = link_put_carrier(link, carrier, &link->bound_by_links);
1189 if (r < 0)
1190 return r;
1191
1192 list_updated = true;
1193 }
1194 }
1195
1196 if (list_updated)
1197 link_save(link);
1198
1199 HASHMAP_FOREACH (carrier, link->bound_by_links, i) {
1200 r = link_put_carrier(carrier, link, &carrier->bound_to_links);
1201 if (r < 0)
1202 return r;
1203
1204 link_save(carrier);
1205 }
1206
1207 return 0;
1208}
1209
1210static int link_new_bound_to_list(Link *link) {
1211 Manager *m;
1212 Link *carrier;
1213 Iterator i;
1214 int r;
1215 bool list_updated = false;
1216
1217 assert(link);
1218 assert(link->manager);
1219
1220 if (!link->network)
1221 return 0;
1222
1223 if (strv_isempty(link->network->bind_carrier))
1224 return 0;
1225
1226 m = link->manager;
1227
1228 HASHMAP_FOREACH (carrier, m->links, i) {
1229 if (strv_fnmatch(link->network->bind_carrier, carrier->ifname, 0)) {
1230 r = link_put_carrier(link, carrier, &link->bound_to_links);
1231 if (r < 0)
1232 return r;
1233
1234 list_updated = true;
1235 }
1236 }
1237
1238 if (list_updated)
1239 link_save(link);
1240
1241 HASHMAP_FOREACH (carrier, link->bound_to_links, i) {
1242 r = link_put_carrier(carrier, link, &carrier->bound_by_links);
1243 if (r < 0)
1244 return r;
1245
1246 link_save(carrier);
1247 }
1248
1249 return 0;
1250}
1251
1252static int link_new_carrier_maps(Link *link) {
1253 int r;
1254
1255 r = link_new_bound_by_list(link);
1256 if (r < 0)
1257 return r;
1258
1259 r = link_handle_bound_by_list(link);
1260 if (r < 0)
1261 return r;
1262
1263 r = link_new_bound_to_list(link);
1264 if (r < 0)
1265 return r;
1266
1267 r = link_handle_bound_to_list(link);
1268 if (r < 0)
1269 return r;
1270
1271 return 0;
1272}
1273
1274static void link_free_bound_to_list(Link *link) {
1275 Link *bound_to;
1276 Iterator i;
1277
1278 HASHMAP_FOREACH (bound_to, link->bound_to_links, i) {
1279 hashmap_remove(link->bound_to_links, INT_TO_PTR(bound_to->ifindex));
1280
1281 if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
1282 link_save(bound_to);
1283 }
1284
1285 return;
1286}
1287
1288static void link_free_bound_by_list(Link *link) {
1289 Link *bound_by;
1290 Iterator i;
1291
1292 HASHMAP_FOREACH (bound_by, link->bound_by_links, i) {
1293 hashmap_remove(link->bound_by_links, INT_TO_PTR(bound_by->ifindex));
1294
1295 if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
1296 link_save(bound_by);
1297 link_handle_bound_to_list(bound_by);
1298 }
1299 }
1300
1301 return;
1302}
1303
1304static void link_free_carrier_maps(Link *link) {
1305 bool list_updated = false;
1306
1307 assert(link);
1308
1309 if (!hashmap_isempty(link->bound_to_links)) {
1310 link_free_bound_to_list(link);
1311 list_updated = true;
1312 }
1313
1314 if (!hashmap_isempty(link->bound_by_links)) {
1315 link_free_bound_by_list(link);
1316 list_updated = true;
1317 }
1318
1319 if (list_updated)
1320 link_save(link);
1321
1322 return;
1323}
1324
1325void link_drop(Link *link) {
1326 if (!link || link->state == LINK_STATE_LINGER)
1327 return;
1328
1329 link_set_state(link, LINK_STATE_LINGER);
1330
1331 link_free_carrier_maps(link);
1332
6a7a4e4d 1333 log_link_debug(link, "Link removed");
0d4ad91d
AR		 1334
1335 link_unref(link);
1336
1337 return;
1338}
1339
3f265037 1340static int link_joined(Link *link) {
f882c247
TG		 1341 int r;
1342
ef1ba606 1343 assert(link);
f5be5601 1344 assert(link->network);
dd3efc09 1345
0d4ad91d
AR		 1346 if (!hashmap_isempty(link->bound_to_links)) {
1347 r = link_handle_bound_to_list(link);
1348 if (r < 0)
1349 return r;
1350 } else if (!(link->flags & IFF_UP)) {
505f8da7
TG		 1351 r = link_up(link);
1352 if (r < 0) {
1353 link_enter_failed(link);
1354 return r;
1355 }
ef1ba606 1356 }
f882c247 1357
e1853b00
SS		 1358 if(link->network->bridge) {
1359 r = link_set_bridge(link);
6a7a4e4d
LP		 1360 if (r < 0)
1361 log_link_error_errno(link, r, "Could not set bridge message: %m");
e1853b00
SS		 1362 }
1363
fb6730c4 1364 return link_enter_set_addresses(link);
02b59d57
TG		 1365}
1366
3c9b8860
TG		 1367static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1368 void *userdata) {
5da8149f 1369 _cleanup_link_unref_ Link *link = userdata;
02b59d57
TG		 1370 int r;
1371
1746cf2a 1372 assert(link);
ef1ba606 1373 assert(link->network);
02b59d57 1374
52433f6b
TG		 1375 link->enslaving --;
1376
5da8149f 1377 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
02b59d57
TG		 1378 return 1;
1379
1380 r = sd_rtnl_message_get_errno(m);
856f962c 1381 if (r < 0 && r != -EEXIST) {
6a7a4e4d 1382 log_link_error_errno(link, r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
ef1ba606
TG		 1383 link_enter_failed(link);
1384 return 1;
ba179154 1385 } else
6a7a4e4d 1386 log_link_debug(link, "Joined netdev");
02b59d57 1387
856f962c 1388 if (link->enslaving <= 0)
3f265037 1389 link_joined(link);
02b59d57
TG		 1390
1391 return 1;
1392}
1393
3f265037 1394static int link_enter_join_netdev(Link *link) {
6a0a2f86 1395 NetDev *netdev;
672682a6 1396 Iterator i;
02b59d57
TG		 1397 int r;
1398
1399 assert(link);
1400 assert(link->network);
8434fd5c 1401 assert(link->state == LINK_STATE_PENDING);
02b59d57 1402
e331e246 1403 link_set_state(link, LINK_STATE_ENSLAVING);
02b59d57 1404
fe8db0c5
TG		 1405 link_save(link);
1406
7951dea2
SS		 1407 if (!link->network->bridge &&
1408 !link->network->bond &&
6a0a2f86 1409 hashmap_isempty(link->network->stacked_netdevs))
3f265037 1410 return link_joined(link);
02b59d57 1411
d9c67ea1 1412 if (link->network->bond) {
f2341e0a
LP		 1413 log_struct(LOG_DEBUG,
1414 LOG_LINK_INTERFACE(link),
1415 LOG_NETDEV_INTERFACE(link->network->bond),
1416 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bond->ifname),
1417 NULL);
1418
1419 r = netdev_join(link->network->bond, link, netdev_join_handler);
52433f6b 1420 if (r < 0) {
f2341e0a
LP		 1421 log_struct_errno(LOG_WARNING, r,
1422 LOG_LINK_INTERFACE(link),
1423 LOG_NETDEV_INTERFACE(link->network->bond),
1424 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bond->ifname),
1425 NULL);
1426
52433f6b
TG		 1427 link_enter_failed(link);
1428 return r;
1429 }
1430
0ad6148e
MO		 1431 link->enslaving ++;
1432 }
1433
d9c67ea1 1434 if (link->network->bridge) {
f2341e0a
LP		 1435 log_struct(LOG_DEBUG,
1436 LOG_LINK_INTERFACE(link),
1437 LOG_NETDEV_INTERFACE(link->network->bridge),
1438 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bridge->ifname),
1439 NULL);
1440
1441 r = netdev_join(link->network->bridge, link, netdev_join_handler);
0ad6148e 1442 if (r < 0) {
f2341e0a
LP		 1443 log_struct_errno(LOG_WARNING, r,
1444 LOG_LINK_INTERFACE(link),
1445 LOG_NETDEV_INTERFACE(link->network->bridge),
1446 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bridge->ifname),
1447 NULL),
0ad6148e
MO		 1448 link_enter_failed(link);
1449 return r;
1450 }
1451
52433f6b
TG		 1452 link->enslaving ++;
1453 }
1454
6a0a2f86 1455 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
7951dea2 1456
f2341e0a
LP		 1457 log_struct(LOG_DEBUG,
1458 LOG_LINK_INTERFACE(link),
1459 LOG_NETDEV_INTERFACE(netdev),
1460 LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname),
1461 NULL);
1462
1463 r = netdev_join(netdev, link, netdev_join_handler);
7951dea2 1464 if (r < 0) {
f2341e0a
LP		 1465 log_struct_errno(LOG_WARNING, r,
1466 LOG_LINK_INTERFACE(link),
1467 LOG_NETDEV_INTERFACE(netdev),
1468 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname),
1469 NULL);
326cb406
SS		 1470 link_enter_failed(link);
1471 return r;
1472 }
1473
326cb406
SS		 1474 link->enslaving ++;
1475 }
1476
ef1ba606
TG		 1477 return 0;
1478}
1479
769d324c 1480static int link_set_ipv4_forward(Link *link) {
5a8bcb67
LP		 1481 const char *p = NULL;
1482 int r;
1483
a70ec7f1
NO		 1484 if (link->network->ip_forward == ADDRESS_FAMILY_KERNEL)
1485 return 0;
1486
63c372cb 1487 p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
505c5f6d 1488 r = write_string_file_no_create(p, one_zero(link_ipv4_forward_enabled(link)));
5a8bcb67 1489 if (r < 0)
43c6d5ab
LP		 1490 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1491
769d324c
LP		 1492 return 0;
1493}
1494
1495static int link_set_ipv6_forward(Link *link) {
1496 const char *p = NULL;
1497 int r;
1498
fe027299
LP		 1499 /* Make this a NOP if IPv6 is not available */
1500 if (!socket_ipv6_is_supported())
1501 return 0;
1502
a70ec7f1
NO		 1503 if (link->network->ip_forward == ADDRESS_FAMILY_KERNEL)
1504 return 0;
1505
63c372cb 1506 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
769d324c
LP		 1507 r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1508 if (r < 0)
1509 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
5a8bcb67
LP		 1510
1511 return 0;
1512}
1513
a748b692 1514static int link_configure(Link *link) {
02b59d57
TG		 1515 int r;
1516
ef1ba606 1517 assert(link);
b22d8a00 1518 assert(link->network);
8434fd5c 1519 assert(link->state == LINK_STATE_PENDING);
a748b692 1520
b98b483b
AR		 1521 r = link_set_bridge_fdb(link);
1522 if (r < 0)
1523 return r;
1524
769d324c
LP		 1525 r = link_set_ipv4_forward(link);
1526 if (r < 0)
1527 return r;
1528
1529 r = link_set_ipv6_forward(link);
5a8bcb67
LP		 1530 if (r < 0)
1531 return r;
1532
78c958f8 1533 if (link_ipv4ll_enabled(link)) {
b22d8a00 1534 r = ipv4ll_configure(link);
eb34d4af
TG		 1535 if (r < 0)
1536 return r;
1537 }
1538
78c958f8 1539 if (link_dhcp4_enabled(link)) {
3c9b8860 1540 r = dhcp4_configure(link);
eb34d4af
TG		 1541 if (r < 0)
1542 return r;
eb34d4af
TG		 1543 }
1544
78c958f8 1545 if (link_dhcp4_server_enabled(link)) {
dd43110f
TG		 1546 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1547 if (r < 0)
1548 return r;
1549
1550 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1551 if (r < 0)
1552 return r;
dd43110f
TG		 1553 }
1554
78c958f8 1555 if (link_dhcp6_enabled(link)) {
5c79bd79 1556 r = icmp6_configure(link);
4138fb2c
PF		 1557 if (r < 0)
1558 return r;
1559 }
1560
ce43e484
SS		 1561 if (link_lldp_enabled(link)) {
1562 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1563 if (r < 0)
1564 return r;
1565
1566 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1567 if (r < 0)
1568 return r;
49699bac
SS		 1569
1570 r = sd_lldp_set_callback(link->lldp,
1571 lldp_handler, link);
1572 if (r < 0)
1573 return r;
ce43e484
SS		 1574 }
1575
a61bb41c 1576 if (link_has_carrier(link)) {
1e9be60b
TG		 1577 r = link_acquire_conf(link);
1578 if (r < 0)
1579 return r;
cc544d5f 1580 }
1e9be60b 1581
3f265037 1582 return link_enter_join_netdev(link);
505f8da7
TG		 1583}
1584
3c9b8860
TG		 1585static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1586 void *userdata) {
5da8149f 1587 _cleanup_link_unref_ Link *link = userdata;
505f8da7 1588 Network *network;
505f8da7
TG		 1589 int r;
1590
1591 assert(link);
1592 assert(link->ifname);
1593 assert(link->manager);
1594
8434fd5c 1595 if (link->state != LINK_STATE_PENDING)
5da8149f 1596 return 1;
505f8da7 1597
6a7a4e4d 1598 log_link_debug(link, "Link state is up-to-date");
505f8da7 1599
0d4ad91d
AR		 1600 r = link_new_bound_by_list(link);
1601 if (r < 0)
1602 return r;
1603
1604 r = link_handle_bound_by_list(link);
1605 if (r < 0)
1606 return r;
1607
3c9b8860
TG		 1608 r = network_get(link->manager, link->udev_device, link->ifname,
1609 &link->mac, &network);
57bd6899
TG		 1610 if (r == -ENOENT) {
1611 link_enter_unmanaged(link);
5da8149f 1612 return 1;
57bd6899
TG		 1613 } else if (r < 0)
1614 return r;
505f8da7 1615
bd2efe92 1616 if (link->flags & IFF_LOOPBACK) {
d0d6a4cd 1617 if (network->link_local != ADDRESS_FAMILY_NO)
6a7a4e4d 1618 log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
78c958f8 1619
cb9fc36a 1620 if (network->dhcp != ADDRESS_FAMILY_NO)
6a7a4e4d 1621 log_link_debug(link, "Ignoring DHCP clients for loopback link");
78c958f8
TG		 1622
1623 if (network->dhcp_server)
6a7a4e4d 1624 log_link_debug(link, "Ignoring DHCP server for loopback link");
bd2efe92
TG		 1625 }
1626
505f8da7
TG		 1627 r = network_apply(link->manager, network, link);
1628 if (r < 0)
1629 return r;
1630
0d4ad91d
AR		 1631 r = link_new_bound_to_list(link);
1632 if (r < 0)
1633 return r;
1634
a748b692
TG		 1635 r = link_configure(link);
1636 if (r < 0)
1637 return r;
1638
5da8149f 1639 return 1;
505f8da7
TG		 1640}
1641
4f561e8e
TG		 1642int link_initialized(Link *link, struct udev_device *device) {
1643 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1644 int r;
1645
1646 assert(link);
1647 assert(link->manager);
1648 assert(link->manager->rtnl);
1649 assert(device);
1650
8434fd5c 1651 if (link->state != LINK_STATE_PENDING)
4f561e8e
TG		 1652 return 0;
1653
679b3605
TG		 1654 if (link->udev_device)
1655 return 0;
1656
79008bdd 1657 log_link_debug(link, "udev initialized link");
4f561e8e
TG		 1658
1659 link->udev_device = udev_device_ref(device);
1660
3c9b8860
TG		 1661 /* udev has initialized the link, but we don't know if we have yet
1662 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1663 * when it returns we know that the pending NEWLINKs have already been
1664 * processed and that we are up-to-date */
4f561e8e 1665
3c9b8860
TG		 1666 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1667 link->ifindex);
4f561e8e
TG		 1668 if (r < 0)
1669 return r;
1670
3c9b8860
TG		 1671 r = sd_rtnl_call_async(link->manager->rtnl, req,
1672 link_initialized_and_synced, link, 0, NULL);
4f561e8e
TG		 1673 if (r < 0)
1674 return r;
1675
5da8149f
TG		 1676 link_ref(link);
1677
4f561e8e
TG		 1678 return 0;
1679}
1680
5a8bcb67
LP		 1681static Address* link_get_equal_address(Link *link, Address *needle) {
1682 Address *i;
1683
1684 assert(link);
1685 assert(needle);
1686
1687 LIST_FOREACH(addresses, i, link->addresses)
1688 if (address_equal(i, needle))
1689 return i;
1690
1691 return NULL;
1692}
1693
45af44d4 1694int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
fbbeb65a
TG		 1695 Manager *m = userdata;
1696 Link *link = NULL;
1697 uint16_t type;
1698 _cleanup_address_free_ Address *address = NULL;
851c9f82 1699 unsigned char flags;
5a8bcb67
LP		 1700 Address *existing;
1701 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
c6d3b303 1702 const char *valid_str = NULL;
fbbeb65a
TG		 1703 int r, ifindex;
1704
1705 assert(rtnl);
1706 assert(message);
1707 assert(m);
1708
45af44d4
TG		 1709 if (sd_rtnl_message_is_error(message)) {
1710 r = sd_rtnl_message_get_errno(message);
1711 if (r < 0)
1712 log_warning_errno(r, "rtnl: failed to receive address: %m");
1713
1714 return 0;
1715 }
1716
fbbeb65a
TG		 1717 r = sd_rtnl_message_get_type(message, &type);
1718 if (r < 0) {
6a7a4e4d 1719 log_warning_errno(r, "rtnl: could not get message type: %m");
fbbeb65a 1720 return 0;
cdfee943
TG		 1721 } else if (type != RTM_NEWADDR && type != RTM_DELADDR) {
1722 log_warning("rtnl: received unexpected message type when processing address");
1723 return 0;
fbbeb65a
TG		 1724 }
1725
1726 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
45af44d4 1727 if (r < 0) {
cdfee943 1728 log_warning_errno(r, "rtnl: could not get ifindex from address: %m");
45af44d4
TG		 1729 return 0;
1730 } else if (ifindex <= 0) {
1731 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
fbbeb65a
TG		 1732 return 0;
1733 } else {
1734 r = link_get(m, ifindex, &link);
1735 if (r < 0 || !link) {
6a24f148
TG		 1736 /* when enumerating we might be out of sync, but we will
1737 * get the address again, so just ignore it */
1738 if (!m->enumerating)
1739 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
fbbeb65a
TG		 1740 return 0;
1741 }
1742 }
1743
1744 r = address_new_dynamic(&address);
1745 if (r < 0)
393c0c5e 1746 return r;
fbbeb65a
TG		 1747
1748 r = sd_rtnl_message_addr_get_family(message, &address->family);
1749 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
6a7a4e4d 1750 log_link_warning(link, "rtnl: received address with invalid family, ignoring.");
fbbeb65a
TG		 1751 return 0;
1752 }
1753
1754 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1755 if (r < 0) {
6a7a4e4d 1756 log_link_warning_errno(link, r, "rtnl: received address with invalid prefixlen, ignoring: %m");
e375dcde
TG		 1757 return 0;
1758 }
1759
1760 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1761 if (r < 0) {
6a7a4e4d 1762 log_link_warning_errno(link, r, "rtnl: received address with invalid scope, ignoring: %m");
fbbeb65a
TG		 1763 return 0;
1764 }
1765
851c9f82 1766 r = sd_rtnl_message_addr_get_flags(message, &flags);
81163121 1767 if (r < 0) {
6a7a4e4d 1768 log_link_warning_errno(link, r, "rtnl: received address with invalid flags, ignoring: %m");
81163121
TG		 1769 return 0;
1770 }
851c9f82 1771 address->flags = flags;
81163121 1772
fbbeb65a
TG		 1773 switch (address->family) {
1774 case AF_INET:
5a8bcb67 1775 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
fbbeb65a 1776 if (r < 0) {
6a7a4e4d 1777 log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
fbbeb65a
TG		 1778 return 0;
1779 }
1780
1781 break;
1782
1783 case AF_INET6:
5a8bcb67 1784 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
fbbeb65a 1785 if (r < 0) {
6a7a4e4d 1786 log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
fbbeb65a
TG		 1787 return 0;
1788 }
1789
1790 break;
1791
1792 default:
1793 assert_not_reached("invalid address family");
1794 }
1795
5a8bcb67 1796 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
6a7a4e4d 1797 log_link_warning(link, "Could not print address");
fbbeb65a
TG		 1798 return 0;
1799 }
1800
5a8bcb67 1801 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
c6d3b303
TG		 1802 if (r >= 0) {
1803 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1804 valid_str = "ever";
1805 else
1806 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1807 address->cinfo.ifa_valid * USEC_PER_SEC,
1808 USEC_PER_SEC);
1809 }
1810
5a8bcb67
LP		 1811 existing = link_get_equal_address(link, address);
1812
1813 switch (type) {
1814 case RTM_NEWADDR:
1815 if (existing) {
1816 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
428fd0a7 1817
428fd0a7 1818
5a8bcb67
LP		 1819 existing->scope = address->scope;
1820 existing->flags = address->flags;
1821 existing->cinfo = address->cinfo;
428fd0a7 1822
5a8bcb67
LP		 1823 } else {
1824 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
428fd0a7 1825
5a8bcb67
LP		 1826 LIST_PREPEND(addresses, link->addresses, address);
1827 address_establish(address, link);
fbbeb65a 1828
5a8bcb67 1829 address = NULL;
428fd0a7 1830
5a8bcb67
LP		 1831 link_save(link);
1832 }
f5602be9 1833
428fd0a7 1834 break;
5a8bcb67 1835
fbbeb65a 1836 case RTM_DELADDR:
428fd0a7 1837
5a8bcb67
LP		 1838 if (existing) {
1839 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1840 address_release(existing, link);
1841 LIST_REMOVE(addresses, link->addresses, existing);
1842 address_free(existing);
393c0c5e 1843 } else
5a8bcb67 1844 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
f5602be9 1845
fbbeb65a
TG		 1846 break;
1847 default:
1848 assert_not_reached("Received invalid RTNL message type");
1849 }
1850
1851 return 1;
1852}
1853
505f8da7
TG		 1854int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1855 Link *link;
1856 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1857 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1858 int r;
1859
1860 assert(m);
fbbeb65a 1861 assert(m->rtnl);
505f8da7
TG		 1862 assert(message);
1863 assert(ret);
1864
1865 r = link_new(m, message, ret);
1866 if (r < 0)
1867 return r;
1868
1869 link = *ret;
1870
6a7a4e4d 1871 log_link_debug(link, "Link %d added", link->ifindex);
505f8da7
TG		 1872
1873 if (detect_container(NULL) <= 0) {
1874 /* not in a container, udev will be around */
ae06ab10 1875 sprintf(ifindex_str, "n%d", link->ifindex);
505f8da7 1876 device = udev_device_new_from_device_id(m->udev, ifindex_str);
6a7a4e4d
LP		 1877 if (!device)
1878 return log_link_warning_errno(link, errno, "Could not find udev device: %m");
505f8da7 1879
3c4cb064 1880 if (udev_device_get_is_initialized(device) <= 0) {
505f8da7 1881 /* not yet ready */
79008bdd 1882 log_link_debug(link, "link pending udev initialization...");
505f8da7 1883 return 0;
3c4cb064 1884 }
505f8da7 1885
4f561e8e
TG		 1886 r = link_initialized(link, device);
1887 if (r < 0)
1888 return r;
1889 } else {
5da8149f
TG		 1890 /* we are calling a callback directly, so must take a ref */
1891 link_ref(link);
1892
4f561e8e
TG		 1893 r = link_initialized_and_synced(m->rtnl, NULL, link);
1894 if (r < 0)
1895 return r;
1896 }
505f8da7 1897
a748b692
TG		 1898 return 0;
1899}
1900
9c0a72f9
TG		 1901static int link_carrier_gained(Link *link) {
1902 int r;
1903
1904 assert(link);
1905
1906 if (link->network) {
1907 r = link_acquire_conf(link);
1908 if (r < 0) {
1909 link_enter_failed(link);
1910 return r;
1911 }
1912 }
1913
0d4ad91d
AR		 1914 r = link_handle_bound_by_list(link);
1915 if (r < 0)
1916 return r;
1917
9c0a72f9
TG		 1918 return 0;
1919}
1920
1921static int link_carrier_lost(Link *link) {
1922 int r;
1923
1924 assert(link);
1925
1926 r = link_stop_clients(link);
1927 if (r < 0) {
1928 link_enter_failed(link);
1929 return r;
1930 }
1931
0d4ad91d
AR		 1932 r = link_handle_bound_by_list(link);
1933 if (r < 0)
1934 return r;
1935
9c0a72f9
TG		 1936 return 0;
1937}
1938
1939int link_carrier_reset(Link *link) {
1940 int r;
1941
1942 assert(link);
1943
1944 if (link_has_carrier(link)) {
1945 r = link_carrier_lost(link);
1946 if (r < 0)
1947 return r;
1948
1949 r = link_carrier_gained(link);
1950 if (r < 0)
1951 return r;
1952
6a7a4e4d 1953 log_link_info(link, "Reset carrier");
9c0a72f9
TG		 1954 }
1955
1956 return 0;
1957}
1958
1959
22936833 1960int link_update(Link *link, sd_rtnl_message *m) {
c49b33ac 1961 struct ether_addr mac;
ca4e095a 1962 const char *ifname;
afe7fd56 1963 uint32_t mtu;
a61bb41c 1964 bool had_carrier, carrier_gained, carrier_lost;
22936833
TG		 1965 int r;
1966
dd3efc09 1967 assert(link);
b8941f74 1968 assert(link->ifname);
22936833
TG		 1969 assert(m);
1970
7619683b
TG		 1971 if (link->state == LINK_STATE_LINGER) {
1972 link_ref(link);
6a7a4e4d 1973 log_link_info(link, "Link readded");
e331e246 1974 link_set_state(link, LINK_STATE_ENSLAVING);
0d4ad91d
AR		 1975
1976 r = link_new_carrier_maps(link);
1977 if (r < 0)
1978 return r;
7619683b
TG		 1979 }
1980
b8941f74
TG		 1981 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1982 if (r >= 0 && !streq(ifname, link->ifname)) {
6a7a4e4d 1983 log_link_info(link, "Renamed to %s", ifname);
b8941f74 1984
0d4ad91d
AR		 1985 link_free_carrier_maps(link);
1986
b8941f74
TG		 1987 free(link->ifname);
1988 link->ifname = strdup(ifname);
1989 if (!link->ifname)
1990 return -ENOMEM;
0d4ad91d
AR		 1991
1992 r = link_new_carrier_maps(link);
1993 if (r < 0)
1994 return r;
b8941f74
TG		 1995 }
1996
afe7fd56
TG		 1997 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1998 if (r >= 0 && mtu > 0) {
1999 link->mtu = mtu;
2000 if (!link->original_mtu) {
2001 link->original_mtu = mtu;
6a7a4e4d 2002 log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
afe7fd56
TG		 2003 }
2004
2005 if (link->dhcp_client) {
3c9b8860
TG		 2006 r = sd_dhcp_client_set_mtu(link->dhcp_client,
2007 link->mtu);
afe7fd56 2008 if (r < 0) {
6a7a4e4d 2009 log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
afe7fd56
TG		 2010 return r;
2011 }
2012 }
9842de0d 2013 }
69629de9 2014
e9189a1f
TG		 2015 /* The kernel may broadcast NEWLINK messages without the MAC address
2016 set, simply ignore them. */
c49b33ac 2017 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
e9189a1f 2018 if (r >= 0) {
3c9b8860
TG		 2019 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
2020 ETH_ALEN)) {
c49b33ac 2021
3c9b8860
TG		 2022 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
2023 ETH_ALEN);
c49b33ac 2024
79008bdd 2025 log_link_debug(link, "MAC address: "
20861203
TG		 2026 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2027 mac.ether_addr_octet[0],
2028 mac.ether_addr_octet[1],
2029 mac.ether_addr_octet[2],
2030 mac.ether_addr_octet[3],
2031 mac.ether_addr_octet[4],
2032 mac.ether_addr_octet[5]);
c49b33ac 2033
20861203
TG		 2034 if (link->ipv4ll) {
2035 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
6a7a4e4d
LP		 2036 if (r < 0)
2037 return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
c49b33ac 2038 }
c49b33ac 2039
20861203 2040 if (link->dhcp_client) {
3c9b8860 2041 r = sd_dhcp_client_set_mac(link->dhcp_client,
76253e73
DW		 2042 (const uint8_t *) &link->mac,
2043 sizeof (link->mac),
2044 ARPHRD_ETHER);
6a7a4e4d
LP		 2045 if (r < 0)
2046 return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
c49b33ac 2047 }
4138fb2c
PF		 2048
2049 if (link->dhcp6_client) {
2050 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
76253e73
DW		 2051 (const uint8_t *) &link->mac,
2052 sizeof (link->mac),
2053 ARPHRD_ETHER);
6a7a4e4d
LP		 2054 if (r < 0)
2055 return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
4138fb2c 2056 }
c49b33ac 2057 }
4f882b2a
TG		 2058 }
2059
a61bb41c
TG		 2060 had_carrier = link_has_carrier(link);
2061
2062 r = link_update_flags(link, m);
2063 if (r < 0)
2064 return r;
2065
2066 carrier_gained = !had_carrier && link_has_carrier(link);
2067 carrier_lost = had_carrier && !link_has_carrier(link);
2068
2069 if (carrier_gained) {
6a7a4e4d 2070 log_link_info(link, "Gained carrier");
a61bb41c 2071
9c0a72f9
TG		 2072 r = link_carrier_gained(link);
2073 if (r < 0)
2074 return r;
a61bb41c 2075 } else if (carrier_lost) {
6a7a4e4d 2076 log_link_info(link, "Lost carrier");
a61bb41c 2077
9c0a72f9
TG		 2078 r = link_carrier_lost(link);
2079 if (r < 0)
a61bb41c 2080 return r;
9c0a72f9 2081
a61bb41c
TG		 2082 }
2083
2084 return 0;
dd3efc09 2085}
fe8db0c5 2086
e375dcde 2087static void link_update_operstate(Link *link) {
e331e246 2088 LinkOperationalState operstate;
e375dcde
TG		 2089 assert(link);
2090
2091 if (link->kernel_operstate == IF_OPER_DORMANT)
e331e246 2092 operstate = LINK_OPERSTATE_DORMANT;
a61bb41c 2093 else if (link_has_carrier(link)) {
e375dcde
TG		 2094 Address *address;
2095 uint8_t scope = RT_SCOPE_NOWHERE;
2096
2097 /* if we have carrier, check what addresses we have */
2098 LIST_FOREACH(addresses, address, link->addresses) {
81163121
TG		 2099 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
2100 continue;
2101
e375dcde
TG		 2102 if (address->scope < scope)
2103 scope = address->scope;
2104 }
2105
2106 if (scope < RT_SCOPE_SITE)
2107 /* universally accessible addresses found */
e331e246 2108 operstate = LINK_OPERSTATE_ROUTABLE;
e375dcde
TG		 2109 else if (scope < RT_SCOPE_HOST)
2110 /* only link or site local addresses found */
e331e246 2111 operstate = LINK_OPERSTATE_DEGRADED;
e375dcde
TG		 2112 else
2113 /* no useful addresses found */
e331e246 2114 operstate = LINK_OPERSTATE_CARRIER;
54cba0b1 2115 } else if (link->flags & IFF_UP)
e331e246 2116 operstate = LINK_OPERSTATE_NO_CARRIER;
54cba0b1 2117 else
e331e246
TG		 2118 operstate = LINK_OPERSTATE_OFF;
2119
2120 if (link->operstate != operstate) {
2121 link->operstate = operstate;
2122 link_send_changed(link, "OperationalState", NULL);
2123 }
e375dcde
TG		 2124}
2125
fe8db0c5 2126int link_save(Link *link) {
68a8723c 2127 _cleanup_free_ char *temp_path = NULL;
fe8db0c5 2128 _cleanup_fclose_ FILE *f = NULL;
e375dcde 2129 const char *admin_state, *oper_state;
fe8db0c5
TG		 2130 int r;
2131
2132 assert(link);
2133 assert(link->state_file);
68a8723c 2134 assert(link->lease_file);
bbf7c048
TG		 2135 assert(link->manager);
2136
e375dcde
TG		 2137 link_update_operstate(link);
2138
bbf7c048
TG		 2139 r = manager_save(link->manager);
2140 if (r < 0)
2141 return r;
fe8db0c5 2142
370e9930
TG		 2143 if (link->state == LINK_STATE_LINGER) {
2144 unlink(link->state_file);
2145 return 0;
2146 }
2147
deb2e523
TG		 2148 admin_state = link_state_to_string(link->state);
2149 assert(admin_state);
2150
e375dcde
TG		 2151 oper_state = link_operstate_to_string(link->operstate);
2152 assert(oper_state);
deb2e523 2153
fe8db0c5
TG		 2154 r = fopen_temporary(link->state_file, &f, &temp_path);
2155 if (r < 0)
6a7a4e4d 2156 goto fail;
fe8db0c5
TG		 2157
2158 fchmod(fileno(f), 0644);
2159
2160 fprintf(f,
2161 "# This is private data. Do not parse.\n"
deb2e523 2162 "ADMIN_STATE=%s\n"
6dcaa6f5
TG		 2163 "OPER_STATE=%s\n",
2164 admin_state, oper_state);
fe8db0c5 2165
bcb7a07e 2166 if (link->network) {
ea352b40
LP		 2167 char **address, **domain;
2168 bool space;
b0e39c82 2169
adc5b2e2
TG		 2170 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
2171
b0e39c82 2172 fputs("DNS=", f);
ea352b40
LP		 2173 space = false;
2174 STRV_FOREACH(address, link->network->dns) {
2175 if (space)
2176 fputc(' ', f);
2177 fputs(*address, f);
2178 space = true;
2179 }
d5314fff 2180
b0e39c82
TG		 2181 if (link->network->dhcp_dns &&
2182 link->dhcp_lease) {
2183 const struct in_addr *addresses;
2184
2185 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2186 if (r > 0) {
ea352b40
LP		 2187 if (space)
2188 fputc(' ', f);
b0e39c82 2189 serialize_in_addrs(f, addresses, r);
b0e39c82
TG		 2190 }
2191 }
2192
b0e39c82
TG		 2193 fputs("\n", f);
2194
2195 fprintf(f, "NTP=");
ea352b40
LP		 2196 space = false;
2197 STRV_FOREACH(address, link->network->ntp) {
2198 if (space)
2199 fputc(' ', f);
2200 fputs(*address, f);
2201 space = true;
2202 }
d5314fff 2203
b0e39c82
TG		 2204 if (link->network->dhcp_ntp &&
2205 link->dhcp_lease) {
2206 const struct in_addr *addresses;
2207
2208 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2209 if (r > 0) {
ea352b40
LP		 2210 if (space)
2211 fputc(' ', f);
b0e39c82 2212 serialize_in_addrs(f, addresses, r);
b0e39c82
TG		 2213 }
2214 }
2215
b0e39c82 2216 fputs("\n", f);
bd8f6538 2217
6192b846 2218 fprintf(f, "DOMAINS=");
ea352b40
LP		 2219 space = false;
2220 STRV_FOREACH(domain, link->network->domains) {
2221 if (space)
2222 fputc(' ', f);
2223 fputs(*domain, f);
2224 space = true;
2225 }
d5314fff 2226
ad0734e8 2227 if (link->network->dhcp_domains &&
9b4d1882
TG		 2228 link->dhcp_lease) {
2229 const char *domainname;
2230
2231 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
6192b846 2232 if (r >= 0) {
ea352b40
LP		 2233 if (space)
2234 fputc(' ', f);
6192b846 2235 fputs(domainname, f);
6192b846 2236 }
9b4d1882
TG		 2237 }
2238
6192b846
TG		 2239 fputs("\n", f);
2240
67272d15
TG		 2241 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2242 yes_no(link->network->wildcard_domain));
2243
3c9b8860
TG		 2244 fprintf(f, "LLMNR=%s\n",
2245 llmnr_support_to_string(link->network->llmnr));
bcb7a07e 2246 }
7374f9d8 2247
0d4ad91d
AR		 2248 if (!hashmap_isempty(link->bound_to_links)) {
2249 Link *carrier;
2250 Iterator i;
2251 bool space = false;
2252
2253 fputs("CARRIER_BOUND_TO=", f);
2254 HASHMAP_FOREACH(carrier, link->bound_to_links, i) {
2255 if (space)
2256 fputc(' ', f);
2257 fputs(carrier->ifname, f);
2258 space = true;
2259 }
2260
2261 fputs("\n", f);
2262 }
2263
2264 if (!hashmap_isempty(link->bound_by_links)) {
2265 Link *carrier;
2266 Iterator i;
2267 bool space = false;
2268
2269 fputs("CARRIER_BOUND_BY=", f);
0d4ad91d
AR		 2270 HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
2271 if (space)
2272 fputc(' ', f);
2273 fputs(carrier->ifname, f);
2274 space = true;
2275 }
2276
2277 fputs("\n", f);
2278 }
2279
fe8db0c5 2280 if (link->dhcp_lease) {
d9876a52
TG		 2281 assert(link->network);
2282
1dc24d5f 2283 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
fe8db0c5 2284 if (r < 0)
c2d6bd61 2285 goto fail;
fe8db0c5 2286
7374f9d8 2287 fprintf(f,
b0e39c82
TG		 2288 "DHCP_LEASE=%s\n",
2289 link->lease_file);
deb2e523 2290 } else
68a8723c 2291 unlink(link->lease_file);
fe8db0c5 2292
49699bac
SS		 2293 if (link->lldp) {
2294 assert(link->network);
2295
2296 r = sd_lldp_save(link->lldp, link->lldp_file);
2297 if (r < 0)
2298 goto fail;
2299
2300 fprintf(f,
2301 "LLDP_FILE=%s\n",
2302 link->lldp_file);
2303 } else
2304 unlink(link->lldp_file);
2305
c2d6bd61
LP		 2306 r = fflush_and_check(f);
2307 if (r < 0)
2308 goto fail;
fe8db0c5 2309
c2d6bd61 2310 if (rename(temp_path, link->state_file) < 0) {
fe8db0c5 2311 r = -errno;
c2d6bd61 2312 goto fail;
fe8db0c5
TG		 2313 }
2314
c2d6bd61 2315 return 0;
c2d6bd61 2316fail:
6a7a4e4d
LP		 2317 log_link_error_errno(link, r, "Failed to save link data to %s: %m", link->state_file);
2318 (void) unlink(link->state_file);
2319
2320 if (temp_path)
2321 (void) unlink(temp_path);
2322
fe8db0c5
TG		 2323 return r;
2324}
2325
2326static const char* const link_state_table[_LINK_STATE_MAX] = {
8434fd5c 2327 [LINK_STATE_PENDING] = "pending",
fe8db0c5
TG		 2328 [LINK_STATE_ENSLAVING] = "configuring",
2329 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2330 [LINK_STATE_SETTING_ROUTES] = "configuring",
2331 [LINK_STATE_CONFIGURED] = "configured",
57bd6899 2332 [LINK_STATE_UNMANAGED] = "unmanaged",
fe8db0c5 2333 [LINK_STATE_FAILED] = "failed",
370e9930 2334 [LINK_STATE_LINGER] = "linger",
fe8db0c5
TG		 2335};
2336
2337DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
e375dcde
TG		 2338
2339static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
d3df0e39
TG		 2340 [LINK_OPERSTATE_OFF] = "off",
2341 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
e375dcde
TG		 2342 [LINK_OPERSTATE_DORMANT] = "dormant",
2343 [LINK_OPERSTATE_CARRIER] = "carrier",
2344 [LINK_OPERSTATE_DEGRADED] = "degraded",
2345 [LINK_OPERSTATE_ROUTABLE] = "routable",
2346};
2347
2348DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
Unnamed repository; edit this file 'description' to name the repository.