1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2014 Tom Gundersen <teg@jklm.no>
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 #include <netinet/in.h>
23 #include <sys/ioctl.h>
30 #include "alloc-util.h"
31 #include "dirent-util.h"
32 #include "dns-domain.h"
34 #include "fileio-label.h"
35 #include "hostname-util.h"
37 #include "netlink-util.h"
38 #include "network-internal.h"
39 #include "ordered-set.h"
40 #include "parse-util.h"
41 #include "random-util.h"
42 #include "resolved-bus.h"
43 #include "resolved-conf.h"
44 #include "resolved-dnssd.h"
45 #include "resolved-dns-stub.h"
46 #include "resolved-etc-hosts.h"
47 #include "resolved-llmnr.h"
48 #include "resolved-manager.h"
49 #include "resolved-mdns.h"
50 #include "resolved-resolv-conf.h"
51 #include "socket-util.h"
52 #include "string-table.h"
53 #include "string-util.h"
56 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
58 static int manager_process_link(sd_netlink
*rtnl
, sd_netlink_message
*mm
, void *userdata
) {
59 Manager
*m
= userdata
;
68 r
= sd_netlink_message_get_type(mm
, &type
);
72 r
= sd_rtnl_message_link_get_ifindex(mm
, &ifindex
);
76 l
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
84 r
= link_new(m
, &l
, ifindex
);
89 r
= link_process_rtnl(l
, mm
);
98 log_debug("Found new link %i/%s", ifindex
, l
->name
);
105 log_debug("Removing link %i/%s", l
->ifindex
, l
->name
);
116 log_warning_errno(r
, "Failed to process RTNL link message: %m");
120 static int manager_process_address(sd_netlink
*rtnl
, sd_netlink_message
*mm
, void *userdata
) {
121 Manager
*m
= userdata
;
122 union in_addr_union address
;
124 int r
, ifindex
, family
;
132 r
= sd_netlink_message_get_type(mm
, &type
);
136 r
= sd_rtnl_message_addr_get_ifindex(mm
, &ifindex
);
140 l
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
144 r
= sd_rtnl_message_addr_get_family(mm
, &family
);
151 r
= sd_netlink_message_read_in_addr(mm
, IFA_LOCAL
, &address
.in
);
153 r
= sd_netlink_message_read_in_addr(mm
, IFA_ADDRESS
, &address
.in
);
161 r
= sd_netlink_message_read_in6_addr(mm
, IFA_LOCAL
, &address
.in6
);
163 r
= sd_netlink_message_read_in6_addr(mm
, IFA_ADDRESS
, &address
.in6
);
174 a
= link_find_address(l
, family
, &address
);
181 r
= link_address_new(l
, &a
, family
, &address
);
186 r
= link_address_update_rtnl(a
, mm
);
193 link_address_free(a
);
200 log_warning_errno(r
, "Failed to process RTNL address message: %m");
204 static int manager_rtnl_listen(Manager
*m
) {
205 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
, *reply
= NULL
;
206 sd_netlink_message
*i
;
211 /* First, subscribe to interfaces coming and going */
212 r
= sd_netlink_open(&m
->rtnl
);
216 r
= sd_netlink_attach_event(m
->rtnl
, m
->event
, SD_EVENT_PRIORITY_IMPORTANT
);
220 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWLINK
, manager_process_link
, m
);
224 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELLINK
, manager_process_link
, m
);
228 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWADDR
, manager_process_address
, m
);
232 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELADDR
, manager_process_address
, m
);
236 /* Then, enumerate all links */
237 r
= sd_rtnl_message_new_link(m
->rtnl
, &req
, RTM_GETLINK
, 0);
241 r
= sd_netlink_message_request_dump(req
, true);
245 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
249 for (i
= reply
; i
; i
= sd_netlink_message_next(i
)) {
250 r
= manager_process_link(m
->rtnl
, i
, m
);
255 req
= sd_netlink_message_unref(req
);
256 reply
= sd_netlink_message_unref(reply
);
258 /* Finally, enumerate all addresses, too */
259 r
= sd_rtnl_message_new_addr(m
->rtnl
, &req
, RTM_GETADDR
, 0, AF_UNSPEC
);
263 r
= sd_netlink_message_request_dump(req
, true);
267 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
271 for (i
= reply
; i
; i
= sd_netlink_message_next(i
)) {
272 r
= manager_process_address(m
->rtnl
, i
, m
);
280 static int on_network_event(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
281 Manager
*m
= userdata
;
288 sd_network_monitor_flush(m
->network_monitor
);
290 HASHMAP_FOREACH(l
, m
->links
, i
) {
293 log_warning_errno(r
, "Failed to update monitor information for %i: %m", l
->ifindex
);
296 (void) manager_write_resolv_conf(m
);
301 static int manager_network_monitor_listen(Manager
*m
) {
306 r
= sd_network_monitor_new(&m
->network_monitor
, NULL
);
310 fd
= sd_network_monitor_get_fd(m
->network_monitor
);
314 events
= sd_network_monitor_get_events(m
->network_monitor
);
318 r
= sd_event_add_io(m
->event
, &m
->network_event_source
, fd
, events
, &on_network_event
, m
);
322 r
= sd_event_source_set_priority(m
->network_event_source
, SD_EVENT_PRIORITY_IMPORTANT
+5);
326 (void) sd_event_source_set_description(m
->network_event_source
, "network-monitor");
331 static int determine_hostname(char **full_hostname
, char **llmnr_hostname
, char **mdns_hostname
) {
332 _cleanup_free_
char *h
= NULL
, *n
= NULL
;
334 _cleanup_free_
char *utf8
= NULL
;
338 char label
[DNS_LABEL_MAX
];
339 const char *p
, *decoded
;
342 assert(full_hostname
);
343 assert(llmnr_hostname
);
344 assert(mdns_hostname
);
346 /* Extract and normalize the first label of the locally configured hostname, and check it's not "localhost". */
348 r
= gethostname_strict(&h
);
350 return log_debug_errno(r
, "Can't determine system hostname: %m");
353 r
= dns_label_unescape(&p
, label
, sizeof label
);
355 return log_error_errno(r
, "Failed to unescape host name: %m");
357 log_error("Couldn't find a single label in hostname.");
362 r
= idn2_to_unicode_8z8z(label
, &utf8
, 0);
364 return log_error("Failed to undo IDNA: %s", idn2_strerror(r
));
365 assert(utf8_is_valid(utf8
));
370 k
= dns_label_undo_idna(label
, r
, label
, sizeof label
);
372 return log_error_errno(k
, "Failed to undo IDNA: %m");
376 if (!utf8_is_valid(label
)) {
377 log_error("System hostname is not UTF-8 clean.");
382 decoded
= label
; /* no decoding */
385 r
= dns_label_escape_new(decoded
, r
, &n
);
387 return log_error_errno(r
, "Failed to escape host name: %m");
389 if (is_localhost(n
)) {
390 log_debug("System hostname is 'localhost', ignoring.");
394 r
= dns_name_concat(n
, "local", mdns_hostname
);
396 return log_error_errno(r
, "Failed to determine mDNS hostname: %m");
407 static const char *fallback_hostname(void) {
409 /* Determine the fall back hostname. For exposing this system to the outside world, we cannot have it to be
410 * "localhost" even if that's the compiled in hostname. In this case, let's revert to "linux" instead. */
412 if (is_localhost(FALLBACK_HOSTNAME
))
415 return FALLBACK_HOSTNAME
;
418 static int make_fallback_hostnames(char **full_hostname
, char **llmnr_hostname
, char **mdns_hostname
) {
419 _cleanup_free_
char *n
= NULL
, *m
= NULL
;
420 char label
[DNS_LABEL_MAX
], *h
;
424 assert(full_hostname
);
425 assert(llmnr_hostname
);
426 assert(mdns_hostname
);
428 p
= fallback_hostname();
429 r
= dns_label_unescape(&p
, label
, sizeof(label
));
431 return log_error_errno(r
, "Failed to unescape fallback host name: %m");
433 assert(r
> 0); /* The fallback hostname must have at least one label */
435 r
= dns_label_escape_new(label
, r
, &n
);
437 return log_error_errno(r
, "Failed to escape fallback hostname: %m");
439 r
= dns_name_concat(n
, "local", &m
);
441 return log_error_errno(r
, "Failed to concatenate mDNS hostname: %m");
443 h
= strdup(fallback_hostname());
458 static int on_hostname_change(sd_event_source
*es
, int fd
, uint32_t revents
, void *userdata
) {
459 _cleanup_free_
char *full_hostname
= NULL
, *llmnr_hostname
= NULL
, *mdns_hostname
= NULL
;
460 Manager
*m
= userdata
;
465 r
= determine_hostname(&full_hostname
, &llmnr_hostname
, &mdns_hostname
);
467 return 0; /* ignore invalid hostnames */
469 if (streq(full_hostname
, m
->full_hostname
) &&
470 streq(llmnr_hostname
, m
->llmnr_hostname
) &&
471 streq(mdns_hostname
, m
->mdns_hostname
))
474 log_info("System hostname changed to '%s'.", full_hostname
);
476 free_and_replace(m
->full_hostname
, full_hostname
);
477 free_and_replace(m
->llmnr_hostname
, llmnr_hostname
);
478 free_and_replace(m
->mdns_hostname
, mdns_hostname
);
480 manager_refresh_rrs(m
);
485 static int manager_watch_hostname(Manager
*m
) {
490 m
->hostname_fd
= open("/proc/sys/kernel/hostname", O_RDONLY
|O_CLOEXEC
|O_NDELAY
|O_NOCTTY
);
491 if (m
->hostname_fd
< 0) {
492 log_warning_errno(errno
, "Failed to watch hostname: %m");
496 r
= sd_event_add_io(m
->event
, &m
->hostname_event_source
, m
->hostname_fd
, 0, on_hostname_change
, m
);
499 /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */
500 m
->hostname_fd
= safe_close(m
->hostname_fd
);
502 return log_error_errno(r
, "Failed to add hostname event source: %m");
505 (void) sd_event_source_set_description(m
->hostname_event_source
, "hostname");
507 r
= determine_hostname(&m
->full_hostname
, &m
->llmnr_hostname
, &m
->mdns_hostname
);
509 log_info("Defaulting to hostname '%s'.", fallback_hostname());
511 r
= make_fallback_hostnames(&m
->full_hostname
, &m
->llmnr_hostname
, &m
->mdns_hostname
);
515 log_info("Using system hostname '%s'.", m
->full_hostname
);
520 static int manager_sigusr1(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
521 _cleanup_free_
char *buffer
= NULL
;
522 _cleanup_fclose_
FILE *f
= NULL
;
523 Manager
*m
= userdata
;
534 f
= open_memstream(&buffer
, &size
);
538 LIST_FOREACH(scopes
, scope
, m
->dns_scopes
)
539 dns_scope_dump(scope
, f
);
541 LIST_FOREACH(servers
, server
, m
->dns_servers
)
542 dns_server_dump(server
, f
);
543 LIST_FOREACH(servers
, server
, m
->fallback_dns_servers
)
544 dns_server_dump(server
, f
);
545 HASHMAP_FOREACH(l
, m
->links
, i
)
546 LIST_FOREACH(servers
, server
, l
->dns_servers
)
547 dns_server_dump(server
, f
);
549 if (fflush_and_check(f
) < 0)
552 log_dump(LOG_INFO
, buffer
);
556 static int manager_sigusr2(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
557 Manager
*m
= userdata
;
563 manager_flush_caches(m
);
568 static int manager_sigrtmin1(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
569 Manager
*m
= userdata
;
575 manager_reset_server_features(m
);
579 int manager_new(Manager
**ret
) {
580 _cleanup_(manager_freep
) Manager
*m
= NULL
;
585 m
= new0(Manager
, 1);
589 m
->llmnr_ipv4_udp_fd
= m
->llmnr_ipv6_udp_fd
= -1;
590 m
->llmnr_ipv4_tcp_fd
= m
->llmnr_ipv6_tcp_fd
= -1;
591 m
->mdns_ipv4_fd
= m
->mdns_ipv6_fd
= -1;
592 m
->dns_stub_udp_fd
= m
->dns_stub_tcp_fd
= -1;
595 m
->llmnr_support
= RESOLVE_SUPPORT_YES
;
596 m
->mdns_support
= RESOLVE_SUPPORT_YES
;
597 m
->dnssec_mode
= DEFAULT_DNSSEC_MODE
;
598 m
->enable_cache
= true;
599 m
->dns_stub_listener_mode
= DNS_STUB_LISTENER_UDP
;
600 m
->read_resolv_conf
= true;
601 m
->need_builtin_fallbacks
= true;
602 m
->etc_hosts_last
= m
->etc_hosts_mtime
= USEC_INFINITY
;
604 r
= dns_trust_anchor_load(&m
->trust_anchor
);
608 r
= manager_parse_config_file(m
);
610 log_warning_errno(r
, "Failed to parse configuration file: %m");
612 r
= sd_event_default(&m
->event
);
616 sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
617 sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
619 sd_event_set_watchdog(m
->event
, true);
621 r
= manager_watch_hostname(m
);
627 log_warning_errno(r
, "Failed to load DNS-SD configuration files: %m");
629 r
= dns_scope_new(m
, &m
->unicast_scope
, NULL
, DNS_PROTOCOL_DNS
, AF_UNSPEC
);
633 r
= manager_network_monitor_listen(m
);
637 r
= manager_rtnl_listen(m
);
641 r
= manager_connect_bus(m
);
645 (void) sd_event_add_signal(m
->event
, &m
->sigusr1_event_source
, SIGUSR1
, manager_sigusr1
, m
);
646 (void) sd_event_add_signal(m
->event
, &m
->sigusr2_event_source
, SIGUSR2
, manager_sigusr2
, m
);
647 (void) sd_event_add_signal(m
->event
, &m
->sigrtmin1_event_source
, SIGRTMIN
+1, manager_sigrtmin1
, m
);
649 manager_cleanup_saved_user(m
);
657 int manager_start(Manager
*m
) {
662 r
= manager_dns_stub_start(m
);
669 Manager
*manager_free(Manager
*m
) {
676 dns_server_unlink_all(m
->dns_servers
);
677 dns_server_unlink_all(m
->fallback_dns_servers
);
678 dns_search_domain_unlink_all(m
->search_domains
);
680 while ((l
= hashmap_first(m
->links
)))
683 while (m
->dns_queries
)
684 dns_query_free(m
->dns_queries
);
686 dns_scope_free(m
->unicast_scope
);
688 /* At this point only orphaned streams should remain. All others should have been freed already by their
690 while (m
->dns_streams
)
691 dns_stream_unref(m
->dns_streams
);
693 hashmap_free(m
->links
);
694 hashmap_free(m
->dns_transactions
);
696 sd_event_source_unref(m
->network_event_source
);
697 sd_network_monitor_unref(m
->network_monitor
);
699 sd_netlink_unref(m
->rtnl
);
700 sd_event_source_unref(m
->rtnl_event_source
);
702 manager_llmnr_stop(m
);
703 manager_mdns_stop(m
);
704 manager_dns_stub_stop(m
);
706 sd_bus_slot_unref(m
->prepare_for_sleep_slot
);
707 sd_event_source_unref(m
->bus_retry_event_source
);
708 sd_bus_unref(m
->bus
);
710 sd_event_source_unref(m
->sigusr1_event_source
);
711 sd_event_source_unref(m
->sigusr2_event_source
);
712 sd_event_source_unref(m
->sigrtmin1_event_source
);
714 sd_event_unref(m
->event
);
716 dns_resource_key_unref(m
->llmnr_host_ipv4_key
);
717 dns_resource_key_unref(m
->llmnr_host_ipv6_key
);
718 dns_resource_key_unref(m
->mdns_host_ipv4_key
);
719 dns_resource_key_unref(m
->mdns_host_ipv6_key
);
721 sd_event_source_unref(m
->hostname_event_source
);
722 safe_close(m
->hostname_fd
);
724 free(m
->full_hostname
);
725 free(m
->llmnr_hostname
);
726 free(m
->mdns_hostname
);
728 while ((s
= hashmap_first(m
->dnssd_services
)))
729 dnssd_service_free(s
);
730 hashmap_free(m
->dnssd_services
);
732 dns_trust_anchor_flush(&m
->trust_anchor
);
733 manager_etc_hosts_flush(m
);
738 int manager_recv(Manager
*m
, int fd
, DnsProtocol protocol
, DnsPacket
**ret
) {
739 _cleanup_(dns_packet_unrefp
) DnsPacket
*p
= NULL
;
741 struct cmsghdr header
; /* For alignment */
742 uint8_t buffer
[CMSG_SPACE(MAXSIZE(struct in_pktinfo
, struct in6_pktinfo
))
743 + CMSG_SPACE(int) /* ttl/hoplimit */
744 + EXTRA_CMSG_SPACE
/* kernel appears to require extra buffer space */];
746 union sockaddr_union sa
;
747 struct msghdr mh
= {};
748 struct cmsghdr
*cmsg
;
757 ms
= next_datagram_size_fd(fd
);
761 r
= dns_packet_new(&p
, protocol
, ms
, DNS_PACKET_SIZE_MAX
);
765 iov
.iov_base
= DNS_PACKET_DATA(p
);
766 iov
.iov_len
= p
->allocated
;
768 mh
.msg_name
= &sa
.sa
;
769 mh
.msg_namelen
= sizeof(sa
);
772 mh
.msg_control
= &control
;
773 mh
.msg_controllen
= sizeof(control
);
775 l
= recvmsg(fd
, &mh
, 0);
779 if (IN_SET(errno
, EAGAIN
, EINTR
))
785 assert(!(mh
.msg_flags
& MSG_CTRUNC
));
786 assert(!(mh
.msg_flags
& MSG_TRUNC
));
788 p
->size
= (size_t) l
;
790 p
->family
= sa
.sa
.sa_family
;
791 p
->ipproto
= IPPROTO_UDP
;
792 if (p
->family
== AF_INET
) {
793 p
->sender
.in
= sa
.in
.sin_addr
;
794 p
->sender_port
= be16toh(sa
.in
.sin_port
);
795 } else if (p
->family
== AF_INET6
) {
796 p
->sender
.in6
= sa
.in6
.sin6_addr
;
797 p
->sender_port
= be16toh(sa
.in6
.sin6_port
);
798 p
->ifindex
= sa
.in6
.sin6_scope_id
;
800 return -EAFNOSUPPORT
;
802 CMSG_FOREACH(cmsg
, &mh
) {
804 if (cmsg
->cmsg_level
== IPPROTO_IPV6
) {
805 assert(p
->family
== AF_INET6
);
807 switch (cmsg
->cmsg_type
) {
810 struct in6_pktinfo
*i
= (struct in6_pktinfo
*) CMSG_DATA(cmsg
);
813 p
->ifindex
= i
->ipi6_ifindex
;
815 p
->destination
.in6
= i
->ipi6_addr
;
820 p
->ttl
= *(int *) CMSG_DATA(cmsg
);
824 } else if (cmsg
->cmsg_level
== IPPROTO_IP
) {
825 assert(p
->family
== AF_INET
);
827 switch (cmsg
->cmsg_type
) {
830 struct in_pktinfo
*i
= (struct in_pktinfo
*) CMSG_DATA(cmsg
);
833 p
->ifindex
= i
->ipi_ifindex
;
835 p
->destination
.in
= i
->ipi_addr
;
840 p
->ttl
= *(int *) CMSG_DATA(cmsg
);
846 /* The Linux kernel sets the interface index to the loopback
847 * device if the packet came from the local host since it
848 * avoids the routing table in such a case. Let's unset the
849 * interface index in such a case. */
850 if (p
->ifindex
== LOOPBACK_IFINDEX
)
853 if (protocol
!= DNS_PROTOCOL_DNS
) {
854 /* If we don't know the interface index still, we look for the
855 * first local interface with a matching address. Yuck! */
857 p
->ifindex
= manager_find_ifindex(m
, p
->family
, &p
->destination
);
866 static int sendmsg_loop(int fd
, struct msghdr
*mh
, int flags
) {
873 if (sendmsg(fd
, mh
, flags
) >= 0)
882 r
= fd_wait_for_event(fd
, POLLOUT
, SEND_TIMEOUT_USEC
);
890 static int write_loop(int fd
, void *message
, size_t length
) {
897 if (write(fd
, message
, length
) >= 0)
906 r
= fd_wait_for_event(fd
, POLLOUT
, SEND_TIMEOUT_USEC
);
914 int manager_write(Manager
*m
, int fd
, DnsPacket
*p
) {
917 log_debug("Sending %s packet with id %" PRIu16
".", DNS_PACKET_QR(p
) ? "response" : "query", DNS_PACKET_ID(p
));
919 r
= write_loop(fd
, DNS_PACKET_DATA(p
), p
->size
);
926 static int manager_ipv4_send(
930 const struct in_addr
*destination
,
932 const struct in_addr
*source
,
934 union sockaddr_union sa
= {
935 .in
.sin_family
= AF_INET
,
938 struct cmsghdr header
; /* For alignment */
939 uint8_t buffer
[CMSG_SPACE(sizeof(struct in_pktinfo
))];
941 struct msghdr mh
= {};
950 iov
.iov_base
= DNS_PACKET_DATA(p
);
951 iov
.iov_len
= p
->size
;
953 sa
.in
.sin_addr
= *destination
;
954 sa
.in
.sin_port
= htobe16(port
),
958 mh
.msg_name
= &sa
.sa
;
959 mh
.msg_namelen
= sizeof(sa
.in
);
962 struct cmsghdr
*cmsg
;
963 struct in_pktinfo
*pi
;
967 mh
.msg_control
= &control
;
968 mh
.msg_controllen
= CMSG_LEN(sizeof(struct in_pktinfo
));
970 cmsg
= CMSG_FIRSTHDR(&mh
);
971 cmsg
->cmsg_len
= mh
.msg_controllen
;
972 cmsg
->cmsg_level
= IPPROTO_IP
;
973 cmsg
->cmsg_type
= IP_PKTINFO
;
975 pi
= (struct in_pktinfo
*) CMSG_DATA(cmsg
);
976 pi
->ipi_ifindex
= ifindex
;
979 pi
->ipi_spec_dst
= *source
;
982 return sendmsg_loop(fd
, &mh
, 0);
985 static int manager_ipv6_send(
989 const struct in6_addr
*destination
,
991 const struct in6_addr
*source
,
994 union sockaddr_union sa
= {
995 .in6
.sin6_family
= AF_INET6
,
998 struct cmsghdr header
; /* For alignment */
999 uint8_t buffer
[CMSG_SPACE(sizeof(struct in6_pktinfo
))];
1001 struct msghdr mh
= {};
1006 assert(destination
);
1010 iov
.iov_base
= DNS_PACKET_DATA(p
);
1011 iov
.iov_len
= p
->size
;
1013 sa
.in6
.sin6_addr
= *destination
;
1014 sa
.in6
.sin6_port
= htobe16(port
),
1015 sa
.in6
.sin6_scope_id
= ifindex
;
1019 mh
.msg_name
= &sa
.sa
;
1020 mh
.msg_namelen
= sizeof(sa
.in6
);
1023 struct cmsghdr
*cmsg
;
1024 struct in6_pktinfo
*pi
;
1028 mh
.msg_control
= &control
;
1029 mh
.msg_controllen
= CMSG_LEN(sizeof(struct in6_pktinfo
));
1031 cmsg
= CMSG_FIRSTHDR(&mh
);
1032 cmsg
->cmsg_len
= mh
.msg_controllen
;
1033 cmsg
->cmsg_level
= IPPROTO_IPV6
;
1034 cmsg
->cmsg_type
= IPV6_PKTINFO
;
1036 pi
= (struct in6_pktinfo
*) CMSG_DATA(cmsg
);
1037 pi
->ipi6_ifindex
= ifindex
;
1040 pi
->ipi6_addr
= *source
;
1043 return sendmsg_loop(fd
, &mh
, 0);
1051 const union in_addr_union
*destination
,
1053 const union in_addr_union
*source
,
1058 assert(destination
);
1062 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
));
1064 if (family
== AF_INET
)
1065 return manager_ipv4_send(m
, fd
, ifindex
, &destination
->in
, port
, &source
->in
, p
);
1066 if (family
== AF_INET6
)
1067 return manager_ipv6_send(m
, fd
, ifindex
, &destination
->in6
, port
, &source
->in6
, p
);
1069 return -EAFNOSUPPORT
;
1072 uint32_t manager_find_mtu(Manager
*m
) {
1077 /* If we don't know on which link a DNS packet would be
1078 * delivered, let's find the largest MTU that works on all
1079 * interfaces we know of */
1081 HASHMAP_FOREACH(l
, m
->links
, i
) {
1085 if (mtu
<= 0 || l
->mtu
< mtu
)
1092 int manager_find_ifindex(Manager
*m
, int family
, const union in_addr_union
*in_addr
) {
1097 a
= manager_find_link_address(m
, family
, in_addr
);
1099 return a
->link
->ifindex
;
1104 void manager_refresh_rrs(Manager
*m
) {
1111 m
->llmnr_host_ipv4_key
= dns_resource_key_unref(m
->llmnr_host_ipv4_key
);
1112 m
->llmnr_host_ipv6_key
= dns_resource_key_unref(m
->llmnr_host_ipv6_key
);
1113 m
->mdns_host_ipv4_key
= dns_resource_key_unref(m
->mdns_host_ipv4_key
);
1114 m
->mdns_host_ipv6_key
= dns_resource_key_unref(m
->mdns_host_ipv6_key
);
1116 if (m
->mdns_support
== RESOLVE_SUPPORT_YES
)
1117 HASHMAP_FOREACH(s
, m
->dnssd_services
, i
)
1118 if (dnssd_update_rrs(s
) < 0)
1119 log_warning("Failed to refresh DNS-SD service '%s'", s
->name
);
1121 HASHMAP_FOREACH(l
, m
->links
, i
) {
1122 link_add_rrs(l
, true);
1123 link_add_rrs(l
, false);
1127 int manager_next_hostname(Manager
*m
) {
1135 p
= strchr(m
->llmnr_hostname
, 0);
1138 while (p
> m
->llmnr_hostname
) {
1139 if (!strchr("0123456789", p
[-1]))
1145 if (*p
== 0 || safe_atou64(p
, &u
) < 0 || u
<= 0)
1148 /* Add a random number to the old value. This way we can avoid
1149 * that two hosts pick the same hostname, win on IPv4 and lose
1150 * on IPv6 (or vice versa), and pick the same hostname
1151 * replacement hostname, ad infinitum. We still want the
1152 * numbers to go up monotonically, hence we just add a random
1155 random_bytes(&a
, sizeof(a
));
1158 if (asprintf(&h
, "%.*s%" PRIu64
, (int) (p
- m
->llmnr_hostname
), m
->llmnr_hostname
, u
) < 0)
1161 r
= dns_name_concat(h
, "local", &k
);
1167 log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m
->llmnr_hostname
, h
);
1169 free(m
->llmnr_hostname
);
1170 m
->llmnr_hostname
= h
;
1172 free(m
->mdns_hostname
);
1173 m
->mdns_hostname
= k
;
1175 manager_refresh_rrs(m
);
1180 LinkAddress
* manager_find_link_address(Manager
*m
, int family
, const union in_addr_union
*in_addr
) {
1186 HASHMAP_FOREACH(l
, m
->links
, i
) {
1189 a
= link_find_address(l
, family
, in_addr
);
1197 bool manager_our_packet(Manager
*m
, DnsPacket
*p
) {
1201 return !!manager_find_link_address(m
, p
->family
, &p
->sender
);
1204 DnsScope
* manager_find_scope(Manager
*m
, DnsPacket
*p
) {
1210 l
= hashmap_get(m
->links
, INT_TO_PTR(p
->ifindex
));
1214 switch (p
->protocol
) {
1215 case DNS_PROTOCOL_LLMNR
:
1216 if (p
->family
== AF_INET
)
1217 return l
->llmnr_ipv4_scope
;
1218 else if (p
->family
== AF_INET6
)
1219 return l
->llmnr_ipv6_scope
;
1223 case DNS_PROTOCOL_MDNS
:
1224 if (p
->family
== AF_INET
)
1225 return l
->mdns_ipv4_scope
;
1226 else if (p
->family
== AF_INET6
)
1227 return l
->mdns_ipv6_scope
;
1238 void manager_verify_all(Manager
*m
) {
1243 LIST_FOREACH(scopes
, s
, m
->dns_scopes
)
1244 dns_zone_verify_all(&s
->zone
);
1247 int manager_is_own_hostname(Manager
*m
, const char *name
) {
1253 if (m
->llmnr_hostname
) {
1254 r
= dns_name_equal(name
, m
->llmnr_hostname
);
1259 if (m
->mdns_hostname
) {
1260 r
= dns_name_equal(name
, m
->mdns_hostname
);
1265 if (m
->full_hostname
)
1266 return dns_name_equal(name
, m
->full_hostname
);
1271 int manager_compile_dns_servers(Manager
*m
, OrderedSet
**dns
) {
1280 r
= ordered_set_ensure_allocated(dns
, &dns_server_hash_ops
);
1284 /* First add the system-wide servers and domains */
1285 LIST_FOREACH(servers
, s
, m
->dns_servers
) {
1286 r
= ordered_set_put(*dns
, s
);
1293 /* Then, add the per-link servers */
1294 HASHMAP_FOREACH(l
, m
->links
, i
) {
1295 LIST_FOREACH(servers
, s
, l
->dns_servers
) {
1296 r
= ordered_set_put(*dns
, s
);
1304 /* If we found nothing, add the fallback servers */
1305 if (ordered_set_isempty(*dns
)) {
1306 LIST_FOREACH(servers
, s
, m
->fallback_dns_servers
) {
1307 r
= ordered_set_put(*dns
, s
);
1318 /* filter_route is a tri-state:
1320 * = 0 or false: return only domains which should be used for searching
1321 * > 0 or true: return only domains which are for routing only
1323 int manager_compile_search_domains(Manager
*m
, OrderedSet
**domains
, int filter_route
) {
1332 r
= ordered_set_ensure_allocated(domains
, &dns_name_hash_ops
);
1336 LIST_FOREACH(domains
, d
, m
->search_domains
) {
1338 if (filter_route
>= 0 &&
1339 d
->route_only
!= !!filter_route
)
1342 r
= ordered_set_put(*domains
, d
->name
);
1349 HASHMAP_FOREACH(l
, m
->links
, i
) {
1351 LIST_FOREACH(domains
, d
, l
->search_domains
) {
1353 if (filter_route
>= 0 &&
1354 d
->route_only
!= !!filter_route
)
1357 r
= ordered_set_put(*domains
, d
->name
);
1368 DnssecMode
manager_get_dnssec_mode(Manager
*m
) {
1371 if (m
->dnssec_mode
!= _DNSSEC_MODE_INVALID
)
1372 return m
->dnssec_mode
;
1377 bool manager_dnssec_supported(Manager
*m
) {
1384 if (manager_get_dnssec_mode(m
) == DNSSEC_NO
)
1387 server
= manager_get_dns_server(m
);
1388 if (server
&& !dns_server_dnssec_supported(server
))
1391 HASHMAP_FOREACH(l
, m
->links
, i
)
1392 if (!link_dnssec_supported(l
))
1398 void manager_dnssec_verdict(Manager
*m
, DnssecVerdict verdict
, const DnsResourceKey
*key
) {
1400 assert(verdict
>= 0);
1401 assert(verdict
< _DNSSEC_VERDICT_MAX
);
1403 if (log_get_max_level() >= LOG_DEBUG
) {
1404 char s
[DNS_RESOURCE_KEY_STRING_MAX
];
1406 log_debug("Found verdict for lookup %s: %s",
1407 dns_resource_key_to_string(key
, s
, sizeof s
),
1408 dnssec_verdict_to_string(verdict
));
1411 m
->n_dnssec_verdict
[verdict
]++;
1414 bool manager_routable(Manager
*m
, int family
) {
1420 /* Returns true if the host has at least one interface with a routable address of the specified type */
1422 HASHMAP_FOREACH(l
, m
->links
, i
)
1423 if (link_relevant(l
, family
, false))
1429 void manager_flush_caches(Manager
*m
) {
1434 LIST_FOREACH(scopes
, scope
, m
->dns_scopes
)
1435 dns_cache_flush(&scope
->cache
);
1437 log_info("Flushed all caches.");
1440 void manager_reset_server_features(Manager
*m
) {
1444 dns_server_reset_features_all(m
->dns_servers
);
1445 dns_server_reset_features_all(m
->fallback_dns_servers
);
1447 HASHMAP_FOREACH(l
, m
->links
, i
)
1448 dns_server_reset_features_all(l
->dns_servers
);
1450 log_info("Resetting learnt feature levels on all servers.");
1453 void manager_cleanup_saved_user(Manager
*m
) {
1454 _cleanup_closedir_
DIR *d
= NULL
;
1460 /* Clean up all saved per-link files in /run/systemd/resolve/netif/ that don't have a matching interface
1461 * anymore. These files are created to persist settings pushed in by the user via the bus, so that resolved can
1462 * be restarted without losing this data. */
1464 d
= opendir("/run/systemd/resolve/netif/");
1466 if (errno
== ENOENT
)
1469 log_warning_errno(errno
, "Failed to open interface directory: %m");
1473 FOREACH_DIRENT_ALL(de
, d
, log_error_errno(errno
, "Failed to read interface directory: %m")) {
1474 _cleanup_free_
char *p
= NULL
;
1478 if (!IN_SET(de
->d_type
, DT_UNKNOWN
, DT_REG
))
1481 if (dot_or_dot_dot(de
->d_name
))
1484 r
= parse_ifindex(de
->d_name
, &ifindex
);
1485 if (r
< 0) /* Probably some temporary file from a previous run. Delete it */
1488 l
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
1489 if (!l
) /* link vanished */
1492 if (l
->is_managed
) /* now managed by networkd, hence the bus settings are useless */
1498 p
= strappend("/run/systemd/resolve/netif/", de
->d_name
);