]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/network/networkd-link.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
networkd: ipv4ll - drop unnecessary get_address()
[thirdparty/systemd.git] / src / network / networkd-link.c
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>
24 #include <unistd.h>
25
26 #include "networkd.h"
27 #include "networkd-netdev.h"
28 #include "libudev-private.h"
29 #include "udev-util.h"
30 #include "util.h"
31 #include "virt.h"
32 #include "bus-util.h"
33 #include "network-internal.h"
34 #include "conf-parser.h"
35
36 #include "network-util.h"
37 #include "dhcp-lease-internal.h"
38
39 static int ipv4ll_address_update(Link *link, bool deprecate);
40 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
41
42 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
43 _cleanup_link_unref_ Link *link = NULL;
44 uint16_t type;
45 const char *ifname;
46 int r, ifindex;
47
48 assert(manager);
49 assert(manager->links);
50 assert(message);
51 assert(ret);
52
53 r = sd_rtnl_message_get_type(message, &type);
54 if (r < 0)
55 return r;
56 else if (type != RTM_NEWLINK)
57 return -EINVAL;
58
59 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
60 if (r < 0)
61 return r;
62 else if (ifindex <= 0)
63 return -EINVAL;
64
65 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
66 if (r < 0)
67 return r;
68
69 link = new0(Link, 1);
70 if (!link)
71 return -ENOMEM;
72
73 link->n_ref = 1;
74 link->manager = manager;
75 link->state = LINK_STATE_INITIALIZING;
76 link->ifindex = ifindex;
77 link->ifname = strdup(ifname);
78 if (!link->ifname)
79 return -ENOMEM;
80
81 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
82 if (r < 0)
83 log_debug_link(link, "MAC address not found for new device, continuing without");
84
85 r = asprintf(&link->state_file, "/run/systemd/netif/links/%"PRIu64,
86 link->ifindex);
87 if (r < 0)
88 return -ENOMEM;
89
90 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%"PRIu64,
91 link->ifindex);
92 if (r < 0)
93 return -ENOMEM;
94
95 r = hashmap_put(manager->links, &link->ifindex, link);
96 if (r < 0)
97 return r;
98
99 *ret = link;
100 link = NULL;
101
102 return 0;
103 }
104
105 static void link_free(Link *link) {
106 Address *address;
107
108 if (!link)
109 return;
110
111 while ((address = link->addresses)) {
112 LIST_REMOVE(addresses, link->addresses, address);
113 address_free(address);
114 }
115
116 while ((address = link->pool_addresses)) {
117 LIST_REMOVE(addresses, link->pool_addresses, address);
118 address_free(address);
119 }
120
121 sd_dhcp_client_unref(link->dhcp_client);
122 sd_dhcp_lease_unref(link->dhcp_lease);
123
124 unlink(link->lease_file);
125 free(link->lease_file);
126
127 sd_ipv4ll_unref(link->ipv4ll);
128 sd_dhcp6_client_unref(link->dhcp6_client);
129 sd_icmp6_nd_unref(link->icmp6_router_discovery);
130
131 if (link->manager)
132 hashmap_remove(link->manager->links, &link->ifindex);
133
134 free(link->ifname);
135
136 unlink(link->state_file);
137 free(link->state_file);
138
139 udev_device_unref(link->udev_device);
140
141 free(link);
142 }
143
144 Link *link_unref(Link *link) {
145 if (link && (-- link->n_ref <= 0))
146 link_free(link);
147
148 return NULL;
149 }
150
151 Link *link_ref(Link *link) {
152 if (link)
153 assert_se(++ link->n_ref >= 2);
154
155 return link;
156 }
157
158 int link_get(Manager *m, int ifindex, Link **ret) {
159 Link *link;
160 uint64_t ifindex_64;
161
162 assert(m);
163 assert(m->links);
164 assert(ifindex);
165 assert(ret);
166
167 ifindex_64 = ifindex;
168 link = hashmap_get(m->links, &ifindex_64);
169 if (!link)
170 return -ENODEV;
171
172 *ret = link;
173
174 return 0;
175 }
176
177 void link_drop(Link *link) {
178 if (!link || link->state == LINK_STATE_LINGER)
179 return;
180
181 link->state = LINK_STATE_LINGER;
182
183 log_debug_link(link, "link removed");
184
185 link_unref(link);
186
187 return;
188 }
189
190 static void link_enter_unmanaged(Link *link) {
191 assert(link);
192
193 log_debug_link(link, "unmanaged");
194
195 link->state = LINK_STATE_UNMANAGED;
196
197 link_save(link);
198 }
199
200 static int link_stop_clients(Link *link) {
201 int r = 0, k;
202
203 assert(link);
204 assert(link->manager);
205 assert(link->manager->event);
206
207 if (!link->network)
208 return 0;
209
210 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
211 assert(link->dhcp_client);
212
213 k = sd_dhcp_client_stop(link->dhcp_client);
214 if (k < 0) {
215 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
216 r = k;
217 }
218 }
219
220 if (link->network->ipv4ll) {
221 assert(link->ipv4ll);
222
223 k = sd_ipv4ll_stop(link->ipv4ll);
224 if (k < 0) {
225 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
226 r = k;
227 }
228 }
229
230 if (link->network->dhcp_server) {
231 assert(link->dhcp_server);
232
233 k = sd_dhcp_server_stop(link->dhcp_server);
234 if (k < 0) {
235 log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
236 r = k;
237 }
238 }
239
240 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
241 assert(link->icmp6_router_discovery);
242
243 if (link->dhcp6_client) {
244 k = sd_dhcp6_client_stop(link->dhcp6_client);
245 if (k < 0) {
246 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
247 r = k;
248 }
249 }
250
251 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
252 if (k < 0) {
253 log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
254 r = k;
255 }
256 }
257
258 return r;
259 }
260
261 static void link_enter_failed(Link *link) {
262 assert(link);
263
264 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
265 return;
266
267 log_warning_link(link, "failed");
268
269 link->state = LINK_STATE_FAILED;
270
271 link_stop_clients(link);
272
273 link_save(link);
274 }
275
276 static Address* link_find_dhcp_server_address(Link *link) {
277 Address *address;
278
279 assert(link);
280 assert(link->network);
281
282 /* The the first statically configured address if there is any */
283 LIST_FOREACH(addresses, address, link->network->static_addresses) {
284
285 if (address->family != AF_INET)
286 continue;
287
288 if (in_addr_null(address->family, &address->in_addr))
289 continue;
290
291 return address;
292 }
293
294 /* If that didn't work, find a suitable address we got from the pool */
295 LIST_FOREACH(addresses, address, link->pool_addresses) {
296 if (address->family != AF_INET)
297 continue;
298
299 return address;
300 }
301
302 return NULL;
303 }
304
305 static int link_enter_configured(Link *link) {
306 int r;
307
308 assert(link);
309 assert(link->network);
310 assert(link->state == LINK_STATE_SETTING_ROUTES);
311
312 if (link->network->dhcp_server &&
313 !sd_dhcp_server_is_running(link->dhcp_server)) {
314 struct in_addr pool_start;
315 Address *address;
316
317 address = link_find_dhcp_server_address(link);
318 if (!address) {
319 log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
320 link_enter_failed(link);
321 return 0;
322 }
323
324 log_debug_link(link, "offering DHCPv4 leases");
325
326 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in);
327 if (r < 0)
328 return r;
329
330 /* offer 32 addresses starting from the address following the server address */
331 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
332 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
333 &pool_start, 32);
334 if (r < 0)
335 return r;
336
337 /* TODO:
338 r = sd_dhcp_server_set_router(link->dhcp_server,
339 &main_address->in_addr.in);
340 if (r < 0)
341 return r;
342
343 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
344 main_address->prefixlen);
345 if (r < 0)
346 return r;
347 */
348
349 r = sd_dhcp_server_start(link->dhcp_server);
350 if (r < 0) {
351 log_warning_link(link, "could not start DHCPv4 server "
352 "instance: %s", strerror(-r));
353
354 link_enter_failed(link);
355
356 return 0;
357 }
358 }
359
360 log_info_link(link, "link configured");
361
362 link->state = LINK_STATE_CONFIGURED;
363
364 link_save(link);
365
366 return 0;
367 }
368
369 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
370 _cleanup_link_unref_ Link *link = userdata;
371 int r;
372
373 assert(link->route_messages > 0);
374 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
375 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
376 LINK_STATE_LINGER));
377
378 link->route_messages --;
379
380 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER))
381 return 1;
382
383 r = sd_rtnl_message_get_errno(m);
384 if (r < 0 && r != -EEXIST)
385 log_struct_link(LOG_WARNING, link,
386 "MESSAGE=%-*s: could not set route: %s",
387 IFNAMSIZ,
388 link->ifname, strerror(-r),
389 "ERRNO=%d", -r,
390 NULL);
391
392 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
393 * ignore it */
394 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
395 log_debug_link(link, "routes set");
396 link_enter_configured(link);
397 }
398
399 return 1;
400 }
401
402 static int link_set_dhcp_routes(Link *link) {
403 struct sd_dhcp_route *static_routes;
404 int r, n, i;
405
406 assert(link);
407
408 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
409 if (n < 0) {
410 if (n != -ENOENT)
411 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-n));
412 return n;
413 }
414
415 for (i = 0; i < n; i++) {
416 _cleanup_route_free_ Route *route = NULL;
417
418 r = route_new_dynamic(&route, RTPROT_DHCP);
419 if (r < 0) {
420 log_error_link(link, "Could not allocate route: %s",
421 strerror(-r));
422 return r;
423 }
424
425 route->family = AF_INET;
426 route->in_addr.in = static_routes[i].gw_addr;
427 route->dst_addr.in = static_routes[i].dst_addr;
428 route->dst_prefixlen = static_routes[i].dst_prefixlen;
429 route->metrics = DHCP_ROUTE_METRIC;
430
431 r = route_configure(route, link, &route_handler);
432 if (r < 0) {
433 log_warning_link(link,
434 "could not set host route: %s", strerror(-r));
435 return r;
436 }
437
438 link->route_messages ++;
439 }
440
441 return 0;
442 }
443
444 static int link_enter_set_routes(Link *link) {
445 Route *rt;
446 int r;
447
448 assert(link);
449 assert(link->network);
450 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
451
452 link->state = LINK_STATE_SETTING_ROUTES;
453
454 if (!link->network->static_routes && !link->dhcp_lease &&
455 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
456 return link_enter_configured(link);
457
458 log_debug_link(link, "setting routes");
459
460 LIST_FOREACH(routes, rt, link->network->static_routes) {
461 r = route_configure(rt, link, &route_handler);
462 if (r < 0) {
463 log_warning_link(link,
464 "could not set routes: %s", strerror(-r));
465 link_enter_failed(link);
466 return r;
467 }
468
469 link->route_messages ++;
470 }
471
472 if (link->ipv4ll && !link->dhcp_lease) {
473 _cleanup_route_free_ Route *route = NULL;
474
475 if (r != -ENOENT) {
476 r = route_new_dynamic(&route, RTPROT_STATIC);
477 if (r < 0) {
478 log_error_link(link, "Could not allocate route: %s",
479 strerror(-r));
480 return r;
481 }
482
483 route->family = AF_INET;
484 route->scope = RT_SCOPE_LINK;
485 route->metrics = IPV4LL_ROUTE_METRIC;
486
487 r = route_configure(route, link, &route_handler);
488 if (r < 0) {
489 log_warning_link(link,
490 "could not set routes: %s", strerror(-r));
491 link_enter_failed(link);
492 return r;
493 }
494
495 link->route_messages ++;
496 }
497 }
498
499 if (link->dhcp_lease) {
500 _cleanup_route_free_ Route *route = NULL;
501 _cleanup_route_free_ Route *route_gw = NULL;
502 struct in_addr gateway;
503
504 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
505 if (r < 0 && r != -ENOENT) {
506 log_warning_link(link, "DHCP error: could not get gateway: %s",
507 strerror(-r));
508 return r;
509 }
510
511 if (r >= 0) {
512 r = route_new_dynamic(&route, RTPROT_DHCP);
513 if (r < 0) {
514 log_error_link(link, "Could not allocate route: %s",
515 strerror(-r));
516 return r;
517 }
518
519 r = route_new_dynamic(&route_gw, RTPROT_DHCP);
520 if (r < 0) {
521 log_error_link(link, "Could not allocate route: %s",
522 strerror(-r));
523 return r;
524 }
525
526 /* The dhcp netmask may mask out the gateway. Add an explicit
527 * route for the gw host so that we can route no matter the
528 * netmask or existing kernel route tables. */
529 route_gw->family = AF_INET;
530 route_gw->dst_addr.in = gateway;
531 route_gw->dst_prefixlen = 32;
532 route_gw->scope = RT_SCOPE_LINK;
533 route_gw->metrics = DHCP_ROUTE_METRIC;
534
535 r = route_configure(route_gw, link, &route_handler);
536 if (r < 0) {
537 log_warning_link(link,
538 "could not set host route: %s", strerror(-r));
539 return r;
540 }
541
542 link->route_messages ++;
543
544 route->family = AF_INET;
545 route->in_addr.in = gateway;
546 route->metrics = DHCP_ROUTE_METRIC;
547
548 r = route_configure(route, link, &route_handler);
549 if (r < 0) {
550 log_warning_link(link,
551 "could not set routes: %s", strerror(-r));
552 link_enter_failed(link);
553 return r;
554 }
555
556 link->route_messages ++;
557 }
558
559 if (link->network->dhcp_routes)
560 link_set_dhcp_routes(link);
561 }
562
563 if (link->route_messages == 0) {
564 link_enter_configured(link);
565 }
566
567 return 0;
568 }
569
570 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
571 _cleanup_link_unref_ Link *link = userdata;
572 int r;
573
574 assert(m);
575 assert(link);
576 assert(link->ifname);
577
578 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
579 return 1;
580
581 r = sd_rtnl_message_get_errno(m);
582 if (r < 0 && r != -ESRCH)
583 log_struct_link(LOG_WARNING, link,
584 "MESSAGE=%-*s: could not drop route: %s",
585 IFNAMSIZ,
586 link->ifname, strerror(-r),
587 "ERRNO=%d", -r,
588 NULL);
589
590 return 1;
591 }
592
593 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
594 _cleanup_link_unref_ Link *link = userdata;
595 int r;
596
597 assert(rtnl);
598 assert(m);
599 assert(link);
600 assert(link->manager);
601
602 for (; m; m = sd_rtnl_message_next(m)) {
603 r = sd_rtnl_message_get_errno(m);
604 if (r < 0) {
605 log_debug_link(link, "getting address failed: %s", strerror(-r));
606 continue;
607 }
608
609 r = link_rtnl_process_address(rtnl, m, link->manager);
610 if (r < 0)
611 log_warning_link(link, "could not process address: %s", strerror(-r));
612 }
613
614 return 1;
615 }
616
617 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
618 _cleanup_link_unref_ Link *link = userdata;
619 int r;
620
621 assert(rtnl);
622 assert(m);
623 assert(link);
624 assert(link->ifname);
625 assert(link->addr_messages > 0);
626 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
627 LINK_STATE_FAILED, LINK_STATE_LINGER));
628
629 link->addr_messages --;
630
631 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
632 return 1;
633
634 r = sd_rtnl_message_get_errno(m);
635 if (r < 0 && r != -EEXIST)
636 log_struct_link(LOG_WARNING, link,
637 "MESSAGE=%-*s: could not set address: %s",
638 IFNAMSIZ,
639 link->ifname, strerror(-r),
640 "ERRNO=%d", -r,
641 NULL);
642 else if (r >= 0) {
643 /* calling handler directly so take a ref */
644 link_ref(link);
645 link_get_address_handler(rtnl, m, link);
646 }
647
648 if (link->addr_messages == 0) {
649 log_debug_link(link, "addresses set");
650 link_enter_set_routes(link);
651 }
652
653 return 1;
654 }
655
656 static int link_enter_set_addresses(Link *link) {
657 Address *ad;
658 int r;
659 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
660
661 assert(link);
662 assert(link->network);
663 assert(link->state != _LINK_STATE_INVALID);
664
665 link->state = LINK_STATE_SETTING_ADDRESSES;
666
667 if (!link->network->static_addresses && !link->dhcp_lease &&
668 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
669 return link_enter_set_routes(link);
670
671 log_debug_link(link, "setting addresses");
672
673 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
674 r = address_configure(ad, link, &address_handler);
675 if (r < 0) {
676 log_warning_link(link,
677 "could not set addresses: %s", strerror(-r));
678 link_enter_failed(link);
679 return r;
680 }
681
682 link->addr_messages ++;
683 }
684
685 if (link->ipv4ll && !link->dhcp_lease) {
686 _cleanup_address_free_ Address *ll_addr = NULL;
687 struct in_addr addr;
688
689 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
690 if (r < 0 && r != -ENOENT) {
691 log_warning_link(link, "IPV4LL error: no address: %s",
692 strerror(-r));
693 return r;
694 }
695
696 if (r != -ENOENT) {
697 r = address_new_dynamic(&ll_addr);
698 if (r < 0) {
699 log_error_link(link, "Could not allocate address: %s", strerror(-r));
700 return r;
701 }
702
703 ll_addr->family = AF_INET;
704 ll_addr->in_addr.in = addr;
705 ll_addr->prefixlen = 16;
706 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
707 ll_addr->scope = RT_SCOPE_LINK;
708
709 r = address_configure(ll_addr, link, &address_handler);
710 if (r < 0) {
711 log_warning_link(link,
712 "could not set addresses: %s", strerror(-r));
713 link_enter_failed(link);
714 return r;
715 }
716
717 link->addr_messages ++;
718 }
719 }
720
721 if (link->dhcp_lease) {
722 _cleanup_address_free_ Address *address = NULL;
723 struct in_addr addr;
724 struct in_addr netmask;
725 unsigned prefixlen;
726
727 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
728 if (r < 0) {
729 log_warning_link(link, "DHCP error: no address: %s",
730 strerror(-r));
731 return r;
732 }
733
734 if (!link->network->dhcp_critical) {
735 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
736 &lifetime);
737 if (r < 0) {
738 log_warning_link(link, "DHCP error: no lifetime: %s",
739 strerror(-r));
740 return r;
741 }
742 }
743
744 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
745 if (r < 0) {
746 log_warning_link(link, "DHCP error: no netmask: %s",
747 strerror(-r));
748 return r;
749 }
750
751 prefixlen = net_netmask_to_prefixlen(&netmask);
752
753 r = address_new_dynamic(&address);
754 if (r < 0) {
755 log_error_link(link, "Could not allocate address: %s",
756 strerror(-r));
757 return r;
758 }
759
760 address->family = AF_INET;
761 address->in_addr.in = addr;
762 address->cinfo.ifa_prefered = lifetime;
763 address->cinfo.ifa_valid = lifetime;
764 address->prefixlen = prefixlen;
765 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
766
767 /* use update rather than configure so that we will update the lifetime
768 of an existing address if it has already been configured */
769 r = address_update(address, link, &address_handler);
770 if (r < 0) {
771 log_warning_link(link,
772 "could not set addresses: %s", strerror(-r));
773 link_enter_failed(link);
774 return r;
775 }
776
777 link->addr_messages ++;
778 }
779
780 return 0;
781 }
782
783 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
784 _cleanup_link_unref_ Link *link = userdata;
785 int r;
786
787 assert(m);
788 assert(link);
789 assert(link->ifname);
790
791 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
792 return 1;
793
794 r = sd_rtnl_message_get_errno(m);
795 if (r < 0 && r != -ENOENT)
796 log_struct_link(LOG_WARNING, link,
797 "MESSAGE=%-*s: could not update address: %s",
798 IFNAMSIZ,
799 link->ifname, strerror(-r),
800 "ERRNO=%d", -r,
801 NULL);
802
803 return 1;
804 }
805
806 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
807 _cleanup_link_unref_ Link *link = userdata;
808 int r;
809
810 assert(m);
811 assert(link);
812 assert(link->ifname);
813
814 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
815 return 1;
816
817 r = sd_rtnl_message_get_errno(m);
818 if (r < 0 && r != -EADDRNOTAVAIL)
819 log_struct_link(LOG_WARNING, link,
820 "MESSAGE=%-*s: could not drop address: %s",
821 IFNAMSIZ,
822 link->ifname, strerror(-r),
823 "ERRNO=%d", -r,
824 NULL);
825
826 return 1;
827 }
828
829 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
830 _cleanup_link_unref_ Link *link = userdata;
831 int r;
832
833 assert(link);
834
835 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
836 return 1;
837
838 r = sd_bus_message_get_errno(m);
839 if (r < 0)
840 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
841
842 return 1;
843 }
844
845 static int link_set_hostname(Link *link, const char *hostname) {
846 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
847 int r = 0;
848
849 assert(link);
850 assert(link->manager);
851 assert(hostname);
852
853 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
854
855 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
856 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
857 return 0;
858 }
859
860 r = sd_bus_message_new_method_call(
861 link->manager->bus,
862 &m,
863 "org.freedesktop.hostname1",
864 "/org/freedesktop/hostname1",
865 "org.freedesktop.hostname1",
866 "SetHostname");
867 if (r < 0)
868 return r;
869
870 r = sd_bus_message_append(m, "sb", hostname, false);
871 if (r < 0)
872 return r;
873
874 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
875 if (r < 0) {
876 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
877 return r;
878 }
879
880 link_ref(link);
881
882 return 0;
883 }
884
885 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
886 _cleanup_link_unref_ Link *link = userdata;
887 int r;
888
889 assert(m);
890 assert(link);
891 assert(link->ifname);
892
893 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
894 return 1;
895
896 r = sd_rtnl_message_get_errno(m);
897 if (r < 0)
898 log_struct_link(LOG_WARNING, link,
899 "MESSAGE=%-*s: could not set MTU: %s",
900 IFNAMSIZ, link->ifname, strerror(-r),
901 "ERRNO=%d", -r,
902 NULL);
903
904 return 1;
905 }
906
907 static int link_set_mtu(Link *link, uint32_t mtu) {
908 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
909 int r;
910
911 assert(link);
912 assert(link->manager);
913 assert(link->manager->rtnl);
914
915 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
916
917 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
918 RTM_SETLINK, link->ifindex);
919 if (r < 0) {
920 log_error_link(link, "Could not allocate RTM_SETLINK message");
921 return r;
922 }
923
924 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
925 if (r < 0) {
926 log_error_link(link, "Could not append MTU: %s", strerror(-r));
927 return r;
928 }
929
930 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
931 if (r < 0) {
932 log_error_link(link,
933 "Could not send rtnetlink message: %s", strerror(-r));
934 return r;
935 }
936
937 link_ref(link);
938
939 return 0;
940 }
941
942 static int dhcp_lease_lost(Link *link) {
943 _cleanup_address_free_ Address *address = NULL;
944 struct in_addr addr;
945 struct in_addr netmask;
946 struct in_addr gateway;
947 unsigned prefixlen;
948 int r;
949
950 assert(link);
951 assert(link->dhcp_lease);
952
953 log_warning_link(link, "DHCP lease lost");
954
955 if (link->network->dhcp_routes) {
956 struct sd_dhcp_route *routes;
957 int n, i;
958
959 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
960 if (n >= 0) {
961 for (i = 0; i < n; i++) {
962 _cleanup_route_free_ Route *route = NULL;
963
964 r = route_new_dynamic(&route, RTPROT_UNSPEC);
965 if (r >= 0) {
966 route->family = AF_INET;
967 route->in_addr.in = routes[i].gw_addr;
968 route->dst_addr.in = routes[i].dst_addr;
969 route->dst_prefixlen = routes[i].dst_prefixlen;
970
971 route_drop(route, link, &route_drop_handler);
972 }
973 }
974 }
975 }
976
977 r = address_new_dynamic(&address);
978 if (r >= 0) {
979 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
980 if (r >= 0) {
981 _cleanup_route_free_ Route *route_gw = NULL;
982 _cleanup_route_free_ Route *route = NULL;
983
984 r = route_new_dynamic(&route_gw, RTPROT_UNSPEC);
985 if (r >= 0) {
986 route_gw->family = AF_INET;
987 route_gw->dst_addr.in = gateway;
988 route_gw->dst_prefixlen = 32;
989 route_gw->scope = RT_SCOPE_LINK;
990
991 route_drop(route_gw, link, &route_drop_handler);
992 }
993
994 r = route_new_dynamic(&route, RTPROT_UNSPEC);
995 if (r >= 0) {
996 route->family = AF_INET;
997 route->in_addr.in = gateway;
998
999 route_drop(route, link, &route_drop_handler);
1000 }
1001 }
1002
1003 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1004 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1005 prefixlen = net_netmask_to_prefixlen(&netmask);
1006
1007 address->family = AF_INET;
1008 address->in_addr.in = addr;
1009 address->prefixlen = prefixlen;
1010
1011 address_drop(address, link, &address_drop_handler);
1012 }
1013
1014 if (link->network->dhcp_mtu) {
1015 uint16_t mtu;
1016
1017 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1018 if (r >= 0 && link->original_mtu != mtu) {
1019 r = link_set_mtu(link, link->original_mtu);
1020 if (r < 0) {
1021 log_warning_link(link, "DHCP error: could not reset MTU");
1022 link_enter_failed(link);
1023 return r;
1024 }
1025 }
1026 }
1027
1028 if (link->network->dhcp_hostname) {
1029 const char *hostname = NULL;
1030
1031 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1032 if (r >= 0 && hostname) {
1033 r = link_set_hostname(link, "");
1034 if (r < 0)
1035 log_error_link(link, "Failed to reset transient hostname");
1036 }
1037 }
1038
1039 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1040
1041 return 0;
1042 }
1043
1044 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1045 sd_dhcp_lease *lease;
1046 int r;
1047
1048 r = sd_dhcp_client_get_lease(client, &lease);
1049 if (r < 0) {
1050 log_warning_link(link, "DHCP error: no lease %s",
1051 strerror(-r));
1052 return r;
1053 }
1054
1055 sd_dhcp_lease_unref(link->dhcp_lease);
1056 link->dhcp_lease = lease;
1057
1058 link_enter_set_addresses(link);
1059
1060 return 0;
1061 }
1062
1063 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1064 sd_dhcp_lease *lease;
1065 struct in_addr address;
1066 struct in_addr netmask;
1067 struct in_addr gateway;
1068 unsigned prefixlen;
1069 int r;
1070
1071 assert(client);
1072 assert(link);
1073
1074 r = sd_dhcp_client_get_lease(client, &lease);
1075 if (r < 0) {
1076 log_warning_link(link, "DHCP error: no lease: %s",
1077 strerror(-r));
1078 return r;
1079 }
1080
1081 r = sd_dhcp_lease_get_address(lease, &address);
1082 if (r < 0) {
1083 log_warning_link(link, "DHCP error: no address: %s",
1084 strerror(-r));
1085 return r;
1086 }
1087
1088 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1089 if (r < 0) {
1090 log_warning_link(link, "DHCP error: no netmask: %s",
1091 strerror(-r));
1092 return r;
1093 }
1094
1095 prefixlen = net_netmask_to_prefixlen(&netmask);
1096
1097 r = sd_dhcp_lease_get_router(lease, &gateway);
1098 if (r < 0 && r != -ENOENT) {
1099 log_warning_link(link, "DHCP error: could not get gateway: %s",
1100 strerror(-r));
1101 return r;
1102 }
1103
1104 if (r >= 0)
1105 log_struct_link(LOG_INFO, link,
1106 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1107 IFNAMSIZ,
1108 link->ifname,
1109 ADDRESS_FMT_VAL(address),
1110 prefixlen,
1111 ADDRESS_FMT_VAL(gateway),
1112 "ADDRESS=%u.%u.%u.%u",
1113 ADDRESS_FMT_VAL(address),
1114 "PREFIXLEN=%u",
1115 prefixlen,
1116 "GATEWAY=%u.%u.%u.%u",
1117 ADDRESS_FMT_VAL(gateway),
1118 NULL);
1119 else
1120 log_struct_link(LOG_INFO, link,
1121 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1122 IFNAMSIZ,
1123 link->ifname,
1124 ADDRESS_FMT_VAL(address),
1125 prefixlen,
1126 "ADDRESS=%u.%u.%u.%u",
1127 ADDRESS_FMT_VAL(address),
1128 "PREFIXLEN=%u",
1129 prefixlen,
1130 NULL);
1131
1132 link->dhcp_lease = lease;
1133
1134 if (link->network->dhcp_mtu) {
1135 uint16_t mtu;
1136
1137 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1138 if (r >= 0) {
1139 r = link_set_mtu(link, mtu);
1140 if (r < 0)
1141 log_error_link(link, "Failed to set MTU "
1142 "to %" PRIu16, mtu);
1143 }
1144 }
1145
1146 if (link->network->dhcp_hostname) {
1147 const char *hostname;
1148
1149 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1150 if (r >= 0) {
1151 r = link_set_hostname(link, hostname);
1152 if (r < 0)
1153 log_error_link(link, "Failed to set transient hostname "
1154 "to '%s'", hostname);
1155 }
1156 }
1157
1158 link_enter_set_addresses(link);
1159
1160 return 0;
1161 }
1162
1163 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1164 Link *link = userdata;
1165 int r = 0;
1166
1167 assert(link);
1168 assert(link->network);
1169 assert(link->manager);
1170
1171 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1172 return;
1173
1174 switch (event) {
1175 case DHCP_EVENT_NO_LEASE:
1176 log_debug_link(link, "IP address in use.");
1177 break;
1178 case DHCP_EVENT_EXPIRED:
1179 case DHCP_EVENT_STOP:
1180 case DHCP_EVENT_IP_CHANGE:
1181 if (link->network->dhcp_critical) {
1182 log_error_link(link, "DHCPv4 connection considered system critical, "
1183 "ignoring request to reconfigure it.");
1184 return;
1185 }
1186
1187 if (link->dhcp_lease) {
1188 r = dhcp_lease_lost(link);
1189 if (r < 0) {
1190 link_enter_failed(link);
1191 return;
1192 }
1193 }
1194
1195 if (event == DHCP_EVENT_IP_CHANGE) {
1196 r = dhcp_lease_acquired(client, link);
1197 if (r < 0) {
1198 link_enter_failed(link);
1199 return;
1200 }
1201 }
1202
1203 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1204 if (!sd_ipv4ll_is_running(link->ipv4ll))
1205 r = sd_ipv4ll_start(link->ipv4ll);
1206 else if (ipv4ll_is_bound(link->ipv4ll))
1207 r = ipv4ll_address_update(link, false);
1208 if (r < 0) {
1209 link_enter_failed(link);
1210 return;
1211 }
1212 }
1213
1214 break;
1215 case DHCP_EVENT_RENEW:
1216 r = dhcp_lease_renew(client, link);
1217 if (r < 0) {
1218 link_enter_failed(link);
1219 return;
1220 }
1221 break;
1222 case DHCP_EVENT_IP_ACQUIRE:
1223 r = dhcp_lease_acquired(client, link);
1224 if (r < 0) {
1225 link_enter_failed(link);
1226 return;
1227 }
1228 if (link->ipv4ll) {
1229 if (ipv4ll_is_bound(link->ipv4ll))
1230 r = ipv4ll_address_update(link, true);
1231 else
1232 r = sd_ipv4ll_stop(link->ipv4ll);
1233 if (r < 0) {
1234 link_enter_failed(link);
1235 return;
1236 }
1237 }
1238 break;
1239 default:
1240 if (event < 0)
1241 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1242 else
1243 log_warning_link(link, "DHCP unknown event: %d", event);
1244 break;
1245 }
1246
1247 return;
1248 }
1249
1250 static int ipv4ll_address_update(Link *link, bool deprecate) {
1251 int r;
1252 struct in_addr addr;
1253
1254 assert(link);
1255
1256 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1257 if (r >= 0) {
1258 _cleanup_address_free_ Address *address = NULL;
1259
1260 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1261 deprecate ? "deprecate" : "approve",
1262 ADDRESS_FMT_VAL(addr));
1263
1264 r = address_new_dynamic(&address);
1265 if (r < 0) {
1266 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1267 return r;
1268 }
1269
1270 address->family = AF_INET;
1271 address->in_addr.in = addr;
1272 address->prefixlen = 16;
1273 address->scope = RT_SCOPE_LINK;
1274 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1275 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1276
1277 address_update(address, link, &address_update_handler);
1278 }
1279
1280 return 0;
1281
1282 }
1283
1284 static int ipv4ll_address_lost(Link *link) {
1285 int r;
1286 struct in_addr addr;
1287
1288 assert(link);
1289
1290 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1291 if (r >= 0) {
1292 _cleanup_address_free_ Address *address = NULL;
1293 _cleanup_route_free_ Route *route = NULL;
1294
1295 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1296 ADDRESS_FMT_VAL(addr));
1297
1298 r = address_new_dynamic(&address);
1299 if (r < 0) {
1300 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1301 return r;
1302 }
1303
1304 address->family = AF_INET;
1305 address->in_addr.in = addr;
1306 address->prefixlen = 16;
1307 address->scope = RT_SCOPE_LINK;
1308
1309 address_drop(address, link, &address_drop_handler);
1310
1311 r = route_new_dynamic(&route, RTPROT_UNSPEC);
1312 if (r < 0) {
1313 log_error_link(link, "Could not allocate route: %s",
1314 strerror(-r));
1315 return r;
1316 }
1317
1318 route->family = AF_INET;
1319 route->scope = RT_SCOPE_LINK;
1320 route->metrics = 99;
1321
1322 route_drop(route, link, &route_drop_handler);
1323 }
1324
1325 return 0;
1326 }
1327
1328 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1329 int r;
1330 struct in_addr addr;
1331
1332 assert(ll);
1333
1334 r = sd_ipv4ll_get_address(ll, &addr);
1335 if (r < 0)
1336 return false;
1337 return true;
1338 }
1339
1340 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1341 struct in_addr address;
1342 int r;
1343
1344 assert(ll);
1345 assert(link);
1346
1347 r = sd_ipv4ll_get_address(ll, &address);
1348 if (r < 0)
1349 return r;
1350
1351 log_struct_link(LOG_INFO, link,
1352 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1353 IFNAMSIZ,
1354 link->ifname,
1355 ADDRESS_FMT_VAL(address),
1356 NULL);
1357
1358 link_enter_set_addresses(link);
1359
1360 return 0;
1361 }
1362
1363 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1364 Link *link = userdata;
1365 int r;
1366
1367 assert(link);
1368 assert(link->network);
1369 assert(link->manager);
1370
1371 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1372 return;
1373
1374 switch(event) {
1375 case IPV4LL_EVENT_STOP:
1376 case IPV4LL_EVENT_CONFLICT:
1377 r = ipv4ll_address_lost(link);
1378 if (r < 0) {
1379 link_enter_failed(link);
1380 return;
1381 }
1382 break;
1383 case IPV4LL_EVENT_BIND:
1384 r = ipv4ll_address_claimed(ll, link);
1385 if (r < 0) {
1386 link_enter_failed(link);
1387 return;
1388 }
1389 break;
1390 default:
1391 if (event < 0)
1392 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1393 else
1394 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1395 break;
1396 }
1397 }
1398
1399 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1400 Link *link = userdata;
1401
1402 assert(link);
1403 assert(link->network);
1404 assert(link->manager);
1405
1406 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1407 return;
1408
1409 switch(event) {
1410 case DHCP6_EVENT_STOP:
1411 case DHCP6_EVENT_RESEND_EXPIRE:
1412 case DHCP6_EVENT_RETRANS_MAX:
1413 case DHCP6_EVENT_IP_ACQUIRE:
1414 log_debug_link(link, "DHCPv6 event %d", event);
1415
1416 break;
1417
1418 default:
1419 if (event < 0)
1420 log_warning_link(link, "DHCPv6 error: %s",
1421 strerror(-event));
1422 else
1423 log_warning_link(link, "DHCPv6 unknown event: %d",
1424 event);
1425 return;
1426 }
1427 }
1428
1429 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1430 Link *link = userdata;
1431 int r;
1432
1433 assert(link);
1434 assert(link->network);
1435 assert(link->manager);
1436
1437 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1438 return;
1439
1440 switch(event) {
1441 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1442 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1443 return;
1444
1445 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1446 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1447 break;
1448
1449 default:
1450 if (event < 0)
1451 log_warning_link(link, "ICMPv6 error: %s",
1452 strerror(-event));
1453 else
1454 log_warning_link(link, "ICMPv6 unknown event: %d",
1455 event);
1456
1457 return;
1458 }
1459
1460 if (link->dhcp6_client)
1461 return;
1462
1463 r = sd_dhcp6_client_new(&link->dhcp6_client);
1464 if (r < 0)
1465 return;
1466
1467 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1468 if (r < 0) {
1469 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1470 return;
1471 }
1472
1473 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1474 if (r < 0) {
1475 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1476 return;
1477 }
1478
1479 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1480 if (r < 0) {
1481 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1482 return;
1483 }
1484
1485 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1486 link);
1487 if (r < 0) {
1488 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1489 return;
1490 }
1491
1492 r = sd_dhcp6_client_start(link->dhcp6_client);
1493 if (r < 0)
1494 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1495 }
1496
1497 static int link_acquire_conf(Link *link) {
1498 int r;
1499
1500 assert(link);
1501 assert(link->network);
1502 assert(link->manager);
1503 assert(link->manager->event);
1504
1505 if (link->network->ipv4ll) {
1506 assert(link->ipv4ll);
1507
1508 log_debug_link(link, "acquiring IPv4 link-local address");
1509
1510 r = sd_ipv4ll_start(link->ipv4ll);
1511 if (r < 0) {
1512 log_warning_link(link, "could not acquire IPv4 "
1513 "link-local address");
1514 return r;
1515 }
1516 }
1517
1518 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1519 assert(link->dhcp_client);
1520
1521 log_debug_link(link, "acquiring DHCPv4 lease");
1522
1523 r = sd_dhcp_client_start(link->dhcp_client);
1524 if (r < 0) {
1525 log_warning_link(link, "could not acquire DHCPv4 "
1526 "lease");
1527 return r;
1528 }
1529 }
1530
1531 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1532 assert(link->icmp6_router_discovery);
1533
1534 log_debug_link(link, "discovering IPv6 routers");
1535
1536 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1537 if (r < 0) {
1538 log_warning_link(link, "could not start IPv6 router discovery");
1539 return r;
1540 }
1541 }
1542
1543 return 0;
1544 }
1545
1546 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1547 /* see Documentation/networking/operstates.txt in the kernel sources */
1548
1549 if (operstate == IF_OPER_UP)
1550 return true;
1551
1552 if (operstate == IF_OPER_UNKNOWN)
1553 /* operstate may not be implemented, so fall back to flags */
1554 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1555 return true;
1556
1557 return false;
1558 }
1559
1560 #define FLAG_STRING(string, flag, old, new) \
1561 (((old ^ new) & flag) \
1562 ? ((old & flag) ? (" -" string) : (" +" string)) \
1563 : "")
1564
1565 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1566 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1567 uint8_t operstate;
1568 bool carrier_gained = false, carrier_lost = false;
1569 int r;
1570
1571 assert(link);
1572
1573 r = sd_rtnl_message_link_get_flags(m, &flags);
1574 if (r < 0) {
1575 log_warning_link(link, "Could not get link flags");
1576 return r;
1577 }
1578
1579 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1580 if (r < 0)
1581 /* if we got a message without operstate, take it to mean
1582 the state was unchanged */
1583 operstate = link->kernel_operstate;
1584
1585 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1586 return 0;
1587
1588 if (link->flags != flags) {
1589 log_debug_link(link, "flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
1590 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1591 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1592 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1593 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1594 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1595 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1596 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1597 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1598 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1599 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1600 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1601 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1602 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1603 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1604 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1605 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1606 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1607 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1608 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1609
1610 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1611 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1612 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1613 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1614 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1615 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1616 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1617 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1618
1619 /* link flags are currently at most 18 bits, let's align to printing 20 */
1620 if (unknown_flags_added)
1621 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1622 unknown_flags_added);
1623
1624 if (unknown_flags_removed)
1625 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1626 unknown_flags_removed);
1627 }
1628
1629 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1630 link_has_carrier(flags, operstate);
1631 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1632 !link_has_carrier(flags, operstate);
1633
1634 link->flags = flags;
1635 link->kernel_operstate = operstate;
1636
1637 link_save(link);
1638
1639 if (link->state == LINK_STATE_FAILED ||
1640 link->state == LINK_STATE_UNMANAGED)
1641 return 0;
1642
1643 if (carrier_gained) {
1644 log_info_link(link, "gained carrier");
1645
1646 if (link->network) {
1647 r = link_acquire_conf(link);
1648 if (r < 0) {
1649 link_enter_failed(link);
1650 return r;
1651 }
1652 }
1653 } else if (carrier_lost) {
1654 log_info_link(link, "lost carrier");
1655
1656 r = link_stop_clients(link);
1657 if (r < 0) {
1658 link_enter_failed(link);
1659 return r;
1660 }
1661 }
1662
1663 return 0;
1664 }
1665
1666 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1667 _cleanup_link_unref_ Link *link = userdata;
1668 int r;
1669
1670 assert(link);
1671
1672 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1673 return 1;
1674
1675 r = sd_rtnl_message_get_errno(m);
1676 if (r < 0) {
1677 /* we warn but don't fail the link, as it may
1678 be brought up later */
1679 log_struct_link(LOG_WARNING, link,
1680 "MESSAGE=%-*s: could not bring up interface: %s",
1681 IFNAMSIZ,
1682 link->ifname, strerror(-r),
1683 "ERRNO=%d", -r,
1684 NULL);
1685 }
1686
1687 return 1;
1688 }
1689
1690 static int link_up(Link *link) {
1691 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1692 int r;
1693
1694 assert(link);
1695 assert(link->manager);
1696 assert(link->manager->rtnl);
1697
1698 log_debug_link(link, "bringing link up");
1699
1700 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1701 RTM_SETLINK, link->ifindex);
1702 if (r < 0) {
1703 log_error_link(link, "Could not allocate RTM_SETLINK message");
1704 return r;
1705 }
1706
1707 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1708 if (r < 0) {
1709 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1710 return r;
1711 }
1712
1713 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1714 if (r < 0) {
1715 log_error_link(link,
1716 "Could not send rtnetlink message: %s", strerror(-r));
1717 return r;
1718 }
1719
1720 link_ref(link);
1721
1722 return 0;
1723 }
1724
1725 static int link_joined(Link *link) {
1726 int r;
1727
1728 assert(link);
1729 assert(link->state == LINK_STATE_ENSLAVING);
1730 assert(link->network);
1731
1732 log_debug_link(link, "joined netdev");
1733
1734 if (!(link->flags & IFF_UP)) {
1735 r = link_up(link);
1736 if (r < 0) {
1737 link_enter_failed(link);
1738 return r;
1739 }
1740 }
1741
1742 return link_enter_set_addresses(link);
1743 }
1744
1745 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1746 _cleanup_link_unref_ Link *link = userdata;
1747 int r;
1748
1749 assert(link);
1750 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1751 LINK_STATE_LINGER));
1752 assert(link->network);
1753
1754 link->enslaving --;
1755
1756 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1757 return 1;
1758
1759 r = sd_rtnl_message_get_errno(m);
1760 if (r < 0 && r != -EEXIST) {
1761 log_struct_link(LOG_ERR, link,
1762 "MESSAGE=%-*s: could not join netdev: %s",
1763 IFNAMSIZ,
1764 link->ifname, strerror(-r),
1765 "ERRNO=%d", -r,
1766 NULL);
1767 link_enter_failed(link);
1768 return 1;
1769 }
1770
1771 if (link->enslaving <= 0)
1772 link_joined(link);
1773
1774 return 1;
1775 }
1776
1777 static int link_enter_join_netdev(Link *link) {
1778 NetDev *vlan, *macvlan, *vxlan;
1779 Iterator i;
1780 int r;
1781
1782 assert(link);
1783 assert(link->network);
1784 assert(link->state == LINK_STATE_INITIALIZING);
1785
1786 link->state = LINK_STATE_ENSLAVING;
1787
1788 link_save(link);
1789
1790 if (!link->network->bridge &&
1791 !link->network->bond &&
1792 !link->network->tunnel &&
1793 hashmap_isempty(link->network->vlans) &&
1794 hashmap_isempty(link->network->macvlans) &&
1795 hashmap_isempty(link->network->vxlans))
1796 return link_joined(link);
1797
1798 if (link->network->bond) {
1799 log_struct_link(LOG_DEBUG, link,
1800 "MESSAGE=%-*s: enslaving by '%s'",
1801 IFNAMSIZ,
1802 link->ifname, link->network->bond->ifname,
1803 NETDEVIF(link->network->bond),
1804 NULL);
1805
1806 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1807 if (r < 0) {
1808 log_struct_link(LOG_WARNING, link,
1809 "MESSAGE=%-*s: could not join netdev '%s': %s",
1810 IFNAMSIZ,
1811 link->ifname, link->network->bond->ifname, strerror(-r),
1812 NETDEVIF(link->network->bond),
1813 NULL);
1814 link_enter_failed(link);
1815 return r;
1816 }
1817
1818 link->enslaving ++;
1819 }
1820
1821 if (link->network->bridge) {
1822 log_struct_link(LOG_DEBUG, link,
1823 "MESSAGE=%-*s: enslaving by '%s'",
1824 IFNAMSIZ,
1825 link->ifname, link->network->bridge->ifname,
1826 NETDEVIF(link->network->bridge),
1827 NULL);
1828
1829 r = netdev_join(link->network->bridge, link, &netdev_join_handler);
1830 if (r < 0) {
1831 log_struct_link(LOG_WARNING, link,
1832 "MESSAGE=%-*s: could not join netdev '%s': %s",
1833 IFNAMSIZ,
1834 link->ifname, link->network->bridge->ifname, strerror(-r),
1835 NETDEVIF(link->network->bridge),
1836 NULL);
1837 link_enter_failed(link);
1838 return r;
1839 }
1840
1841 link->enslaving ++;
1842 }
1843
1844 if (link->network->tunnel) {
1845 log_struct_link(LOG_DEBUG, link,
1846 "MESSAGE=%-*s: enslaving by '%s'",
1847 IFNAMSIZ,
1848 link->ifname, link->network->tunnel->ifname,
1849 NETDEVIF(link->network->tunnel),
1850 NULL);
1851
1852 r = netdev_join(link->network->tunnel, link, &netdev_join_handler);
1853 if (r < 0) {
1854 log_struct_link(LOG_WARNING, link,
1855 "MESSAGE=%-*s: could not join netdev '%s': %s",
1856 IFNAMSIZ,
1857 link->ifname, link->network->tunnel->ifname, strerror(-r),
1858 NETDEVIF(link->network->tunnel),
1859 NULL);
1860 link_enter_failed(link);
1861 return r;
1862 }
1863
1864 link->enslaving ++;
1865 }
1866
1867 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1868 log_struct_link(LOG_DEBUG, link,
1869 "MESSAGE=%-*s: enslaving by '%s'",
1870 IFNAMSIZ,
1871 link->ifname, vlan->ifname, NETDEVIF(vlan), NULL);
1872
1873 r = netdev_join(vlan, link, &netdev_join_handler);
1874 if (r < 0) {
1875 log_struct_link(LOG_WARNING, link,
1876 "MESSAGE=%-*s: could not join netdev '%s': %s",
1877 IFNAMSIZ,
1878 link->ifname, vlan->ifname, strerror(-r),
1879 NETDEVIF(vlan), NULL);
1880 link_enter_failed(link);
1881 return r;
1882 }
1883
1884 link->enslaving ++;
1885 }
1886
1887 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1888 log_struct_link(LOG_DEBUG, link,
1889 "MESSAGE=%-*s: enslaving by '%s'",
1890 IFNAMSIZ,
1891 link->ifname, macvlan->ifname, NETDEVIF(macvlan), NULL);
1892
1893 r = netdev_join(macvlan, link, &netdev_join_handler);
1894 if (r < 0) {
1895 log_struct_link(LOG_WARNING, link,
1896 "MESSAGE=%-*s: could not join netdev '%s': %s",
1897 IFNAMSIZ,
1898 link->ifname, macvlan->ifname, strerror(-r),
1899 NETDEVIF(macvlan), NULL);
1900 link_enter_failed(link);
1901 return r;
1902 }
1903
1904 link->enslaving ++;
1905 }
1906
1907 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1908 log_struct_link(LOG_DEBUG, link,
1909 "MESSAGE=%*s: enslaving by '%s'",
1910 IFNAMSIZ,
1911 link->ifname, vxlan->ifname, NETDEVIF(vxlan), NULL);
1912
1913 r = netdev_join(vxlan, link, &netdev_join_handler);
1914 if (r < 0) {
1915 log_struct_link(LOG_WARNING, link,
1916 "MESSAGE=%*s: could not join netdev '%s': %s",
1917 IFNAMSIZ,
1918 link->ifname, vxlan->ifname, strerror(-r),
1919 NETDEVIF(vxlan), NULL);
1920 link_enter_failed(link);
1921 return r;
1922 }
1923
1924 link->enslaving ++;
1925 }
1926
1927 return 0;
1928 }
1929
1930 static int link_configure(Link *link) {
1931 int r;
1932
1933 assert(link);
1934 assert(link->state == LINK_STATE_INITIALIZING);
1935
1936 if (link->network->ipv4ll) {
1937 uint8_t seed[8];
1938
1939 r = sd_ipv4ll_new(&link->ipv4ll);
1940 if (r < 0)
1941 return r;
1942
1943 if (link->udev_device) {
1944 r = net_get_unique_predictable_data(link->udev_device, seed);
1945 if (r >= 0) {
1946 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1947 if (r < 0)
1948 return r;
1949 }
1950 }
1951
1952 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1953 if (r < 0)
1954 return r;
1955
1956 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1957 if (r < 0)
1958 return r;
1959
1960 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1961 if (r < 0)
1962 return r;
1963
1964 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1965 if (r < 0)
1966 return r;
1967 }
1968
1969 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1970 r = sd_dhcp_client_new(&link->dhcp_client);
1971 if (r < 0)
1972 return r;
1973
1974 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1975 if (r < 0)
1976 return r;
1977
1978 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1979 if (r < 0)
1980 return r;
1981
1982 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1983 if (r < 0)
1984 return r;
1985
1986 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1987 if (r < 0)
1988 return r;
1989
1990 r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link->network->dhcp_broadcast);
1991 if (r < 0)
1992 return r;
1993
1994 if (link->network->dhcp_mtu) {
1995 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1996 if (r < 0)
1997 return r;
1998 }
1999
2000 if (link->network->dhcp_routes) {
2001 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2002 if (r < 0)
2003 return r;
2004 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2005 if (r < 0)
2006 return r;
2007 }
2008
2009 if (link->network->dhcp_sendhost) {
2010 _cleanup_free_ char *hostname = gethostname_malloc();
2011 if (!hostname)
2012 return -ENOMEM;
2013
2014 if (!is_localhost(hostname)) {
2015 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
2016 if (r < 0)
2017 return r;
2018 }
2019 }
2020
2021 if (link->network->dhcp_vendor_class_identifier) {
2022 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
2023 link->network->dhcp_vendor_class_identifier);
2024 if (r < 0)
2025 return r;
2026 }
2027 }
2028
2029 if (link->network->dhcp_server) {
2030 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2031 if (r < 0)
2032 return r;
2033
2034 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2035 if (r < 0)
2036 return r;
2037 }
2038
2039 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2040 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2041 if (r < 0)
2042 return r;
2043
2044 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2045 NULL, 0);
2046 if (r < 0)
2047 return r;
2048
2049 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2050 &link->mac);
2051 if (r < 0)
2052 return r;
2053
2054 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2055 link->ifindex);
2056 if (r < 0)
2057 return r;
2058
2059 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2060 icmp6_router_handler, link);
2061 if (r < 0)
2062 return r;
2063 }
2064
2065 if (link_has_carrier(link->flags, link->kernel_operstate)) {
2066 r = link_acquire_conf(link);
2067 if (r < 0)
2068 return r;
2069 }
2070
2071 return link_enter_join_netdev(link);
2072 }
2073
2074 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2075 _cleanup_link_unref_ Link *link = userdata;
2076 Network *network;
2077 int r;
2078
2079 assert(link);
2080 assert(link->ifname);
2081 assert(link->manager);
2082
2083 if (link->state != LINK_STATE_INITIALIZING)
2084 return 1;
2085
2086 log_debug_link(link, "link state is up-to-date");
2087
2088 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2089 if (r == -ENOENT) {
2090 link_enter_unmanaged(link);
2091 return 1;
2092 } else if (r < 0)
2093 return r;
2094
2095 r = network_apply(link->manager, network, link);
2096 if (r < 0)
2097 return r;
2098
2099 r = link_configure(link);
2100 if (r < 0)
2101 return r;
2102
2103 return 1;
2104 }
2105
2106 int link_initialized(Link *link, struct udev_device *device) {
2107 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2108 int r;
2109
2110 assert(link);
2111 assert(link->manager);
2112 assert(link->manager->rtnl);
2113 assert(device);
2114
2115 if (link->state != LINK_STATE_INITIALIZING)
2116 return 0;
2117
2118 if (link->udev_device)
2119 return 0;
2120
2121 log_debug_link(link, "udev initialized link");
2122
2123 link->udev_device = udev_device_ref(device);
2124
2125 /* udev has initialized the link, but we don't know if we have yet processed
2126 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2127 we know that the pending NEWLINKs have already been processed and that we
2128 are up-to-date */
2129
2130 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2131 if (r < 0)
2132 return r;
2133
2134 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2135 if (r < 0)
2136 return r;
2137
2138 link_ref(link);
2139
2140 return 0;
2141 }
2142
2143 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2144 Manager *m = userdata;
2145 Link *link = NULL;
2146 uint16_t type;
2147 _cleanup_address_free_ Address *address = NULL;
2148 Address *ad;
2149 char buf[INET6_ADDRSTRLEN];
2150 bool address_dropped = false;
2151 int r, ifindex;
2152
2153 assert(rtnl);
2154 assert(message);
2155 assert(m);
2156
2157 r = sd_rtnl_message_get_type(message, &type);
2158 if (r < 0) {
2159 log_warning("rtnl: could not get message type");
2160 return 0;
2161 }
2162
2163 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2164 if (r < 0 || ifindex <= 0) {
2165 log_warning("rtnl: received address message without valid ifindex, ignoring");
2166 return 0;
2167 } else {
2168 r = link_get(m, ifindex, &link);
2169 if (r < 0 || !link) {
2170 log_warning("rtnl: received address for a nonexistent link, ignoring");
2171 return 0;
2172 }
2173 }
2174
2175 r = address_new_dynamic(&address);
2176 if (r < 0)
2177 return r;
2178
2179 r = sd_rtnl_message_addr_get_family(message, &address->family);
2180 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2181 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2182 return 0;
2183 }
2184
2185 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2186 if (r < 0) {
2187 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2188 return 0;
2189 }
2190
2191 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2192 if (r < 0) {
2193 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2194 return 0;
2195 }
2196
2197 switch (address->family) {
2198 case AF_INET:
2199 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2200 if (r < 0) {
2201 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2202 return 0;
2203 }
2204
2205 break;
2206
2207 case AF_INET6:
2208 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2209 if (r < 0) {
2210 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2211 return 0;
2212 }
2213
2214 break;
2215
2216 default:
2217 assert_not_reached("invalid address family");
2218 }
2219
2220 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2221 log_warning_link(link, "could not print address");
2222 return 0;
2223 }
2224
2225 LIST_FOREACH(addresses, ad, link->addresses) {
2226 if (address_equal(ad, address)) {
2227 LIST_REMOVE(addresses, link->addresses, ad);
2228
2229 address_free(ad);
2230
2231 address_dropped = true;
2232
2233 break;
2234 }
2235 }
2236
2237 switch (type) {
2238 case RTM_NEWADDR:
2239 if (!address_dropped)
2240 log_debug_link(link, "added address: %s/%u", buf,
2241 address->prefixlen);
2242 else
2243 log_debug_link(link, "updated address: %s/%u", buf,
2244 address->prefixlen);
2245
2246 LIST_PREPEND(addresses, link->addresses, address);
2247 address = NULL;
2248
2249 link_save(link);
2250
2251 break;
2252 case RTM_DELADDR:
2253 if (address_dropped) {
2254 log_debug_link(link, "removed address: %s/%u", buf,
2255 address->prefixlen);
2256
2257 link_save(link);
2258 } else
2259 log_warning_link(link, "removing non-existent address: %s/%u",
2260 buf, address->prefixlen);
2261
2262 break;
2263 default:
2264 assert_not_reached("Received invalid RTNL message type");
2265 }
2266
2267 return 1;
2268 }
2269
2270 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2271 Link *link;
2272 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2273 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2274 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2275 int r;
2276
2277 assert(m);
2278 assert(m->rtnl);
2279 assert(message);
2280 assert(ret);
2281
2282 r = link_new(m, message, ret);
2283 if (r < 0)
2284 return r;
2285
2286 link = *ret;
2287
2288 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2289
2290 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2291 if (r < 0)
2292 return r;
2293
2294 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2295 if (r < 0)
2296 return r;
2297
2298 link_ref(link);
2299
2300 if (detect_container(NULL) <= 0) {
2301 /* not in a container, udev will be around */
2302 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2303 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2304 if (!device) {
2305 log_warning_link(link, "could not find udev device");
2306 return -errno;
2307 }
2308
2309 if (udev_device_get_is_initialized(device) <= 0) {
2310 /* not yet ready */
2311 log_debug_link(link, "udev initializing link...");
2312 return 0;
2313 }
2314
2315 r = link_initialized(link, device);
2316 if (r < 0)
2317 return r;
2318 } else {
2319 /* we are calling a callback directly, so must take a ref */
2320 link_ref(link);
2321
2322 r = link_initialized_and_synced(m->rtnl, NULL, link);
2323 if (r < 0)
2324 return r;
2325 }
2326
2327 return 0;
2328 }
2329
2330 int link_update(Link *link, sd_rtnl_message *m) {
2331 struct ether_addr mac;
2332 const char *ifname;
2333 int r;
2334
2335 assert(link);
2336 assert(link->ifname);
2337 assert(m);
2338
2339 if (link->state == LINK_STATE_LINGER) {
2340 link_ref(link);
2341 log_info_link(link, "link readded");
2342 link->state = LINK_STATE_ENSLAVING;
2343 }
2344
2345 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2346 if (r >= 0 && !streq(ifname, link->ifname)) {
2347 log_info_link(link, "renamed to %s", ifname);
2348
2349 free(link->ifname);
2350 link->ifname = strdup(ifname);
2351 if (!link->ifname)
2352 return -ENOMEM;
2353 }
2354
2355 if (!link->original_mtu) {
2356 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2357 if (r >= 0)
2358 log_debug_link(link, "saved original MTU: %"
2359 PRIu16, link->original_mtu);
2360 }
2361
2362 /* The kernel may broadcast NEWLINK messages without the MAC address
2363 set, simply ignore them. */
2364 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2365 if (r >= 0) {
2366 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2367
2368 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2369
2370 log_debug_link(link, "MAC address: "
2371 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2372 mac.ether_addr_octet[0],
2373 mac.ether_addr_octet[1],
2374 mac.ether_addr_octet[2],
2375 mac.ether_addr_octet[3],
2376 mac.ether_addr_octet[4],
2377 mac.ether_addr_octet[5]);
2378
2379 if (link->ipv4ll) {
2380 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2381 if (r < 0) {
2382 log_warning_link(link, "Could not update MAC "
2383 "address in IPv4LL client: %s",
2384 strerror(-r));
2385 return r;
2386 }
2387 }
2388
2389 if (link->dhcp_client) {
2390 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2391 if (r < 0) {
2392 log_warning_link(link, "Could not update MAC "
2393 "address in DHCP client: %s",
2394 strerror(-r));
2395 return r;
2396 }
2397 }
2398
2399 if (link->dhcp6_client) {
2400 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2401 &link->mac);
2402 if (r < 0) {
2403 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2404 strerror(-r));
2405 return r;
2406 }
2407 }
2408 }
2409 }
2410
2411 return link_update_flags(link, m);
2412 }
2413
2414 static void link_update_operstate(Link *link) {
2415
2416 assert(link);
2417
2418 if (link->kernel_operstate == IF_OPER_DORMANT)
2419 link->operstate = LINK_OPERSTATE_DORMANT;
2420 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2421 Address *address;
2422 uint8_t scope = RT_SCOPE_NOWHERE;
2423
2424 /* if we have carrier, check what addresses we have */
2425 LIST_FOREACH(addresses, address, link->addresses) {
2426 if (address->scope < scope)
2427 scope = address->scope;
2428 }
2429
2430 if (scope < RT_SCOPE_SITE)
2431 /* universally accessible addresses found */
2432 link->operstate = LINK_OPERSTATE_ROUTABLE;
2433 else if (scope < RT_SCOPE_HOST)
2434 /* only link or site local addresses found */
2435 link->operstate = LINK_OPERSTATE_DEGRADED;
2436 else
2437 /* no useful addresses found */
2438 link->operstate = LINK_OPERSTATE_CARRIER;
2439 } else
2440 link->operstate = LINK_OPERSTATE_UNKNOWN;
2441 }
2442
2443 int link_save(Link *link) {
2444 _cleanup_free_ char *temp_path = NULL;
2445 _cleanup_fclose_ FILE *f = NULL;
2446 const char *admin_state, *oper_state;
2447 int r;
2448
2449 assert(link);
2450 assert(link->state_file);
2451 assert(link->lease_file);
2452 assert(link->manager);
2453
2454 link_update_operstate(link);
2455
2456 r = manager_save(link->manager);
2457 if (r < 0)
2458 return r;
2459
2460 if (link->state == LINK_STATE_LINGER) {
2461 unlink(link->state_file);
2462 return 0;
2463 }
2464
2465 admin_state = link_state_to_string(link->state);
2466 assert(admin_state);
2467
2468 oper_state = link_operstate_to_string(link->operstate);
2469 assert(oper_state);
2470
2471 r = fopen_temporary(link->state_file, &f, &temp_path);
2472 if (r < 0)
2473 goto finish;
2474
2475 fchmod(fileno(f), 0644);
2476
2477 fprintf(f,
2478 "# This is private data. Do not parse.\n"
2479 "ADMIN_STATE=%s\n"
2480 "OPER_STATE=%s\n",
2481 admin_state, oper_state);
2482
2483 if (link->network) {
2484 char **address;
2485
2486 fputs("DNS=", f);
2487
2488 if (link->network->dhcp_dns &&
2489 link->dhcp_lease) {
2490 const struct in_addr *addresses;
2491
2492 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2493 if (r > 0) {
2494 serialize_in_addrs(f, addresses, r);
2495 if (link->network->dns)
2496 fputs(" ", f);
2497 }
2498 }
2499
2500 STRV_FOREACH(address, link->network->dns)
2501 fprintf(f, "%s%s", *address,
2502 (address + 1 ? " " : ""));
2503
2504 fputs("\n", f);
2505
2506 fprintf(f, "NTP=");
2507
2508 if (link->network->dhcp_ntp &&
2509 link->dhcp_lease) {
2510 const struct in_addr *addresses;
2511
2512 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2513 if (r > 0) {
2514 serialize_in_addrs(f, addresses, r);
2515 if (link->network->ntp)
2516 fputs(" ", f);
2517 }
2518 }
2519
2520 STRV_FOREACH(address, link->network->ntp)
2521 fprintf(f, "%s%s", *address,
2522 (address + 1 ? " " : ""));
2523
2524 fputs("\n", f);
2525 }
2526
2527 if (link->dhcp_lease) {
2528 assert(link->network);
2529
2530 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2531 if (r < 0)
2532 goto finish;
2533
2534 fprintf(f,
2535 "DHCP_LEASE=%s\n",
2536 link->lease_file);
2537 } else
2538 unlink(link->lease_file);
2539
2540 fflush(f);
2541
2542 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2543 r = -errno;
2544 unlink(link->state_file);
2545 unlink(temp_path);
2546 }
2547
2548 finish:
2549 if (r < 0)
2550 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2551
2552 return r;
2553 }
2554
2555 static const char* const link_state_table[_LINK_STATE_MAX] = {
2556 [LINK_STATE_INITIALIZING] = "initializing",
2557 [LINK_STATE_ENSLAVING] = "configuring",
2558 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2559 [LINK_STATE_SETTING_ROUTES] = "configuring",
2560 [LINK_STATE_CONFIGURED] = "configured",
2561 [LINK_STATE_UNMANAGED] = "unmanaged",
2562 [LINK_STATE_FAILED] = "failed",
2563 [LINK_STATE_LINGER] = "linger",
2564 };
2565
2566 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2567
2568 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2569 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2570 [LINK_OPERSTATE_DORMANT] = "dormant",
2571 [LINK_OPERSTATE_CARRIER] = "carrier",
2572 [LINK_OPERSTATE_DEGRADED] = "degraded",
2573 [LINK_OPERSTATE_ROUTABLE] = "routable",
2574 };
2575
2576 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2577
2578 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2579 [DHCP_SUPPORT_NONE] = "none",
2580 [DHCP_SUPPORT_BOTH] = "both",
2581 [DHCP_SUPPORT_V4] = "v4",
2582 [DHCP_SUPPORT_V6] = "v6",
2583 };
2584
2585 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2586
2587 int config_parse_dhcp(
2588 const char* unit,
2589 const char *filename,
2590 unsigned line,
2591 const char *section,
2592 unsigned section_line,
2593 const char *lvalue,
2594 int ltype,
2595 const char *rvalue,
2596 void *data,
2597 void *userdata) {
2598
2599 DHCPSupport *dhcp = data;
2600 int k;
2601
2602 assert(filename);
2603 assert(lvalue);
2604 assert(rvalue);
2605 assert(data);
2606
2607 /* Our enum shall be a superset of booleans, hence first try
2608 * to parse as boolean, and then as enum */
2609
2610 k = parse_boolean(rvalue);
2611 if (k > 0)
2612 *dhcp = DHCP_SUPPORT_BOTH;
2613 else if (k == 0)
2614 *dhcp = DHCP_SUPPORT_NONE;
2615 else {
2616 DHCPSupport s;
2617
2618 s = dhcp_support_from_string(rvalue);
2619 if (s < 0){
2620 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);
2621 return 0;
2622 }
2623
2624 *dhcp = s;
2625 }
2626
2627 return 0;
2628 }
Unnamed repository; edit this file 'description' to name the repository.