2 This file is part of systemd.
4 Copyright 2014 Tom Gundersen <teg@jklm.no>
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 #include <netinet/in.h>
22 #include <sys/ioctl.h>
25 #include "alloc-util.h"
26 #include "dirent-util.h"
27 #include "dns-domain.h"
29 #include "fileio-label.h"
30 #include "hostname-util.h"
32 #include "netlink-util.h"
33 #include "network-internal.h"
34 #include "ordered-set.h"
35 #include "parse-util.h"
36 #include "random-util.h"
37 #include "resolved-bus.h"
38 #include "resolved-conf.h"
39 #include "resolved-etc-hosts.h"
40 #include "resolved-llmnr.h"
41 #include "resolved-manager.h"
42 #include "resolved-mdns.h"
43 #include "resolved-resolv-conf.h"
44 #include "socket-util.h"
45 #include "string-table.h"
46 #include "string-util.h"
49 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
51 static int manager_process_link(sd_netlink
*rtnl
, sd_netlink_message
*mm
, void *userdata
) {
52 Manager
*m
= userdata
;
61 r
= sd_netlink_message_get_type(mm
, &type
);
65 r
= sd_rtnl_message_link_get_ifindex(mm
, &ifindex
);
69 l
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
77 r
= link_new(m
, &l
, ifindex
);
82 r
= link_process_rtnl(l
, mm
);
91 log_debug("Found new link %i/%s", ifindex
, l
->name
);
98 log_debug("Removing link %i/%s", l
->ifindex
, l
->name
);
109 log_warning_errno(r
, "Failed to process RTNL link message: %m");
113 static int manager_process_address(sd_netlink
*rtnl
, sd_netlink_message
*mm
, void *userdata
) {
114 Manager
*m
= userdata
;
115 union in_addr_union address
;
117 int r
, ifindex
, family
;
125 r
= sd_netlink_message_get_type(mm
, &type
);
129 r
= sd_rtnl_message_addr_get_ifindex(mm
, &ifindex
);
133 l
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
137 r
= sd_rtnl_message_addr_get_family(mm
, &family
);
144 r
= sd_netlink_message_read_in_addr(mm
, IFA_LOCAL
, &address
.in
);
146 r
= sd_netlink_message_read_in_addr(mm
, IFA_ADDRESS
, &address
.in
);
154 r
= sd_netlink_message_read_in6_addr(mm
, IFA_LOCAL
, &address
.in6
);
156 r
= sd_netlink_message_read_in6_addr(mm
, IFA_ADDRESS
, &address
.in6
);
167 a
= link_find_address(l
, family
, &address
);
174 r
= link_address_new(l
, &a
, family
, &address
);
179 r
= link_address_update_rtnl(a
, mm
);
186 link_address_free(a
);
193 log_warning_errno(r
, "Failed to process RTNL address message: %m");
197 static int manager_rtnl_listen(Manager
*m
) {
198 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
199 sd_netlink_message
*i
;
204 /* First, subscribe to interfaces coming and going */
205 r
= sd_netlink_open(&m
->rtnl
);
209 r
= sd_netlink_attach_event(m
->rtnl
, m
->event
, SD_EVENT_PRIORITY_IMPORTANT
);
213 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWLINK
, manager_process_link
, m
);
217 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELLINK
, manager_process_link
, m
);
221 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWADDR
, manager_process_address
, m
);
225 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELADDR
, manager_process_address
, m
);
229 /* Then, enumerate all links */
230 r
= sd_rtnl_message_new_link(m
->rtnl
, &req
, RTM_GETLINK
, 0);
234 r
= sd_netlink_message_request_dump(req
, true);
238 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
242 for (i
= reply
; i
; i
= sd_netlink_message_next(i
)) {
243 r
= manager_process_link(m
->rtnl
, i
, m
);
248 req
= sd_netlink_message_unref(req
);
249 reply
= sd_netlink_message_unref(reply
);
251 /* Finally, enumerate all addresses, too */
252 r
= sd_rtnl_message_new_addr(m
->rtnl
, &req
, RTM_GETADDR
, 0, AF_UNSPEC
);
256 r
= sd_netlink_message_request_dump(req
, true);
260 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
264 for (i
= reply
; i
; i
= sd_netlink_message_next(i
)) {
265 r
= manager_process_address(m
->rtnl
, i
, m
);
273 static int on_network_event(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
274 Manager
*m
= userdata
;
281 sd_network_monitor_flush(m
->network_monitor
);
283 HASHMAP_FOREACH(l
, m
->links
, i
) {
286 log_warning_errno(r
, "Failed to update monitor information for %i: %m", l
->ifindex
);
289 (void) manager_write_resolv_conf(m
);
294 static int manager_network_monitor_listen(Manager
*m
) {
299 r
= sd_network_monitor_new(&m
->network_monitor
, NULL
);
303 fd
= sd_network_monitor_get_fd(m
->network_monitor
);
307 events
= sd_network_monitor_get_events(m
->network_monitor
);
311 r
= sd_event_add_io(m
->event
, &m
->network_event_source
, fd
, events
, &on_network_event
, m
);
315 r
= sd_event_source_set_priority(m
->network_event_source
, SD_EVENT_PRIORITY_IMPORTANT
+5);
319 (void) sd_event_source_set_description(m
->network_event_source
, "network-monitor");
324 static int determine_hostname(char **llmnr_hostname
, char **mdns_hostname
) {
325 _cleanup_free_
char *h
= NULL
, *n
= NULL
;
326 char label
[DNS_LABEL_MAX
];
330 assert(llmnr_hostname
);
331 assert(mdns_hostname
);
333 /* Extract and normalize the first label of the locally
334 * configured hostname, and check it's not "localhost". */
336 h
= gethostname_malloc();
341 r
= dns_label_unescape(&p
, label
, sizeof(label
));
343 return log_error_errno(r
, "Failed to unescape host name: %m");
345 log_error("Couldn't find a single label in hosntame.");
349 k
= dns_label_undo_idna(label
, r
, label
, sizeof(label
));
351 return log_error_errno(k
, "Failed to undo IDNA: %m");
355 if (!utf8_is_valid(label
)) {
356 log_error("System hostname is not UTF-8 clean.");
360 r
= dns_label_escape_new(label
, r
, &n
);
362 return log_error_errno(r
, "Failed to escape host name: %m");
364 if (is_localhost(n
)) {
365 log_debug("System hostname is 'localhost', ignoring.");
369 r
= dns_name_concat(n
, "local", mdns_hostname
);
371 return log_error_errno(r
, "Failed to determine mDNS hostname: %m");
379 static int on_hostname_change(sd_event_source
*es
, int fd
, uint32_t revents
, void *userdata
) {
380 _cleanup_free_
char *llmnr_hostname
= NULL
, *mdns_hostname
= NULL
;
381 Manager
*m
= userdata
;
386 r
= determine_hostname(&llmnr_hostname
, &mdns_hostname
);
388 return 0; /* ignore invalid hostnames */
390 if (streq(llmnr_hostname
, m
->llmnr_hostname
) && streq(mdns_hostname
, m
->mdns_hostname
))
393 log_info("System hostname changed to '%s'.", llmnr_hostname
);
395 free(m
->llmnr_hostname
);
396 free(m
->mdns_hostname
);
398 m
->llmnr_hostname
= llmnr_hostname
;
399 m
->mdns_hostname
= mdns_hostname
;
401 llmnr_hostname
= mdns_hostname
= NULL
;
403 manager_refresh_rrs(m
);
408 static int manager_watch_hostname(Manager
*m
) {
413 m
->hostname_fd
= open("/proc/sys/kernel/hostname", O_RDONLY
|O_CLOEXEC
|O_NDELAY
|O_NOCTTY
);
414 if (m
->hostname_fd
< 0) {
415 log_warning_errno(errno
, "Failed to watch hostname: %m");
419 r
= sd_event_add_io(m
->event
, &m
->hostname_event_source
, m
->hostname_fd
, 0, on_hostname_change
, m
);
422 /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */
423 m
->hostname_fd
= safe_close(m
->hostname_fd
);
425 return log_error_errno(r
, "Failed to add hostname event source: %m");
428 (void) sd_event_source_set_description(m
->hostname_event_source
, "hostname");
430 r
= determine_hostname(&m
->llmnr_hostname
, &m
->mdns_hostname
);
432 log_info("Defaulting to hostname 'linux'.");
433 m
->llmnr_hostname
= strdup("linux");
434 if (!m
->llmnr_hostname
)
437 m
->mdns_hostname
= strdup("linux.local");
438 if (!m
->mdns_hostname
)
441 log_info("Using system hostname '%s'.", m
->llmnr_hostname
);
446 static int manager_sigusr1(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
447 _cleanup_free_
char *buffer
= NULL
;
448 _cleanup_fclose_
FILE *f
= NULL
;
449 Manager
*m
= userdata
;
457 f
= open_memstream(&buffer
, &size
);
461 LIST_FOREACH(scopes
, scope
, m
->dns_scopes
)
462 dns_scope_dump(scope
, f
);
464 if (fflush_and_check(f
) < 0)
467 log_dump(LOG_INFO
, buffer
);
471 static int manager_sigusr2(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
472 Manager
*m
= userdata
;
478 manager_flush_caches(m
);
483 int manager_new(Manager
**ret
) {
484 _cleanup_(manager_freep
) Manager
*m
= NULL
;
489 m
= new0(Manager
, 1);
493 m
->llmnr_ipv4_udp_fd
= m
->llmnr_ipv6_udp_fd
= -1;
494 m
->llmnr_ipv4_tcp_fd
= m
->llmnr_ipv6_tcp_fd
= -1;
495 m
->mdns_ipv4_fd
= m
->mdns_ipv6_fd
= -1;
498 m
->llmnr_support
= RESOLVE_SUPPORT_YES
;
499 m
->mdns_support
= RESOLVE_SUPPORT_NO
;
500 m
->dnssec_mode
= DEFAULT_DNSSEC_MODE
;
501 m
->read_resolv_conf
= true;
502 m
->need_builtin_fallbacks
= true;
503 m
->etc_hosts_last
= m
->etc_hosts_mtime
= USEC_INFINITY
;
505 r
= dns_trust_anchor_load(&m
->trust_anchor
);
509 r
= manager_parse_config_file(m
);
513 r
= sd_event_default(&m
->event
);
517 sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
518 sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
520 sd_event_set_watchdog(m
->event
, true);
522 r
= manager_watch_hostname(m
);
526 r
= dns_scope_new(m
, &m
->unicast_scope
, NULL
, DNS_PROTOCOL_DNS
, AF_UNSPEC
);
530 r
= manager_network_monitor_listen(m
);
534 r
= manager_rtnl_listen(m
);
538 r
= manager_connect_bus(m
);
542 (void) sd_event_add_signal(m
->event
, &m
->sigusr1_event_source
, SIGUSR1
, manager_sigusr1
, m
);
543 (void) sd_event_add_signal(m
->event
, &m
->sigusr2_event_source
, SIGUSR2
, manager_sigusr2
, m
);
545 manager_cleanup_saved_user(m
);
553 int manager_start(Manager
*m
) {
558 r
= manager_llmnr_start(m
);
562 r
= manager_mdns_start(m
);
569 Manager
*manager_free(Manager
*m
) {
575 dns_server_unlink_all(m
->dns_servers
);
576 dns_server_unlink_all(m
->fallback_dns_servers
);
577 dns_search_domain_unlink_all(m
->search_domains
);
579 while ((l
= hashmap_first(m
->links
)))
582 while (m
->dns_queries
)
583 dns_query_free(m
->dns_queries
);
585 dns_scope_free(m
->unicast_scope
);
587 hashmap_free(m
->links
);
588 hashmap_free(m
->dns_transactions
);
590 sd_event_source_unref(m
->network_event_source
);
591 sd_network_monitor_unref(m
->network_monitor
);
593 sd_netlink_unref(m
->rtnl
);
594 sd_event_source_unref(m
->rtnl_event_source
);
596 manager_llmnr_stop(m
);
597 manager_mdns_stop(m
);
599 sd_bus_slot_unref(m
->prepare_for_sleep_slot
);
600 sd_event_source_unref(m
->bus_retry_event_source
);
601 sd_bus_unref(m
->bus
);
603 sd_event_source_unref(m
->sigusr1_event_source
);
604 sd_event_source_unref(m
->sigusr2_event_source
);
606 sd_event_unref(m
->event
);
608 dns_resource_key_unref(m
->llmnr_host_ipv4_key
);
609 dns_resource_key_unref(m
->llmnr_host_ipv6_key
);
611 sd_event_source_unref(m
->hostname_event_source
);
612 safe_close(m
->hostname_fd
);
613 free(m
->llmnr_hostname
);
614 free(m
->mdns_hostname
);
616 dns_trust_anchor_flush(&m
->trust_anchor
);
617 manager_etc_hosts_flush(m
);
624 int manager_recv(Manager
*m
, int fd
, DnsProtocol protocol
, DnsPacket
**ret
) {
625 _cleanup_(dns_packet_unrefp
) DnsPacket
*p
= NULL
;
627 struct cmsghdr header
; /* For alignment */
628 uint8_t buffer
[CMSG_SPACE(MAXSIZE(struct in_pktinfo
, struct in6_pktinfo
))
629 + CMSG_SPACE(int) /* ttl/hoplimit */
630 + EXTRA_CMSG_SPACE
/* kernel appears to require extra buffer space */];
632 union sockaddr_union sa
;
633 struct msghdr mh
= {};
634 struct cmsghdr
*cmsg
;
643 ms
= next_datagram_size_fd(fd
);
647 r
= dns_packet_new(&p
, protocol
, ms
);
651 iov
.iov_base
= DNS_PACKET_DATA(p
);
652 iov
.iov_len
= p
->allocated
;
654 mh
.msg_name
= &sa
.sa
;
655 mh
.msg_namelen
= sizeof(sa
);
658 mh
.msg_control
= &control
;
659 mh
.msg_controllen
= sizeof(control
);
661 l
= recvmsg(fd
, &mh
, 0);
665 if (errno
== EAGAIN
|| errno
== EINTR
)
671 assert(!(mh
.msg_flags
& MSG_CTRUNC
));
672 assert(!(mh
.msg_flags
& MSG_TRUNC
));
674 p
->size
= (size_t) l
;
676 p
->family
= sa
.sa
.sa_family
;
677 p
->ipproto
= IPPROTO_UDP
;
678 if (p
->family
== AF_INET
) {
679 p
->sender
.in
= sa
.in
.sin_addr
;
680 p
->sender_port
= be16toh(sa
.in
.sin_port
);
681 } else if (p
->family
== AF_INET6
) {
682 p
->sender
.in6
= sa
.in6
.sin6_addr
;
683 p
->sender_port
= be16toh(sa
.in6
.sin6_port
);
684 p
->ifindex
= sa
.in6
.sin6_scope_id
;
686 return -EAFNOSUPPORT
;
688 CMSG_FOREACH(cmsg
, &mh
) {
690 if (cmsg
->cmsg_level
== IPPROTO_IPV6
) {
691 assert(p
->family
== AF_INET6
);
693 switch (cmsg
->cmsg_type
) {
696 struct in6_pktinfo
*i
= (struct in6_pktinfo
*) CMSG_DATA(cmsg
);
699 p
->ifindex
= i
->ipi6_ifindex
;
701 p
->destination
.in6
= i
->ipi6_addr
;
706 p
->ttl
= *(int *) CMSG_DATA(cmsg
);
710 } else if (cmsg
->cmsg_level
== IPPROTO_IP
) {
711 assert(p
->family
== AF_INET
);
713 switch (cmsg
->cmsg_type
) {
716 struct in_pktinfo
*i
= (struct in_pktinfo
*) CMSG_DATA(cmsg
);
719 p
->ifindex
= i
->ipi_ifindex
;
721 p
->destination
.in
= i
->ipi_addr
;
726 p
->ttl
= *(int *) CMSG_DATA(cmsg
);
732 /* The Linux kernel sets the interface index to the loopback
733 * device if the packet came from the local host since it
734 * avoids the routing table in such a case. Let's unset the
735 * interface index in such a case. */
736 if (p
->ifindex
== LOOPBACK_IFINDEX
)
739 if (protocol
!= DNS_PROTOCOL_DNS
) {
740 /* If we don't know the interface index still, we look for the
741 * first local interface with a matching address. Yuck! */
743 p
->ifindex
= manager_find_ifindex(m
, p
->family
, &p
->destination
);
752 static int sendmsg_loop(int fd
, struct msghdr
*mh
, int flags
) {
759 if (sendmsg(fd
, mh
, flags
) >= 0)
768 r
= fd_wait_for_event(fd
, POLLOUT
, SEND_TIMEOUT_USEC
);
776 static int write_loop(int fd
, void *message
, size_t length
) {
783 if (write(fd
, message
, length
) >= 0)
792 r
= fd_wait_for_event(fd
, POLLOUT
, SEND_TIMEOUT_USEC
);
800 int manager_write(Manager
*m
, int fd
, DnsPacket
*p
) {
803 log_debug("Sending %s packet with id %" PRIu16
".", DNS_PACKET_QR(p
) ? "response" : "query", DNS_PACKET_ID(p
));
805 r
= write_loop(fd
, DNS_PACKET_DATA(p
), p
->size
);
812 static int manager_ipv4_send(Manager
*m
, int fd
, int ifindex
, const struct in_addr
*addr
, uint16_t port
, DnsPacket
*p
) {
813 union sockaddr_union sa
= {
814 .in
.sin_family
= AF_INET
,
817 struct cmsghdr header
; /* For alignment */
818 uint8_t buffer
[CMSG_SPACE(sizeof(struct in_pktinfo
))];
820 struct msghdr mh
= {};
829 iov
.iov_base
= DNS_PACKET_DATA(p
);
830 iov
.iov_len
= p
->size
;
832 sa
.in
.sin_addr
= *addr
;
833 sa
.in
.sin_port
= htobe16(port
),
837 mh
.msg_name
= &sa
.sa
;
838 mh
.msg_namelen
= sizeof(sa
.in
);
841 struct cmsghdr
*cmsg
;
842 struct in_pktinfo
*pi
;
846 mh
.msg_control
= &control
;
847 mh
.msg_controllen
= CMSG_LEN(sizeof(struct in_pktinfo
));
849 cmsg
= CMSG_FIRSTHDR(&mh
);
850 cmsg
->cmsg_len
= mh
.msg_controllen
;
851 cmsg
->cmsg_level
= IPPROTO_IP
;
852 cmsg
->cmsg_type
= IP_PKTINFO
;
854 pi
= (struct in_pktinfo
*) CMSG_DATA(cmsg
);
855 pi
->ipi_ifindex
= ifindex
;
858 return sendmsg_loop(fd
, &mh
, 0);
861 static int manager_ipv6_send(Manager
*m
, int fd
, int ifindex
, const struct in6_addr
*addr
, uint16_t port
, DnsPacket
*p
) {
862 union sockaddr_union sa
= {
863 .in6
.sin6_family
= AF_INET6
,
866 struct cmsghdr header
; /* For alignment */
867 uint8_t buffer
[CMSG_SPACE(sizeof(struct in6_pktinfo
))];
869 struct msghdr mh
= {};
878 iov
.iov_base
= DNS_PACKET_DATA(p
);
879 iov
.iov_len
= p
->size
;
881 sa
.in6
.sin6_addr
= *addr
;
882 sa
.in6
.sin6_port
= htobe16(port
),
883 sa
.in6
.sin6_scope_id
= ifindex
;
887 mh
.msg_name
= &sa
.sa
;
888 mh
.msg_namelen
= sizeof(sa
.in6
);
891 struct cmsghdr
*cmsg
;
892 struct in6_pktinfo
*pi
;
896 mh
.msg_control
= &control
;
897 mh
.msg_controllen
= CMSG_LEN(sizeof(struct in6_pktinfo
));
899 cmsg
= CMSG_FIRSTHDR(&mh
);
900 cmsg
->cmsg_len
= mh
.msg_controllen
;
901 cmsg
->cmsg_level
= IPPROTO_IPV6
;
902 cmsg
->cmsg_type
= IPV6_PKTINFO
;
904 pi
= (struct in6_pktinfo
*) CMSG_DATA(cmsg
);
905 pi
->ipi6_ifindex
= ifindex
;
908 return sendmsg_loop(fd
, &mh
, 0);
911 int manager_send(Manager
*m
, int fd
, int ifindex
, int family
, const union in_addr_union
*addr
, uint16_t port
, DnsPacket
*p
) {
918 log_debug("Sending %s packet with id %" PRIu16
" on interface %i/%s.", DNS_PACKET_QR(p
) ? "response" : "query", DNS_PACKET_ID(p
), ifindex
, af_to_name(family
));
920 if (family
== AF_INET
)
921 return manager_ipv4_send(m
, fd
, ifindex
, &addr
->in
, port
, p
);
922 if (family
== AF_INET6
)
923 return manager_ipv6_send(m
, fd
, ifindex
, &addr
->in6
, port
, p
);
925 return -EAFNOSUPPORT
;
928 uint32_t manager_find_mtu(Manager
*m
) {
933 /* If we don't know on which link a DNS packet would be
934 * delivered, let's find the largest MTU that works on all
935 * interfaces we know of */
937 HASHMAP_FOREACH(l
, m
->links
, i
) {
941 if (mtu
<= 0 || l
->mtu
< mtu
)
948 int manager_find_ifindex(Manager
*m
, int family
, const union in_addr_union
*in_addr
) {
953 a
= manager_find_link_address(m
, family
, in_addr
);
955 return a
->link
->ifindex
;
960 void manager_refresh_rrs(Manager
*m
) {
966 m
->llmnr_host_ipv4_key
= dns_resource_key_unref(m
->llmnr_host_ipv4_key
);
967 m
->llmnr_host_ipv6_key
= dns_resource_key_unref(m
->llmnr_host_ipv6_key
);
969 HASHMAP_FOREACH(l
, m
->links
, i
) {
970 link_add_rrs(l
, true);
971 link_add_rrs(l
, false);
975 int manager_next_hostname(Manager
*m
) {
983 p
= strchr(m
->llmnr_hostname
, 0);
986 while (p
> m
->llmnr_hostname
) {
987 if (!strchr("0123456789", p
[-1]))
993 if (*p
== 0 || safe_atou64(p
, &u
) < 0 || u
<= 0)
996 /* Add a random number to the old value. This way we can avoid
997 * that two hosts pick the same hostname, win on IPv4 and lose
998 * on IPv6 (or vice versa), and pick the same hostname
999 * replacement hostname, ad infinitum. We still want the
1000 * numbers to go up monotonically, hence we just add a random
1003 random_bytes(&a
, sizeof(a
));
1006 if (asprintf(&h
, "%.*s%" PRIu64
, (int) (p
- m
->llmnr_hostname
), m
->llmnr_hostname
, u
) < 0)
1009 r
= dns_name_concat(h
, "local", &k
);
1015 log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m
->llmnr_hostname
, h
);
1017 free(m
->llmnr_hostname
);
1018 m
->llmnr_hostname
= h
;
1020 free(m
->mdns_hostname
);
1021 m
->mdns_hostname
= k
;
1023 manager_refresh_rrs(m
);
1028 LinkAddress
* manager_find_link_address(Manager
*m
, int family
, const union in_addr_union
*in_addr
) {
1034 HASHMAP_FOREACH(l
, m
->links
, i
) {
1037 a
= link_find_address(l
, family
, in_addr
);
1045 bool manager_our_packet(Manager
*m
, DnsPacket
*p
) {
1049 return !!manager_find_link_address(m
, p
->family
, &p
->sender
);
1052 DnsScope
* manager_find_scope(Manager
*m
, DnsPacket
*p
) {
1058 l
= hashmap_get(m
->links
, INT_TO_PTR(p
->ifindex
));
1062 switch (p
->protocol
) {
1063 case DNS_PROTOCOL_LLMNR
:
1064 if (p
->family
== AF_INET
)
1065 return l
->llmnr_ipv4_scope
;
1066 else if (p
->family
== AF_INET6
)
1067 return l
->llmnr_ipv6_scope
;
1071 case DNS_PROTOCOL_MDNS
:
1072 if (p
->family
== AF_INET
)
1073 return l
->mdns_ipv4_scope
;
1074 else if (p
->family
== AF_INET6
)
1075 return l
->mdns_ipv6_scope
;
1086 void manager_verify_all(Manager
*m
) {
1091 LIST_FOREACH(scopes
, s
, m
->dns_scopes
)
1092 dns_zone_verify_all(&s
->zone
);
1095 int manager_is_own_hostname(Manager
*m
, const char *name
) {
1101 if (m
->llmnr_hostname
) {
1102 r
= dns_name_equal(name
, m
->llmnr_hostname
);
1107 if (m
->mdns_hostname
)
1108 return dns_name_equal(name
, m
->mdns_hostname
);
1113 int manager_compile_dns_servers(Manager
*m
, OrderedSet
**dns
) {
1122 r
= ordered_set_ensure_allocated(dns
, &dns_server_hash_ops
);
1126 /* First add the system-wide servers and domains */
1127 LIST_FOREACH(servers
, s
, m
->dns_servers
) {
1128 r
= ordered_set_put(*dns
, s
);
1135 /* Then, add the per-link servers */
1136 HASHMAP_FOREACH(l
, m
->links
, i
) {
1137 LIST_FOREACH(servers
, s
, l
->dns_servers
) {
1138 r
= ordered_set_put(*dns
, s
);
1146 /* If we found nothing, add the fallback servers */
1147 if (ordered_set_isempty(*dns
)) {
1148 LIST_FOREACH(servers
, s
, m
->fallback_dns_servers
) {
1149 r
= ordered_set_put(*dns
, s
);
1160 int manager_compile_search_domains(Manager
*m
, OrderedSet
**domains
, int filter_route
) {
1169 r
= ordered_set_ensure_allocated(domains
, &dns_name_hash_ops
);
1173 LIST_FOREACH(domains
, d
, m
->search_domains
) {
1175 if (filter_route
>= 0 &&
1176 d
->route_only
!= !!filter_route
)
1179 r
= ordered_set_put(*domains
, d
->name
);
1186 HASHMAP_FOREACH(l
, m
->links
, i
) {
1188 LIST_FOREACH(domains
, d
, l
->search_domains
) {
1190 if (filter_route
>= 0 &&
1191 d
->route_only
!= !!filter_route
)
1194 r
= ordered_set_put(*domains
, d
->name
);
1205 DnssecMode
manager_get_dnssec_mode(Manager
*m
) {
1208 if (m
->dnssec_mode
!= _DNSSEC_MODE_INVALID
)
1209 return m
->dnssec_mode
;
1214 bool manager_dnssec_supported(Manager
*m
) {
1221 if (manager_get_dnssec_mode(m
) == DNSSEC_NO
)
1224 server
= manager_get_dns_server(m
);
1225 if (server
&& !dns_server_dnssec_supported(server
))
1228 HASHMAP_FOREACH(l
, m
->links
, i
)
1229 if (!link_dnssec_supported(l
))
1235 void manager_dnssec_verdict(Manager
*m
, DnssecVerdict verdict
, const DnsResourceKey
*key
) {
1237 assert(verdict
>= 0);
1238 assert(verdict
< _DNSSEC_VERDICT_MAX
);
1240 if (log_get_max_level() >= LOG_DEBUG
) {
1241 char s
[DNS_RESOURCE_KEY_STRING_MAX
];
1243 log_debug("Found verdict for lookup %s: %s",
1244 dns_resource_key_to_string(key
, s
, sizeof s
),
1245 dnssec_verdict_to_string(verdict
));
1248 m
->n_dnssec_verdict
[verdict
]++;
1251 bool manager_routable(Manager
*m
, int family
) {
1257 /* Returns true if the host has at least one interface with a routable address of the specified type */
1259 HASHMAP_FOREACH(l
, m
->links
, i
)
1260 if (link_relevant(l
, family
, false))
1266 void manager_flush_caches(Manager
*m
) {
1271 LIST_FOREACH(scopes
, scope
, m
->dns_scopes
)
1272 dns_cache_flush(&scope
->cache
);
1274 log_info("Flushed all caches.");
1277 void manager_cleanup_saved_user(Manager
*m
) {
1278 _cleanup_closedir_
DIR *d
= NULL
;
1284 /* Clean up all saved per-link files in /run/systemd/resolve/netif/ that don't have a matching interface
1285 * anymore. These files are created to persist settings pushed in by the user via the bus, so that resolved can
1286 * be restarted without losing this data. */
1288 d
= opendir("/run/systemd/resolve/netif/");
1290 if (errno
== ENOENT
)
1293 log_warning_errno(errno
, "Failed to open interface directory: %m");
1297 FOREACH_DIRENT_ALL(de
, d
, log_error_errno(errno
, "Failed to read interface directory: %m")) {
1298 _cleanup_free_
char *p
= NULL
;
1302 if (!IN_SET(de
->d_type
, DT_UNKNOWN
, DT_REG
))
1305 if (STR_IN_SET(de
->d_name
, ".", ".."))
1308 r
= parse_ifindex(de
->d_name
, &ifindex
);
1309 if (r
< 0) /* Probably some temporary file from a previous run. Delete it */
1312 l
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
1313 if (!l
) /* link vanished */
1316 if (l
->is_managed
) /* now managed by networkd, hence the bus settings are useless */
1322 p
= strappend("/run/systemd/resolve/netif/", de
->d_name
);