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