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