]> 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
sd-dhcp-client: fix REBOOT state handling
[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-link.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 "dhcp-lease-internal.h"
37
38 static bool link_dhcp6_enabled(Link *link) {
39 if (link->flags & IFF_LOOPBACK)
40 return false;
41
42 if (!link->network)
43 return false;
44
45 return IN_SET(link->network->dhcp, DHCP_SUPPORT_V6, DHCP_SUPPORT_BOTH);
46 }
47
48 static bool link_dhcp4_enabled(Link *link) {
49 if (link->flags & IFF_LOOPBACK)
50 return false;
51
52 if (!link->network)
53 return false;
54
55 return IN_SET(link->network->dhcp, DHCP_SUPPORT_V4, DHCP_SUPPORT_BOTH);
56 }
57
58 static bool link_dhcp4_server_enabled(Link *link) {
59 if (link->flags & IFF_LOOPBACK)
60 return false;
61
62 if (!link->network)
63 return false;
64
65 return link->network->dhcp_server;
66 }
67
68 static bool link_ipv4ll_enabled(Link *link) {
69 if (link->flags & IFF_LOOPBACK)
70 return false;
71
72 if (!link->network)
73 return false;
74
75 return link->network->ipv4ll;
76 }
77
78 #define FLAG_STRING(string, flag, old, new) \
79 (((old ^ new) & flag) \
80 ? ((old & flag) ? (" -" string) : (" +" string)) \
81 : "")
82
83 static int link_update_flags(Link *link, sd_rtnl_message *m) {
84 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
85 uint8_t operstate;
86 int r;
87
88 assert(link);
89
90 r = sd_rtnl_message_link_get_flags(m, &flags);
91 if (r < 0) {
92 log_warning_link(link, "Could not get link flags");
93 return r;
94 }
95
96 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
97 if (r < 0)
98 /* if we got a message without operstate, take it to mean
99 the state was unchanged */
100 operstate = link->kernel_operstate;
101
102 if ((link->flags == flags) && (link->kernel_operstate == operstate))
103 return 0;
104
105 if (link->flags != flags) {
106 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",
107 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
108 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
109 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
110 FLAG_STRING("UP", IFF_UP, link->flags, flags),
111 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
112 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
113 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
114 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
115 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
116 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
117 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
118 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
119 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
120 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
121 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
122 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
123 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
124 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
125 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
126
127 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
128 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
129 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
130 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
131 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
132 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
133 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
134 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
135
136 /* link flags are currently at most 18 bits, let's align to
137 * printing 20 */
138 if (unknown_flags_added)
139 log_debug_link(link,
140 "unknown link flags gained: %#.5x (ignoring)",
141 unknown_flags_added);
142
143 if (unknown_flags_removed)
144 log_debug_link(link,
145 "unknown link flags lost: %#.5x (ignoring)",
146 unknown_flags_removed);
147 }
148
149 link->flags = flags;
150 link->kernel_operstate = operstate;
151
152 link_save(link);
153
154 return 0;
155 }
156
157 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
158 _cleanup_link_unref_ Link *link = NULL;
159 uint16_t type;
160 const char *ifname;
161 int r, ifindex;
162
163 assert(manager);
164 assert(message);
165 assert(ret);
166
167 r = sd_rtnl_message_get_type(message, &type);
168 if (r < 0)
169 return r;
170 else if (type != RTM_NEWLINK)
171 return -EINVAL;
172
173 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
174 if (r < 0)
175 return r;
176 else if (ifindex <= 0)
177 return -EINVAL;
178
179 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
180 if (r < 0)
181 return r;
182
183 link = new0(Link, 1);
184 if (!link)
185 return -ENOMEM;
186
187 link->n_ref = 1;
188 link->manager = manager;
189 link->state = LINK_STATE_PENDING;
190 link->ifindex = ifindex;
191 link->ifname = strdup(ifname);
192 if (!link->ifname)
193 return -ENOMEM;
194
195 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
196 if (r < 0)
197 log_debug_link(link, "MAC address not found for new device, continuing without");
198
199 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
200 link->ifindex);
201 if (r < 0)
202 return -ENOMEM;
203
204 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
205 link->ifindex);
206 if (r < 0)
207 return -ENOMEM;
208
209 r = hashmap_ensure_allocated(&manager->links, NULL);
210 if (r < 0)
211 return r;
212
213 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
214 if (r < 0)
215 return r;
216
217 r = link_update_flags(link, message);
218 if (r < 0)
219 return r;
220
221 *ret = link;
222 link = NULL;
223
224 return 0;
225 }
226
227 static void link_free(Link *link) {
228 Address *address;
229
230 if (!link)
231 return;
232
233 while ((address = link->addresses)) {
234 LIST_REMOVE(addresses, link->addresses, address);
235 address_free(address);
236 }
237
238 while ((address = link->pool_addresses)) {
239 LIST_REMOVE(addresses, link->pool_addresses, address);
240 address_free(address);
241 }
242
243 sd_dhcp_client_unref(link->dhcp_client);
244 sd_dhcp_lease_unref(link->dhcp_lease);
245
246 unlink(link->lease_file);
247 free(link->lease_file);
248
249 sd_ipv4ll_unref(link->ipv4ll);
250 sd_dhcp6_client_unref(link->dhcp6_client);
251 sd_icmp6_nd_unref(link->icmp6_router_discovery);
252
253 if (link->manager)
254 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
255
256 free(link->ifname);
257
258 unlink(link->state_file);
259 free(link->state_file);
260
261 udev_device_unref(link->udev_device);
262
263 free(link);
264 }
265
266 Link *link_unref(Link *link) {
267 if (link && (-- link->n_ref <= 0))
268 link_free(link);
269
270 return NULL;
271 }
272
273 Link *link_ref(Link *link) {
274 if (link)
275 assert_se(++ link->n_ref >= 2);
276
277 return link;
278 }
279
280 int link_get(Manager *m, int ifindex, Link **ret) {
281 Link *link;
282
283 assert(m);
284 assert(ifindex);
285 assert(ret);
286
287 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
288 if (!link)
289 return -ENODEV;
290
291 *ret = link;
292
293 return 0;
294 }
295
296 void link_drop(Link *link) {
297 if (!link || link->state == LINK_STATE_LINGER)
298 return;
299
300 link->state = LINK_STATE_LINGER;
301
302 log_debug_link(link, "link removed");
303
304 link_unref(link);
305
306 return;
307 }
308
309 static void link_enter_unmanaged(Link *link) {
310 assert(link);
311
312 log_debug_link(link, "unmanaged");
313
314 link->state = LINK_STATE_UNMANAGED;
315
316 link_save(link);
317 }
318
319 static int link_stop_clients(Link *link) {
320 int r = 0, k;
321
322 assert(link);
323 assert(link->manager);
324 assert(link->manager->event);
325
326 if (!link->network)
327 return 0;
328
329 if (link->dhcp_client) {
330 k = sd_dhcp_client_stop(link->dhcp_client);
331 if (k < 0) {
332 log_warning_link(link, "Could not stop DHCPv4 client: %s",
333 strerror(-r));
334 r = k;
335 }
336 }
337
338 if (link->ipv4ll) {
339 k = sd_ipv4ll_stop(link->ipv4ll);
340 if (k < 0) {
341 log_warning_link(link, "Could not stop IPv4 link-local: %s",
342 strerror(-r));
343 r = k;
344 }
345 }
346
347 if(link->icmp6_router_discovery) {
348
349 if (link->dhcp6_client) {
350 k = sd_dhcp6_client_stop(link->dhcp6_client);
351 if (k < 0) {
352 log_warning_link(link, "Could not stop DHCPv6 client: %s",
353 strerror(-r));
354 r = k;
355 }
356 }
357
358 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
359 if (k < 0) {
360 log_warning_link(link,
361 "Could not stop ICMPv6 router discovery: %s",
362 strerror(-r));
363 r = k;
364 }
365 }
366
367 return r;
368 }
369
370 void link_enter_failed(Link *link) {
371 assert(link);
372
373 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
374 return;
375
376 log_warning_link(link, "failed");
377
378 link->state = LINK_STATE_FAILED;
379
380 link_stop_clients(link);
381
382 link_save(link);
383 }
384
385 static Address* link_find_dhcp_server_address(Link *link) {
386 Address *address;
387
388 assert(link);
389 assert(link->network);
390
391 /* The the first statically configured address if there is any */
392 LIST_FOREACH(addresses, address, link->network->static_addresses) {
393
394 if (address->family != AF_INET)
395 continue;
396
397 if (in_addr_is_null(address->family, &address->in_addr))
398 continue;
399
400 return address;
401 }
402
403 /* If that didn't work, find a suitable address we got from the pool */
404 LIST_FOREACH(addresses, address, link->pool_addresses) {
405 if (address->family != AF_INET)
406 continue;
407
408 return address;
409 }
410
411 return NULL;
412 }
413
414 static int link_enter_configured(Link *link) {
415 int r;
416
417 assert(link);
418 assert(link->network);
419 assert(link->state == LINK_STATE_SETTING_ROUTES);
420
421 if (link_dhcp4_server_enabled(link) &&
422 !sd_dhcp_server_is_running(link->dhcp_server)) {
423 struct in_addr pool_start;
424 Address *address;
425
426 address = link_find_dhcp_server_address(link);
427 if (!address) {
428 log_warning_link(link,
429 "Failed to find suitable address for DHCPv4 server instance.");
430 link_enter_failed(link);
431 return 0;
432 }
433
434 log_debug_link(link, "offering DHCPv4 leases");
435
436 r = sd_dhcp_server_set_address(link->dhcp_server,
437 &address->in_addr.in,
438 address->prefixlen);
439 if (r < 0)
440 return r;
441
442 /* offer 32 addresses starting from the address following the server address */
443 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
444 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
445 &pool_start, 32);
446 if (r < 0)
447 return r;
448
449 /* TODO:
450 r = sd_dhcp_server_set_router(link->dhcp_server,
451 &main_address->in_addr.in);
452 if (r < 0)
453 return r;
454
455 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
456 main_address->prefixlen);
457 if (r < 0)
458 return r;
459 */
460
461 r = sd_dhcp_server_start(link->dhcp_server);
462 if (r < 0) {
463 log_warning_link(link, "could not start DHCPv4 server "
464 "instance: %s", strerror(-r));
465
466 link_enter_failed(link);
467
468 return 0;
469 }
470 }
471
472 log_info_link(link, "link configured");
473
474 link->state = LINK_STATE_CONFIGURED;
475
476 link_save(link);
477
478 return 0;
479 }
480
481 void link_client_handler(Link *link) {
482 assert(link);
483 assert(link->network);
484
485 if (!link->static_configured)
486 return;
487
488 if (link_ipv4ll_enabled(link))
489 if (!link->ipv4ll_address ||
490 !link->ipv4ll_route)
491 return;
492
493 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
494 return;
495
496 if (link->state != LINK_STATE_CONFIGURED)
497 link_enter_configured(link);
498
499 return;
500 }
501
502 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
503 _cleanup_link_unref_ Link *link = userdata;
504 int r;
505
506 assert(link->link_messages > 0);
507 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
508 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
509 LINK_STATE_LINGER));
510
511 link->link_messages --;
512
513 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
514 return 1;
515
516 r = sd_rtnl_message_get_errno(m);
517 if (r < 0 && r != -EEXIST)
518 log_struct_link(LOG_WARNING, link,
519 "MESSAGE=%-*s: could not set route: %s",
520 IFNAMSIZ,
521 link->ifname, strerror(-r),
522 "ERRNO=%d", -r,
523 NULL);
524
525 if (link->link_messages == 0) {
526 log_debug_link(link, "routes set");
527 link->static_configured = true;
528 link_client_handler(link);
529 }
530
531 return 1;
532 }
533
534 static int link_enter_set_routes(Link *link) {
535 Route *rt;
536 int r;
537
538 assert(link);
539 assert(link->network);
540 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
541
542 link->state = LINK_STATE_SETTING_ROUTES;
543
544 LIST_FOREACH(routes, rt, link->network->static_routes) {
545 r = route_configure(rt, link, &route_handler);
546 if (r < 0) {
547 log_warning_link(link,
548 "could not set routes: %s",
549 strerror(-r));
550 link_enter_failed(link);
551 return r;
552 }
553
554 link->link_messages ++;
555 }
556
557 if (link->link_messages == 0) {
558 link->static_configured = true;
559 link_client_handler(link);
560 } else
561 log_debug_link(link, "setting routes");
562
563 return 0;
564 }
565
566 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
567 _cleanup_link_unref_ Link *link = userdata;
568 int r;
569
570 assert(m);
571 assert(link);
572 assert(link->ifname);
573
574 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
575 return 1;
576
577 r = sd_rtnl_message_get_errno(m);
578 if (r < 0 && r != -ESRCH)
579 log_struct_link(LOG_WARNING, link,
580 "MESSAGE=%-*s: could not drop route: %s",
581 IFNAMSIZ,
582 link->ifname, strerror(-r),
583 "ERRNO=%d", -r,
584 NULL);
585
586 return 1;
587 }
588
589 int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
590 _cleanup_link_unref_ Link *link = userdata;
591 int r;
592
593 assert(rtnl);
594 assert(m);
595 assert(link);
596 assert(link->manager);
597
598 for (; m; m = sd_rtnl_message_next(m)) {
599 r = sd_rtnl_message_get_errno(m);
600 if (r < 0) {
601 log_debug_link(link, "getting address failed: %s",
602 strerror(-r));
603 continue;
604 }
605
606 r = link_rtnl_process_address(rtnl, m, link->manager);
607 if (r < 0)
608 log_warning_link(link, "could not process address: %s",
609 strerror(-r));
610 }
611
612 return 1;
613 }
614
615 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
616 _cleanup_link_unref_ Link *link = userdata;
617 int r;
618
619 assert(rtnl);
620 assert(m);
621 assert(link);
622 assert(link->ifname);
623 assert(link->link_messages > 0);
624 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
625 LINK_STATE_FAILED, LINK_STATE_LINGER));
626
627 link->link_messages --;
628
629 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
630 return 1;
631
632 r = sd_rtnl_message_get_errno(m);
633 if (r < 0 && r != -EEXIST)
634 log_struct_link(LOG_WARNING, link,
635 "MESSAGE=%-*s: could not set address: %s",
636 IFNAMSIZ,
637 link->ifname, strerror(-r),
638 "ERRNO=%d", -r,
639 NULL);
640 else if (r >= 0) {
641 /* calling handler directly so take a ref */
642 link_ref(link);
643 link_get_address_handler(rtnl, m, link);
644 }
645
646 if (link->link_messages == 0) {
647 log_debug_link(link, "addresses set");
648 link_enter_set_routes(link);
649 }
650
651 return 1;
652 }
653
654 static int link_enter_set_addresses(Link *link) {
655 Address *ad;
656 int r;
657
658 assert(link);
659 assert(link->network);
660 assert(link->state != _LINK_STATE_INVALID);
661
662 link->state = LINK_STATE_SETTING_ADDRESSES;
663
664 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
665 r = address_configure(ad, link, &address_handler);
666 if (r < 0) {
667 log_warning_link(link,
668 "could not set addresses: %s",
669 strerror(-r));
670 link_enter_failed(link);
671 return r;
672 }
673
674 link->link_messages ++;
675 }
676
677 if (link->link_messages == 0) {
678 link_enter_set_routes(link);
679 } else
680 log_debug_link(link, "setting addresses");
681
682 return 0;
683 }
684
685 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
686 _cleanup_link_unref_ Link *link = userdata;
687 int r;
688
689 assert(m);
690 assert(link);
691 assert(link->ifname);
692
693 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
694 return 1;
695
696 r = sd_rtnl_message_get_errno(m);
697 if (r < 0 && r != -EADDRNOTAVAIL)
698 log_struct_link(LOG_WARNING, link,
699 "MESSAGE=%-*s: could not drop address: %s",
700 IFNAMSIZ,
701 link->ifname, strerror(-r),
702 "ERRNO=%d", -r,
703 NULL);
704
705 return 1;
706 }
707
708 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
709 sd_bus_error *ret_error) {
710 _cleanup_link_unref_ Link *link = userdata;
711 int r;
712
713 assert(link);
714
715 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
716 return 1;
717
718 r = sd_bus_message_get_errno(m);
719 if (r > 0)
720 log_warning_link(link, "Could not set hostname: %s",
721 strerror(r));
722
723 return 1;
724 }
725
726 int link_set_hostname(Link *link, const char *hostname) {
727 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
728 int r = 0;
729
730 assert(link);
731 assert(link->manager);
732 assert(hostname);
733
734 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
735
736 if (!link->manager->bus) {
737 /* TODO: replace by assert when we can rely on kdbus */
738 log_info_link(link,
739 "Not connected to system bus, ignoring transient hostname.");
740 return 0;
741 }
742
743 r = sd_bus_message_new_method_call(
744 link->manager->bus,
745 &m,
746 "org.freedesktop.hostname1",
747 "/org/freedesktop/hostname1",
748 "org.freedesktop.hostname1",
749 "SetHostname");
750 if (r < 0)
751 return r;
752
753 r = sd_bus_message_append(m, "sb", hostname, false);
754 if (r < 0)
755 return r;
756
757 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
758 link, 0);
759 if (r < 0) {
760 log_error_link(link, "Could not set transient hostname: %s",
761 strerror(-r));
762 return r;
763 }
764
765 link_ref(link);
766
767 return 0;
768 }
769
770 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
771 _cleanup_link_unref_ Link *link = userdata;
772 int r;
773
774 assert(m);
775 assert(link);
776 assert(link->ifname);
777
778 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
779 return 1;
780
781 r = sd_rtnl_message_get_errno(m);
782 if (r < 0)
783 log_struct_link(LOG_WARNING, link,
784 "MESSAGE=%-*s: could not set MTU: %s",
785 IFNAMSIZ, link->ifname, strerror(-r),
786 "ERRNO=%d", -r,
787 NULL);
788
789 return 1;
790 }
791
792 int link_set_mtu(Link *link, uint32_t mtu) {
793 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
794 int r;
795
796 assert(link);
797 assert(link->manager);
798 assert(link->manager->rtnl);
799
800 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
801
802 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
803 RTM_SETLINK, link->ifindex);
804 if (r < 0) {
805 log_error_link(link, "Could not allocate RTM_SETLINK message");
806 return r;
807 }
808
809 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
810 if (r < 0) {
811 log_error_link(link, "Could not append MTU: %s", strerror(-r));
812 return r;
813 }
814
815 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
816 0, NULL);
817 if (r < 0) {
818 log_error_link(link,
819 "Could not send rtnetlink message: %s",
820 strerror(-r));
821 return r;
822 }
823
824 link_ref(link);
825
826 return 0;
827 }
828
829 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
830 Link *link = userdata;
831
832 assert(link);
833 assert(link->network);
834 assert(link->manager);
835
836 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
837 return;
838
839 switch(event) {
840 case DHCP6_EVENT_STOP:
841 case DHCP6_EVENT_RESEND_EXPIRE:
842 case DHCP6_EVENT_RETRANS_MAX:
843 case DHCP6_EVENT_IP_ACQUIRE:
844 log_debug_link(link, "DHCPv6 event %d", event);
845
846 break;
847
848 default:
849 if (event < 0)
850 log_warning_link(link, "DHCPv6 error: %s",
851 strerror(-event));
852 else
853 log_warning_link(link, "DHCPv6 unknown event: %d",
854 event);
855 return;
856 }
857 }
858
859 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
860 Link *link = userdata;
861 int r;
862
863 assert(link);
864 assert(link->network);
865 assert(link->manager);
866
867 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
868 return;
869
870 switch(event) {
871 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
872 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
873 return;
874
875 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
876 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
877 break;
878
879 default:
880 if (event < 0)
881 log_warning_link(link, "ICMPv6 error: %s",
882 strerror(-event));
883 else
884 log_warning_link(link, "ICMPv6 unknown event: %d",
885 event);
886
887 return;
888 }
889
890 if (link->dhcp6_client)
891 return;
892
893 r = sd_dhcp6_client_new(&link->dhcp6_client);
894 if (r < 0)
895 return;
896
897 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
898 if (r < 0) {
899 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
900 return;
901 }
902
903 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
904 (const uint8_t *) &link->mac,
905 sizeof (link->mac), ARPHRD_ETHER);
906 if (r < 0) {
907 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
908 return;
909 }
910
911 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
912 if (r < 0) {
913 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
914 return;
915 }
916
917 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
918 link);
919 if (r < 0) {
920 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
921 return;
922 }
923
924 r = sd_dhcp6_client_start(link->dhcp6_client);
925 if (r < 0)
926 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
927 }
928
929 static int link_acquire_conf(Link *link) {
930 int r;
931
932 assert(link);
933 assert(link->network);
934 assert(link->manager);
935 assert(link->manager->event);
936
937 if (link_ipv4ll_enabled(link)) {
938 assert(link->ipv4ll);
939
940 log_debug_link(link, "acquiring IPv4 link-local address");
941
942 r = sd_ipv4ll_start(link->ipv4ll);
943 if (r < 0) {
944 log_warning_link(link, "could not acquire IPv4 "
945 "link-local address");
946 return r;
947 }
948 }
949
950 if (link_dhcp4_enabled(link)) {
951 assert(link->dhcp_client);
952
953 log_debug_link(link, "acquiring DHCPv4 lease");
954
955 r = sd_dhcp_client_start(link->dhcp_client);
956 if (r < 0) {
957 log_warning_link(link, "could not acquire DHCPv4 "
958 "lease");
959 return r;
960 }
961 }
962
963 if (link_dhcp6_enabled(link)) {
964 assert(link->icmp6_router_discovery);
965
966 log_debug_link(link, "discovering IPv6 routers");
967
968 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
969 if (r < 0) {
970 log_warning_link(link,
971 "could not start IPv6 router discovery");
972 return r;
973 }
974 }
975
976 return 0;
977 }
978
979 bool link_has_carrier(Link *link) {
980 /* see Documentation/networking/operstates.txt in the kernel sources */
981
982 if (link->kernel_operstate == IF_OPER_UP)
983 return true;
984
985 if (link->kernel_operstate == IF_OPER_UNKNOWN)
986 /* operstate may not be implemented, so fall back to flags */
987 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
988 return true;
989
990 return false;
991 }
992
993 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
994 _cleanup_link_unref_ Link *link = userdata;
995 int r;
996
997 assert(link);
998
999 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1000 return 1;
1001
1002 r = sd_rtnl_message_get_errno(m);
1003 if (r < 0) {
1004 /* we warn but don't fail the link, as it may
1005 be brought up later */
1006 log_struct_link(LOG_WARNING, link,
1007 "MESSAGE=%-*s: could not bring up interface: %s",
1008 IFNAMSIZ,
1009 link->ifname, strerror(-r),
1010 "ERRNO=%d", -r,
1011 NULL);
1012 }
1013
1014 return 1;
1015 }
1016
1017 static int link_up(Link *link) {
1018 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1019 int r;
1020
1021 assert(link);
1022 assert(link->manager);
1023 assert(link->manager->rtnl);
1024
1025 log_debug_link(link, "bringing link up");
1026
1027 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1028 RTM_SETLINK, link->ifindex);
1029 if (r < 0) {
1030 log_error_link(link, "Could not allocate RTM_SETLINK message");
1031 return r;
1032 }
1033
1034 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1035 if (r < 0) {
1036 log_error_link(link, "Could not set link flags: %s",
1037 strerror(-r));
1038 return r;
1039 }
1040
1041 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1042 0, NULL);
1043 if (r < 0) {
1044 log_error_link(link,
1045 "Could not send rtnetlink message: %s",
1046 strerror(-r));
1047 return r;
1048 }
1049
1050 link_ref(link);
1051
1052 return 0;
1053 }
1054
1055 static int link_joined(Link *link) {
1056 int r;
1057
1058 assert(link);
1059 assert(link->network);
1060
1061 if (!(link->flags & IFF_UP)) {
1062 r = link_up(link);
1063 if (r < 0) {
1064 link_enter_failed(link);
1065 return r;
1066 }
1067 }
1068
1069 return link_enter_set_addresses(link);
1070 }
1071
1072 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1073 void *userdata) {
1074 _cleanup_link_unref_ Link *link = userdata;
1075 int r;
1076
1077 assert(link);
1078 assert(link->network);
1079
1080 link->enslaving --;
1081
1082 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1083 return 1;
1084
1085 r = sd_rtnl_message_get_errno(m);
1086 if (r < 0 && r != -EEXIST) {
1087 log_struct_link(LOG_ERR, link,
1088 "MESSAGE=%-*s: could not join netdev: %s",
1089 IFNAMSIZ,
1090 link->ifname, strerror(-r),
1091 "ERRNO=%d", -r,
1092 NULL);
1093 link_enter_failed(link);
1094 return 1;
1095 } else
1096 log_debug_link(link, "joined netdev");
1097
1098 if (link->enslaving <= 0)
1099 link_joined(link);
1100
1101 return 1;
1102 }
1103
1104 static int link_enter_join_netdev(Link *link) {
1105 NetDev *netdev;
1106 Iterator i;
1107 int r;
1108
1109 assert(link);
1110 assert(link->network);
1111 assert(link->state == LINK_STATE_PENDING);
1112
1113 link->state = LINK_STATE_ENSLAVING;
1114
1115 link_save(link);
1116
1117 if (!link->network->bridge &&
1118 !link->network->bond &&
1119 hashmap_isempty(link->network->stacked_netdevs))
1120 return link_joined(link);
1121
1122 if (link->network->bond) {
1123 log_struct_link(LOG_DEBUG, link,
1124 "MESSAGE=%-*s: enslaving by '%s'",
1125 IFNAMSIZ,
1126 link->ifname, link->network->bond->ifname,
1127 NETDEVIF(link->network->bond),
1128 NULL);
1129
1130 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1131 if (r < 0) {
1132 log_struct_link(LOG_WARNING, link,
1133 "MESSAGE=%-*s: could not join netdev '%s': %s",
1134 IFNAMSIZ,
1135 link->ifname, link->network->bond->ifname,
1136 strerror(-r),
1137 NETDEVIF(link->network->bond),
1138 NULL);
1139 link_enter_failed(link);
1140 return r;
1141 }
1142
1143 link->enslaving ++;
1144 }
1145
1146 if (link->network->bridge) {
1147 log_struct_link(LOG_DEBUG, link,
1148 "MESSAGE=%-*s: enslaving by '%s'",
1149 IFNAMSIZ,
1150 link->ifname, link->network->bridge->ifname,
1151 NETDEVIF(link->network->bridge),
1152 NULL);
1153
1154 r = netdev_join(link->network->bridge, link,
1155 &netdev_join_handler);
1156 if (r < 0) {
1157 log_struct_link(LOG_WARNING, link,
1158 "MESSAGE=%-*s: could not join netdev '%s': %s",
1159 IFNAMSIZ,
1160 link->ifname, link->network->bridge->ifname,
1161 strerror(-r),
1162 NETDEVIF(link->network->bridge),
1163 NULL);
1164 link_enter_failed(link);
1165 return r;
1166 }
1167
1168 link->enslaving ++;
1169 }
1170
1171 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1172 log_struct_link(LOG_DEBUG, link,
1173 "MESSAGE=%-*s: enslaving by '%s'",
1174 IFNAMSIZ,
1175 link->ifname, netdev->ifname, NETDEVIF(netdev),
1176 NULL);
1177
1178 r = netdev_join(netdev, link, &netdev_join_handler);
1179 if (r < 0) {
1180 log_struct_link(LOG_WARNING, link,
1181 "MESSAGE=%-*s: could not join netdev '%s': %s",
1182 IFNAMSIZ,
1183 link->ifname, netdev->ifname,
1184 strerror(-r),
1185 NETDEVIF(netdev), NULL);
1186 link_enter_failed(link);
1187 return r;
1188 }
1189
1190 link->enslaving ++;
1191 }
1192
1193 return 0;
1194 }
1195
1196 static int link_configure(Link *link) {
1197 int r;
1198
1199 assert(link);
1200 assert(link->network);
1201 assert(link->state == LINK_STATE_PENDING);
1202
1203 if (link_ipv4ll_enabled(link)) {
1204 r = ipv4ll_configure(link);
1205 if (r < 0)
1206 return r;
1207 }
1208
1209 if (link_dhcp4_enabled(link)) {
1210 r = dhcp4_configure(link);
1211 if (r < 0)
1212 return r;
1213 }
1214
1215 if (link_dhcp4_server_enabled(link)) {
1216 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1217 if (r < 0)
1218 return r;
1219
1220 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1221 if (r < 0)
1222 return r;
1223 }
1224
1225 if (link_dhcp6_enabled(link)) {
1226 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1227 if (r < 0)
1228 return r;
1229
1230 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1231 NULL, 0);
1232 if (r < 0)
1233 return r;
1234
1235 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1236 &link->mac);
1237 if (r < 0)
1238 return r;
1239
1240 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1241 link->ifindex);
1242 if (r < 0)
1243 return r;
1244
1245 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1246 icmp6_router_handler, link);
1247 if (r < 0)
1248 return r;
1249 }
1250
1251 if (link_has_carrier(link)) {
1252 r = link_acquire_conf(link);
1253 if (r < 0)
1254 return r;
1255 }
1256
1257 return link_enter_join_netdev(link);
1258 }
1259
1260 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1261 void *userdata) {
1262 _cleanup_link_unref_ Link *link = userdata;
1263 Network *network;
1264 int r;
1265
1266 assert(link);
1267 assert(link->ifname);
1268 assert(link->manager);
1269
1270 if (link->state != LINK_STATE_PENDING)
1271 return 1;
1272
1273 log_debug_link(link, "link state is up-to-date");
1274
1275 r = network_get(link->manager, link->udev_device, link->ifname,
1276 &link->mac, &network);
1277 if (r == -ENOENT) {
1278 link_enter_unmanaged(link);
1279 return 1;
1280 } else if (r < 0)
1281 return r;
1282
1283 if (link->flags & IFF_LOOPBACK) {
1284 if (network->ipv4ll)
1285 log_debug_link(link, "ignoring IPv4LL for loopback link");
1286
1287 if (network->dhcp != DHCP_SUPPORT_NONE)
1288 log_debug_link(link, "ignoring DHCP clients for loopback link");
1289
1290 if (network->dhcp_server)
1291 log_debug_link(link, "ignoring DHCP server for loopback link");
1292 }
1293
1294 r = network_apply(link->manager, network, link);
1295 if (r < 0)
1296 return r;
1297
1298 r = link_configure(link);
1299 if (r < 0)
1300 return r;
1301
1302 return 1;
1303 }
1304
1305 int link_initialized(Link *link, struct udev_device *device) {
1306 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1307 int r;
1308
1309 assert(link);
1310 assert(link->manager);
1311 assert(link->manager->rtnl);
1312 assert(device);
1313
1314 if (link->state != LINK_STATE_PENDING)
1315 return 0;
1316
1317 if (link->udev_device)
1318 return 0;
1319
1320 log_debug_link(link, "udev initialized link");
1321
1322 link->udev_device = udev_device_ref(device);
1323
1324 /* udev has initialized the link, but we don't know if we have yet
1325 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1326 * when it returns we know that the pending NEWLINKs have already been
1327 * processed and that we are up-to-date */
1328
1329 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1330 link->ifindex);
1331 if (r < 0)
1332 return r;
1333
1334 r = sd_rtnl_call_async(link->manager->rtnl, req,
1335 link_initialized_and_synced, link, 0, NULL);
1336 if (r < 0)
1337 return r;
1338
1339 link_ref(link);
1340
1341 return 0;
1342 }
1343
1344 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message,
1345 void *userdata) {
1346 Manager *m = userdata;
1347 Link *link = NULL;
1348 uint16_t type;
1349 _cleanup_address_free_ Address *address = NULL;
1350 Address *ad;
1351 char buf[INET6_ADDRSTRLEN];
1352 char valid_buf[FORMAT_TIMESPAN_MAX];
1353 const char *valid_str = NULL;
1354 bool address_dropped = false;
1355 int r, ifindex;
1356
1357 assert(rtnl);
1358 assert(message);
1359 assert(m);
1360
1361 r = sd_rtnl_message_get_type(message, &type);
1362 if (r < 0) {
1363 log_warning("rtnl: could not get message type");
1364 return 0;
1365 }
1366
1367 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1368 if (r < 0 || ifindex <= 0) {
1369 log_warning("rtnl: received address message without valid ifindex, ignoring");
1370 return 0;
1371 } else {
1372 r = link_get(m, ifindex, &link);
1373 if (r < 0 || !link) {
1374 log_warning("rtnl: received address for a nonexistent link (%d), ignoring", ifindex);
1375 return 0;
1376 }
1377 }
1378
1379 r = address_new_dynamic(&address);
1380 if (r < 0)
1381 return r;
1382
1383 r = sd_rtnl_message_addr_get_family(message, &address->family);
1384 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1385 log_warning_link(link,
1386 "rtnl: received address with invalid family, ignoring");
1387 return 0;
1388 }
1389
1390 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1391 if (r < 0) {
1392 log_warning_link(link,
1393 "rtnl: received address with invalid prefixlen, ignoring");
1394 return 0;
1395 }
1396
1397 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1398 if (r < 0) {
1399 log_warning_link(link,
1400 "rtnl: received address with invalid scope, ignoring");
1401 return 0;
1402 }
1403
1404 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1405 if (r < 0) {
1406 log_warning_link(link,
1407 "rtnl: received address with invalid flags, ignoring");
1408 return 0;
1409 }
1410
1411 switch (address->family) {
1412 case AF_INET:
1413 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1414 &address->in_addr.in);
1415 if (r < 0) {
1416 log_warning_link(link,
1417 "rtnl: received address without valid address, ignoring");
1418 return 0;
1419 }
1420
1421 break;
1422
1423 case AF_INET6:
1424 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1425 &address->in_addr.in6);
1426 if (r < 0) {
1427 log_warning_link(link,
1428 "rtnl: received address without valid address, ignoring");
1429 return 0;
1430 }
1431
1432 break;
1433
1434 default:
1435 assert_not_reached("invalid address family");
1436 }
1437
1438 if (!inet_ntop(address->family, &address->in_addr, buf,
1439 INET6_ADDRSTRLEN)) {
1440 log_warning_link(link, "could not print address");
1441 return 0;
1442 }
1443
1444 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1445 &address->cinfo);
1446 if (r >= 0) {
1447 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1448 valid_str = "ever";
1449 else
1450 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1451 address->cinfo.ifa_valid * USEC_PER_SEC,
1452 USEC_PER_SEC);
1453 }
1454
1455 LIST_FOREACH(addresses, ad, link->addresses) {
1456 if (address_equal(ad, address)) {
1457 LIST_REMOVE(addresses, link->addresses, ad);
1458
1459 address_free(ad);
1460
1461 address_dropped = true;
1462
1463 break;
1464 }
1465 }
1466
1467 switch (type) {
1468 case RTM_NEWADDR:
1469 if (!address_dropped)
1470 log_debug_link(link, "added address: %s/%u (valid for %s)",
1471 buf, address->prefixlen, valid_str);
1472 else
1473 log_debug_link(link, "updated address: %s/%u (valid for %s)",
1474 buf, address->prefixlen, valid_str);
1475
1476 LIST_PREPEND(addresses, link->addresses, address);
1477 address = NULL;
1478
1479 link_save(link);
1480
1481 break;
1482 case RTM_DELADDR:
1483 if (address_dropped) {
1484 log_debug_link(link, "removed address: %s/%u (valid for %s)",
1485 buf, address->prefixlen, valid_str);
1486
1487 link_save(link);
1488 } else
1489 log_warning_link(link,
1490 "removing non-existent address: %s/%u (valid for %s)",
1491 buf, address->prefixlen, valid_str);
1492
1493 break;
1494 default:
1495 assert_not_reached("Received invalid RTNL message type");
1496 }
1497
1498 return 1;
1499 }
1500
1501 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1502 Link *link;
1503 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1504 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1505 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1506 int r;
1507
1508 assert(m);
1509 assert(m->rtnl);
1510 assert(message);
1511 assert(ret);
1512
1513 r = link_new(m, message, ret);
1514 if (r < 0)
1515 return r;
1516
1517 link = *ret;
1518
1519 log_debug_link(link, "link %d added", link->ifindex);
1520
1521 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex,
1522 0);
1523 if (r < 0)
1524 return r;
1525
1526 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0,
1527 NULL);
1528 if (r < 0)
1529 return r;
1530
1531 link_ref(link);
1532
1533 if (detect_container(NULL) <= 0) {
1534 /* not in a container, udev will be around */
1535 sprintf(ifindex_str, "n%d", link->ifindex);
1536 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1537 if (!device) {
1538 log_warning_link(link,
1539 "could not find udev device: %m");
1540 return -errno;
1541 }
1542
1543 if (udev_device_get_is_initialized(device) <= 0) {
1544 /* not yet ready */
1545 log_debug_link(link, "link pending udev initialization...");
1546 return 0;
1547 }
1548
1549 r = link_initialized(link, device);
1550 if (r < 0)
1551 return r;
1552 } else {
1553 /* we are calling a callback directly, so must take a ref */
1554 link_ref(link);
1555
1556 r = link_initialized_and_synced(m->rtnl, NULL, link);
1557 if (r < 0)
1558 return r;
1559 }
1560
1561 return 0;
1562 }
1563
1564 int link_update(Link *link, sd_rtnl_message *m) {
1565 struct ether_addr mac;
1566 const char *ifname;
1567 uint32_t mtu;
1568 bool had_carrier, carrier_gained, carrier_lost;
1569 int r;
1570
1571 assert(link);
1572 assert(link->ifname);
1573 assert(m);
1574
1575 if (link->state == LINK_STATE_LINGER) {
1576 link_ref(link);
1577 log_info_link(link, "link readded");
1578 link->state = LINK_STATE_ENSLAVING;
1579 }
1580
1581 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1582 if (r >= 0 && !streq(ifname, link->ifname)) {
1583 log_info_link(link, "renamed to %s", ifname);
1584
1585 free(link->ifname);
1586 link->ifname = strdup(ifname);
1587 if (!link->ifname)
1588 return -ENOMEM;
1589 }
1590
1591 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1592 if (r >= 0 && mtu > 0) {
1593 link->mtu = mtu;
1594 if (!link->original_mtu) {
1595 link->original_mtu = mtu;
1596 log_debug_link(link, "saved original MTU: %"
1597 PRIu32, link->original_mtu);
1598 }
1599
1600 if (link->dhcp_client) {
1601 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1602 link->mtu);
1603 if (r < 0) {
1604 log_warning_link(link,
1605 "Could not update MTU in DHCP client: %s",
1606 strerror(-r));
1607 return r;
1608 }
1609 }
1610 }
1611
1612 /* The kernel may broadcast NEWLINK messages without the MAC address
1613 set, simply ignore them. */
1614 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1615 if (r >= 0) {
1616 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1617 ETH_ALEN)) {
1618
1619 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1620 ETH_ALEN);
1621
1622 log_debug_link(link, "MAC address: "
1623 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1624 mac.ether_addr_octet[0],
1625 mac.ether_addr_octet[1],
1626 mac.ether_addr_octet[2],
1627 mac.ether_addr_octet[3],
1628 mac.ether_addr_octet[4],
1629 mac.ether_addr_octet[5]);
1630
1631 if (link->ipv4ll) {
1632 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1633 if (r < 0) {
1634 log_warning_link(link,
1635 "Could not update MAC address in IPv4LL client: %s",
1636 strerror(-r));
1637 return r;
1638 }
1639 }
1640
1641 if (link->dhcp_client) {
1642 r = sd_dhcp_client_set_mac(link->dhcp_client,
1643 (const uint8_t *) &link->mac,
1644 sizeof (link->mac),
1645 ARPHRD_ETHER);
1646 if (r < 0) {
1647 log_warning_link(link,
1648 "Could not update MAC address in DHCP client: %s",
1649 strerror(-r));
1650 return r;
1651 }
1652 }
1653
1654 if (link->dhcp6_client) {
1655 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1656 (const uint8_t *) &link->mac,
1657 sizeof (link->mac),
1658 ARPHRD_ETHER);
1659 if (r < 0) {
1660 log_warning_link(link,
1661 "Could not update MAC address in DHCPv6 client: %s",
1662 strerror(-r));
1663 return r;
1664 }
1665 }
1666 }
1667 }
1668
1669 had_carrier = link_has_carrier(link);
1670
1671 r = link_update_flags(link, m);
1672 if (r < 0)
1673 return r;
1674
1675 carrier_gained = !had_carrier && link_has_carrier(link);
1676 carrier_lost = had_carrier && !link_has_carrier(link);
1677
1678 if (carrier_gained) {
1679 log_info_link(link, "gained carrier");
1680
1681 if (link->network) {
1682 r = link_acquire_conf(link);
1683 if (r < 0) {
1684 link_enter_failed(link);
1685 return r;
1686 }
1687 }
1688 } else if (carrier_lost) {
1689 log_info_link(link, "lost carrier");
1690
1691 r = link_stop_clients(link);
1692 if (r < 0) {
1693 link_enter_failed(link);
1694 return r;
1695 }
1696 }
1697
1698 return 0;
1699 }
1700
1701 static void link_update_operstate(Link *link) {
1702
1703 assert(link);
1704
1705 if (link->kernel_operstate == IF_OPER_DORMANT)
1706 link->operstate = LINK_OPERSTATE_DORMANT;
1707 else if (link_has_carrier(link)) {
1708 Address *address;
1709 uint8_t scope = RT_SCOPE_NOWHERE;
1710
1711 /* if we have carrier, check what addresses we have */
1712 LIST_FOREACH(addresses, address, link->addresses) {
1713 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1714 continue;
1715
1716 if (address->scope < scope)
1717 scope = address->scope;
1718 }
1719
1720 if (scope < RT_SCOPE_SITE)
1721 /* universally accessible addresses found */
1722 link->operstate = LINK_OPERSTATE_ROUTABLE;
1723 else if (scope < RT_SCOPE_HOST)
1724 /* only link or site local addresses found */
1725 link->operstate = LINK_OPERSTATE_DEGRADED;
1726 else
1727 /* no useful addresses found */
1728 link->operstate = LINK_OPERSTATE_CARRIER;
1729 } else if (link->flags & IFF_UP)
1730 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1731 else
1732 link->operstate = LINK_OPERSTATE_OFF;
1733 }
1734
1735 int link_save(Link *link) {
1736 _cleanup_free_ char *temp_path = NULL;
1737 _cleanup_fclose_ FILE *f = NULL;
1738 const char *admin_state, *oper_state;
1739 int r;
1740
1741 assert(link);
1742 assert(link->state_file);
1743 assert(link->lease_file);
1744 assert(link->manager);
1745
1746 link_update_operstate(link);
1747
1748 r = manager_save(link->manager);
1749 if (r < 0)
1750 return r;
1751
1752 if (link->state == LINK_STATE_LINGER) {
1753 unlink(link->state_file);
1754 return 0;
1755 }
1756
1757 admin_state = link_state_to_string(link->state);
1758 assert(admin_state);
1759
1760 oper_state = link_operstate_to_string(link->operstate);
1761 assert(oper_state);
1762
1763 r = fopen_temporary(link->state_file, &f, &temp_path);
1764 if (r < 0)
1765 return r;
1766
1767 fchmod(fileno(f), 0644);
1768
1769 fprintf(f,
1770 "# This is private data. Do not parse.\n"
1771 "ADMIN_STATE=%s\n"
1772 "OPER_STATE=%s\n",
1773 admin_state, oper_state);
1774
1775 if (link->network) {
1776 char **address, **domain;
1777 bool space;
1778
1779 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1780
1781 fputs("DNS=", f);
1782 space = false;
1783 STRV_FOREACH(address, link->network->dns) {
1784 if (space)
1785 fputc(' ', f);
1786 fputs(*address, f);
1787 space = true;
1788 }
1789
1790 if (link->network->dhcp_dns &&
1791 link->dhcp_lease) {
1792 const struct in_addr *addresses;
1793
1794 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1795 if (r > 0) {
1796 if (space)
1797 fputc(' ', f);
1798 serialize_in_addrs(f, addresses, r);
1799 }
1800 }
1801
1802 fputs("\n", f);
1803
1804 fprintf(f, "NTP=");
1805 space = false;
1806 STRV_FOREACH(address, link->network->ntp) {
1807 if (space)
1808 fputc(' ', f);
1809 fputs(*address, f);
1810 space = true;
1811 }
1812
1813 if (link->network->dhcp_ntp &&
1814 link->dhcp_lease) {
1815 const struct in_addr *addresses;
1816
1817 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1818 if (r > 0) {
1819 if (space)
1820 fputc(' ', f);
1821 serialize_in_addrs(f, addresses, r);
1822 }
1823 }
1824
1825 fputs("\n", f);
1826
1827 fprintf(f, "DOMAINS=");
1828 space = false;
1829 STRV_FOREACH(domain, link->network->domains) {
1830 if (space)
1831 fputc(' ', f);
1832 fputs(*domain, f);
1833 space = true;
1834 }
1835
1836 if (link->network->dhcp_domains &&
1837 link->dhcp_lease) {
1838 const char *domainname;
1839
1840 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1841 if (r >= 0) {
1842 if (space)
1843 fputc(' ', f);
1844 fputs(domainname, f);
1845 }
1846 }
1847
1848 fputs("\n", f);
1849
1850 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1851 yes_no(link->network->wildcard_domain));
1852
1853 fprintf(f, "LLMNR=%s\n",
1854 llmnr_support_to_string(link->network->llmnr));
1855 }
1856
1857 if (link->dhcp_lease) {
1858 assert(link->network);
1859
1860 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
1861 if (r < 0)
1862 goto fail;
1863
1864 fprintf(f,
1865 "DHCP_LEASE=%s\n",
1866 link->lease_file);
1867 } else
1868 unlink(link->lease_file);
1869
1870 r = fflush_and_check(f);
1871 if (r < 0)
1872 goto fail;
1873
1874 if (rename(temp_path, link->state_file) < 0) {
1875 r = -errno;
1876 goto fail;
1877 }
1878
1879 return 0;
1880 fail:
1881 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1882 unlink(link->state_file);
1883 unlink(temp_path);
1884 return r;
1885 }
1886
1887 static const char* const link_state_table[_LINK_STATE_MAX] = {
1888 [LINK_STATE_PENDING] = "pending",
1889 [LINK_STATE_ENSLAVING] = "configuring",
1890 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1891 [LINK_STATE_SETTING_ROUTES] = "configuring",
1892 [LINK_STATE_CONFIGURED] = "configured",
1893 [LINK_STATE_UNMANAGED] = "unmanaged",
1894 [LINK_STATE_FAILED] = "failed",
1895 [LINK_STATE_LINGER] = "linger",
1896 };
1897
1898 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1899
1900 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1901 [LINK_OPERSTATE_OFF] = "off",
1902 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1903 [LINK_OPERSTATE_DORMANT] = "dormant",
1904 [LINK_OPERSTATE_CARRIER] = "carrier",
1905 [LINK_OPERSTATE_DEGRADED] = "degraded",
1906 [LINK_OPERSTATE_ROUTABLE] = "routable",
1907 };
1908
1909 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
Unnamed repository; edit this file 'description' to name the repository.