1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2014 Tom Gundersen <teg@jklm.no>
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.
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.
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/>.
22 #include <netinet/in.h>
25 #include <sys/ioctl.h>
28 #include "dns-domain.h"
30 #include "fileio-label.h"
31 #include "hostname-util.h"
33 #include "netlink-util.h"
34 #include "network-internal.h"
35 #include "ordered-set.h"
36 #include "parse-util.h"
37 #include "random-util.h"
38 #include "resolved-bus.h"
39 #include "resolved-conf.h"
40 #include "resolved-llmnr.h"
41 #include "resolved-manager.h"
42 #include "socket-util.h"
43 #include "string-util.h"
46 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
48 static int manager_process_link(sd_netlink
*rtnl
, sd_netlink_message
*mm
, void *userdata
) {
49 Manager
*m
= userdata
;
58 r
= sd_netlink_message_get_type(mm
, &type
);
62 r
= sd_rtnl_message_link_get_ifindex(mm
, &ifindex
);
66 l
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
74 r
= link_new(m
, &l
, ifindex
);
79 r
= link_update_rtnl(l
, mm
);
83 r
= link_update_monitor(l
);
88 log_debug("Found new link %i/%s", ifindex
, l
->name
);
95 log_debug("Removing link %i/%s", l
->ifindex
, l
->name
);
105 log_warning_errno(r
, "Failed to process RTNL link message: %m");
109 static int manager_process_address(sd_netlink
*rtnl
, sd_netlink_message
*mm
, void *userdata
) {
110 Manager
*m
= userdata
;
111 union in_addr_union address
;
113 int r
, ifindex
, family
;
121 r
= sd_netlink_message_get_type(mm
, &type
);
125 r
= sd_rtnl_message_addr_get_ifindex(mm
, &ifindex
);
129 l
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
133 r
= sd_rtnl_message_addr_get_family(mm
, &family
);
140 r
= sd_netlink_message_read_in_addr(mm
, IFA_LOCAL
, &address
.in
);
142 r
= sd_netlink_message_read_in_addr(mm
, IFA_ADDRESS
, &address
.in
);
150 r
= sd_netlink_message_read_in6_addr(mm
, IFA_LOCAL
, &address
.in6
);
152 r
= sd_netlink_message_read_in6_addr(mm
, IFA_ADDRESS
, &address
.in6
);
163 a
= link_find_address(l
, family
, &address
);
170 r
= link_address_new(l
, &a
, family
, &address
);
175 r
= link_address_update_rtnl(a
, mm
);
182 link_address_free(a
);
189 log_warning_errno(r
, "Failed to process RTNL address message: %m");
193 static int manager_rtnl_listen(Manager
*m
) {
194 _cleanup_netlink_message_unref_ sd_netlink_message
*req
= NULL
, *reply
= NULL
;
195 sd_netlink_message
*i
;
200 /* First, subscribe to interfaces coming and going */
201 r
= sd_netlink_open(&m
->rtnl
);
205 r
= sd_netlink_attach_event(m
->rtnl
, m
->event
, 0);
209 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWLINK
, manager_process_link
, m
);
213 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELLINK
, manager_process_link
, m
);
217 r
= sd_netlink_add_match(m
->rtnl
, RTM_NEWADDR
, manager_process_address
, m
);
221 r
= sd_netlink_add_match(m
->rtnl
, RTM_DELADDR
, manager_process_address
, m
);
225 /* Then, enumerate all links */
226 r
= sd_rtnl_message_new_link(m
->rtnl
, &req
, RTM_GETLINK
, 0);
230 r
= sd_netlink_message_request_dump(req
, true);
234 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
238 for (i
= reply
; i
; i
= sd_netlink_message_next(i
)) {
239 r
= manager_process_link(m
->rtnl
, i
, m
);
244 req
= sd_netlink_message_unref(req
);
245 reply
= sd_netlink_message_unref(reply
);
247 /* Finally, enumerate all addresses, too */
248 r
= sd_rtnl_message_new_addr(m
->rtnl
, &req
, RTM_GETADDR
, 0, AF_UNSPEC
);
252 r
= sd_netlink_message_request_dump(req
, true);
256 r
= sd_netlink_call(m
->rtnl
, req
, 0, &reply
);
260 for (i
= reply
; i
; i
= sd_netlink_message_next(i
)) {
261 r
= manager_process_address(m
->rtnl
, i
, m
);
269 static int on_network_event(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
270 Manager
*m
= userdata
;
277 sd_network_monitor_flush(m
->network_monitor
);
279 HASHMAP_FOREACH(l
, m
->links
, i
) {
280 r
= link_update_monitor(l
);
282 log_warning_errno(r
, "Failed to update monitor information for %i: %m", l
->ifindex
);
285 r
= manager_write_resolv_conf(m
);
287 log_warning_errno(r
, "Could not update resolv.conf: %m");
292 static int manager_network_monitor_listen(Manager
*m
) {
297 r
= sd_network_monitor_new(&m
->network_monitor
, NULL
);
301 fd
= sd_network_monitor_get_fd(m
->network_monitor
);
305 events
= sd_network_monitor_get_events(m
->network_monitor
);
309 r
= sd_event_add_io(m
->event
, &m
->network_event_source
, fd
, events
, &on_network_event
, m
);
316 static int determine_hostname(char **llmnr_hostname
, char **mdns_hostname
) {
317 _cleanup_free_
char *h
= NULL
, *n
= NULL
;
318 char label
[DNS_LABEL_MAX
];
322 assert(llmnr_hostname
);
323 assert(mdns_hostname
);
325 /* Extract and normalize the first label of the locally
326 * configured hostname, and check it's not "localhost". */
328 h
= gethostname_malloc();
333 r
= dns_label_unescape(&p
, label
, sizeof(label
));
335 return log_error_errno(r
, "Failed to unescape host name: %m");
337 log_error("Couldn't find a single label in hosntame.");
341 k
= dns_label_undo_idna(label
, r
, label
, sizeof(label
));
343 return log_error_errno(k
, "Failed to undo IDNA: %m");
347 if (!utf8_is_valid(label
)) {
348 log_error("System hostname is not UTF-8 clean.");
352 r
= dns_label_escape(label
, r
, &n
);
354 return log_error_errno(r
, "Failed to escape host name: %m");
356 if (is_localhost(n
)) {
357 log_debug("System hostname is 'localhost', ignoring.");
361 r
= dns_name_concat(n
, "local", mdns_hostname
);
363 return log_error_errno(r
, "Failed to determine mDNS hostname: %m");
371 static int on_hostname_change(sd_event_source
*es
, int fd
, uint32_t revents
, void *userdata
) {
372 _cleanup_free_
char *llmnr_hostname
= NULL
, *mdns_hostname
= NULL
;
373 Manager
*m
= userdata
;
378 r
= determine_hostname(&llmnr_hostname
, &mdns_hostname
);
380 return 0; /* ignore invalid hostnames */
382 if (streq(llmnr_hostname
, m
->llmnr_hostname
) && streq(mdns_hostname
, m
->mdns_hostname
))
385 log_info("System hostname changed to '%s'.", llmnr_hostname
);
387 free(m
->llmnr_hostname
);
388 free(m
->mdns_hostname
);
390 m
->llmnr_hostname
= llmnr_hostname
;
391 m
->mdns_hostname
= mdns_hostname
;
393 llmnr_hostname
= mdns_hostname
= NULL
;
395 manager_refresh_rrs(m
);
400 static int manager_watch_hostname(Manager
*m
) {
405 m
->hostname_fd
= open("/proc/sys/kernel/hostname", O_RDONLY
|O_CLOEXEC
|O_NDELAY
|O_NOCTTY
);
406 if (m
->hostname_fd
< 0) {
407 log_warning_errno(errno
, "Failed to watch hostname: %m");
411 r
= sd_event_add_io(m
->event
, &m
->hostname_event_source
, m
->hostname_fd
, 0, on_hostname_change
, m
);
414 /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */
415 m
->hostname_fd
= safe_close(m
->hostname_fd
);
417 return log_error_errno(r
, "Failed to add hostname event source: %m");
420 r
= determine_hostname(&m
->llmnr_hostname
, &m
->mdns_hostname
);
422 log_info("Defaulting to hostname 'linux'.");
423 m
->llmnr_hostname
= strdup("linux");
424 if (!m
->llmnr_hostname
)
427 m
->mdns_hostname
= strdup("linux.local");
428 if (!m
->mdns_hostname
)
431 log_info("Using system hostname '%s'.", m
->llmnr_hostname
);
436 static int manager_sigusr1(sd_event_source
*s
, const struct signalfd_siginfo
*si
, void *userdata
) {
437 _cleanup_free_
char *buffer
= NULL
;
438 _cleanup_fclose_
FILE *f
= NULL
;
439 Manager
*m
= userdata
;
447 f
= open_memstream(&buffer
, &size
);
451 LIST_FOREACH(scopes
, scope
, m
->dns_scopes
)
452 dns_scope_dump(scope
, f
);
454 if (fflush_and_check(f
) < 0)
457 log_dump(LOG_INFO
, buffer
);
461 int manager_new(Manager
**ret
) {
462 _cleanup_(manager_freep
) Manager
*m
= NULL
;
467 m
= new0(Manager
, 1);
471 m
->llmnr_ipv4_udp_fd
= m
->llmnr_ipv6_udp_fd
= -1;
472 m
->llmnr_ipv4_tcp_fd
= m
->llmnr_ipv6_tcp_fd
= -1;
475 m
->llmnr_support
= SUPPORT_YES
;
476 m
->read_resolv_conf
= true;
478 r
= manager_parse_dns_server(m
, DNS_SERVER_FALLBACK
, DNS_SERVERS
);
482 r
= sd_event_default(&m
->event
);
486 sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
487 sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
489 sd_event_set_watchdog(m
->event
, true);
491 r
= manager_watch_hostname(m
);
495 r
= dns_scope_new(m
, &m
->unicast_scope
, NULL
, DNS_PROTOCOL_DNS
, AF_UNSPEC
);
499 r
= manager_network_monitor_listen(m
);
503 r
= manager_rtnl_listen(m
);
507 r
= manager_connect_bus(m
);
511 (void) sd_event_add_signal(m
->event
, &m
->sigusr1_event_source
, SIGUSR1
, manager_sigusr1
, m
);
519 int manager_start(Manager
*m
) {
524 r
= manager_llmnr_start(m
);
531 Manager
*manager_free(Manager
*m
) {
537 while ((l
= hashmap_first(m
->links
)))
540 while (m
->dns_queries
)
541 dns_query_free(m
->dns_queries
);
543 manager_flush_dns_servers(m
, DNS_SERVER_SYSTEM
);
544 manager_flush_dns_servers(m
, DNS_SERVER_FALLBACK
);
546 dns_scope_free(m
->unicast_scope
);
548 hashmap_free(m
->links
);
549 hashmap_free(m
->dns_transactions
);
551 sd_event_source_unref(m
->network_event_source
);
552 sd_network_monitor_unref(m
->network_monitor
);
554 manager_llmnr_stop(m
);
556 sd_bus_slot_unref(m
->prepare_for_sleep_slot
);
557 sd_event_source_unref(m
->bus_retry_event_source
);
558 sd_bus_unref(m
->bus
);
560 sd_event_source_unref(m
->sigusr1_event_source
);
562 sd_event_unref(m
->event
);
564 dns_resource_key_unref(m
->llmnr_host_ipv4_key
);
565 dns_resource_key_unref(m
->llmnr_host_ipv6_key
);
567 sd_event_source_unref(m
->hostname_event_source
);
568 safe_close(m
->hostname_fd
);
569 free(m
->llmnr_hostname
);
570 free(m
->mdns_hostname
);
577 int manager_read_resolv_conf(Manager
*m
) {
578 _cleanup_fclose_
FILE *f
= NULL
;
587 /* Reads the system /etc/resolv.conf, if it exists and is not
588 * symlinked to our own resolv.conf instance */
590 if (!m
->read_resolv_conf
)
593 r
= stat("/etc/resolv.conf", &st
);
596 log_warning_errno(errno
, "Failed to open /etc/resolv.conf: %m");
601 /* Have we already seen the file? */
602 t
= timespec_load(&st
.st_mtim
);
603 if (t
== m
->resolv_conf_mtime
)
606 m
->resolv_conf_mtime
= t
;
608 /* Is it symlinked to our own file? */
609 if (stat("/run/systemd/resolve/resolv.conf", &own
) >= 0 &&
610 st
.st_dev
== own
.st_dev
&&
611 st
.st_ino
== own
.st_ino
) {
616 f
= fopen("/etc/resolv.conf", "re");
619 log_warning_errno(errno
, "Failed to open /etc/resolv.conf: %m");
624 if (fstat(fileno(f
), &st
) < 0) {
625 r
= log_error_errno(errno
, "Failed to stat open file: %m");
629 LIST_FOREACH(servers
, s
, m
->dns_servers
)
632 FOREACH_LINE(line
, f
, r
= -errno
; goto clear
) {
633 union in_addr_union address
;
641 if (*l
== '#' || *l
== ';')
644 a
= first_word(l
, "nameserver");
648 r
= in_addr_from_string_auto(a
, &family
, &address
);
650 log_warning("Failed to parse name server %s.", a
);
654 LIST_FOREACH(servers
, s
, m
->dns_servers
)
655 if (s
->family
== family
&& in_addr_equal(family
, &s
->address
, &address
) > 0)
661 r
= dns_server_new(m
, NULL
, DNS_SERVER_SYSTEM
, NULL
, family
, &address
);
667 LIST_FOREACH_SAFE(servers
, s
, nx
, m
->dns_servers
)
669 LIST_REMOVE(servers
, m
->dns_servers
, s
);
673 /* Whenever /etc/resolv.conf changes, start using the first
674 * DNS server of it. This is useful to deal with broken
675 * network managing implementations (like NetworkManager),
676 * that when connecting to a VPN place both the VPN DNS
677 * servers and the local ones in /etc/resolv.conf. Without
678 * resetting the DNS server to use back to the first entry we
679 * will continue to use the local one thus being unable to
680 * resolve VPN domains. */
681 manager_set_dns_server(m
, m
->dns_servers
);
686 while (m
->dns_servers
) {
689 LIST_REMOVE(servers
, m
->dns_servers
, s
);
696 static void write_resolv_conf_server(DnsServer
*s
, FILE *f
, unsigned *count
) {
697 _cleanup_free_
char *t
= NULL
;
704 r
= in_addr_to_string(s
->family
, &s
->address
, &t
);
706 log_warning_errno(r
, "Invalid DNS address. Ignoring: %m");
711 fputs("# Too many DNS servers configured, the following entries may be ignored.\n", f
);
713 fprintf(f
, "nameserver %s\n", t
);
717 static void write_resolv_conf_search(
718 const char *domain
, FILE *f
,
726 if (*count
>= MAXDNSRCH
||
727 *length
+ strlen(domain
) > 256) {
728 if (*count
== MAXDNSRCH
)
729 fputs(" # Too many search domains configured, remaining ones ignored.", f
);
731 fputs(" # Total length of all search domains is too long, remaining ones ignored.", f
);
736 fprintf(f
, " %s", domain
);
738 (*length
) += strlen(domain
);
742 static int write_resolv_conf_contents(FILE *f
, OrderedSet
*dns
, OrderedSet
*domains
) {
745 fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n"
746 "# Third party programs must not access this file directly, but\n"
747 "# only through the symlink at /etc/resolv.conf. To manage\n"
748 "# resolv.conf(5) in a different way, replace the symlink by a\n"
749 "# static file or a different symlink.\n\n", f
);
751 if (ordered_set_isempty(dns
))
752 fputs("# No DNS servers known.\n", f
);
757 ORDERED_SET_FOREACH(s
, dns
, i
)
758 write_resolv_conf_server(s
, f
, &count
);
761 if (!ordered_set_isempty(domains
)) {
762 unsigned length
= 0, count
= 0;
766 ORDERED_SET_FOREACH(domain
, domains
, i
)
767 write_resolv_conf_search(domain
, f
, &count
, &length
);
771 return fflush_and_check(f
);
774 int manager_write_resolv_conf(Manager
*m
) {
775 static const char path
[] = "/run/systemd/resolve/resolv.conf";
776 _cleanup_free_
char *temp_path
= NULL
;
777 _cleanup_fclose_
FILE *f
= NULL
;
778 _cleanup_ordered_set_free_ OrderedSet
*dns
= NULL
, *domains
= NULL
;
786 /* Read the system /etc/resolv.conf first */
787 manager_read_resolv_conf(m
);
789 /* Add the full list to a set, to filter out duplicates */
790 dns
= ordered_set_new(&dns_server_hash_ops
);
794 domains
= ordered_set_new(&dns_name_hash_ops
);
798 /* First add the system-wide servers */
799 LIST_FOREACH(servers
, s
, m
->dns_servers
) {
800 r
= ordered_set_put(dns
, s
);
807 /* Then, add the per-link servers and domains */
808 HASHMAP_FOREACH(l
, m
->links
, i
) {
811 LIST_FOREACH(servers
, s
, l
->dns_servers
) {
812 r
= ordered_set_put(dns
, s
);
819 if (!l
->unicast_scope
)
822 STRV_FOREACH(domain
, l
->unicast_scope
->domains
) {
823 r
= ordered_set_put(domains
, *domain
);
831 /* If we found nothing, add the fallback servers */
832 if (ordered_set_isempty(dns
)) {
833 LIST_FOREACH(servers
, s
, m
->fallback_dns_servers
) {
834 r
= ordered_set_put(dns
, s
);
842 r
= fopen_temporary_label(path
, path
, &f
, &temp_path
);
846 fchmod(fileno(f
), 0644);
848 r
= write_resolv_conf_contents(f
, dns
, domains
);
852 if (rename(temp_path
, path
) < 0) {
861 (void) unlink(temp_path
);
865 int manager_recv(Manager
*m
, int fd
, DnsProtocol protocol
, DnsPacket
**ret
) {
866 _cleanup_(dns_packet_unrefp
) DnsPacket
*p
= NULL
;
868 struct cmsghdr header
; /* For alignment */
869 uint8_t buffer
[CMSG_SPACE(MAXSIZE(struct in_pktinfo
, struct in6_pktinfo
))
870 + CMSG_SPACE(int) /* ttl/hoplimit */
871 + EXTRA_CMSG_SPACE
/* kernel appears to require extra buffer space */];
873 union sockaddr_union sa
;
874 struct msghdr mh
= {};
875 struct cmsghdr
*cmsg
;
884 r
= ioctl(fd
, FIONREAD
, &ms
);
890 r
= dns_packet_new(&p
, protocol
, ms
);
894 iov
.iov_base
= DNS_PACKET_DATA(p
);
895 iov
.iov_len
= p
->allocated
;
897 mh
.msg_name
= &sa
.sa
;
898 mh
.msg_namelen
= sizeof(sa
);
901 mh
.msg_control
= &control
;
902 mh
.msg_controllen
= sizeof(control
);
904 l
= recvmsg(fd
, &mh
, 0);
906 if (errno
== EAGAIN
|| errno
== EINTR
)
915 assert(!(mh
.msg_flags
& MSG_CTRUNC
));
916 assert(!(mh
.msg_flags
& MSG_TRUNC
));
918 p
->size
= (size_t) l
;
920 p
->family
= sa
.sa
.sa_family
;
921 p
->ipproto
= IPPROTO_UDP
;
922 if (p
->family
== AF_INET
) {
923 p
->sender
.in
= sa
.in
.sin_addr
;
924 p
->sender_port
= be16toh(sa
.in
.sin_port
);
925 } else if (p
->family
== AF_INET6
) {
926 p
->sender
.in6
= sa
.in6
.sin6_addr
;
927 p
->sender_port
= be16toh(sa
.in6
.sin6_port
);
928 p
->ifindex
= sa
.in6
.sin6_scope_id
;
930 return -EAFNOSUPPORT
;
932 CMSG_FOREACH(cmsg
, &mh
) {
934 if (cmsg
->cmsg_level
== IPPROTO_IPV6
) {
935 assert(p
->family
== AF_INET6
);
937 switch (cmsg
->cmsg_type
) {
940 struct in6_pktinfo
*i
= (struct in6_pktinfo
*) CMSG_DATA(cmsg
);
943 p
->ifindex
= i
->ipi6_ifindex
;
945 p
->destination
.in6
= i
->ipi6_addr
;
950 p
->ttl
= *(int *) CMSG_DATA(cmsg
);
954 } else if (cmsg
->cmsg_level
== IPPROTO_IP
) {
955 assert(p
->family
== AF_INET
);
957 switch (cmsg
->cmsg_type
) {
960 struct in_pktinfo
*i
= (struct in_pktinfo
*) CMSG_DATA(cmsg
);
963 p
->ifindex
= i
->ipi_ifindex
;
965 p
->destination
.in
= i
->ipi_addr
;
970 p
->ttl
= *(int *) CMSG_DATA(cmsg
);
976 /* The Linux kernel sets the interface index to the loopback
977 * device if the packet came from the local host since it
978 * avoids the routing table in such a case. Let's unset the
979 * interface index in such a case. */
980 if (p
->ifindex
== LOOPBACK_IFINDEX
)
983 if (protocol
!= DNS_PROTOCOL_DNS
) {
984 /* If we don't know the interface index still, we look for the
985 * first local interface with a matching address. Yuck! */
987 p
->ifindex
= manager_find_ifindex(m
, p
->family
, &p
->destination
);
996 static int sendmsg_loop(int fd
, struct msghdr
*mh
, int flags
) {
1003 if (sendmsg(fd
, mh
, flags
) >= 0)
1009 if (errno
!= EAGAIN
)
1012 r
= fd_wait_for_event(fd
, POLLOUT
, SEND_TIMEOUT_USEC
);
1020 static int write_loop(int fd
, void *message
, size_t length
) {
1027 if (write(fd
, message
, length
) >= 0)
1033 if (errno
!= EAGAIN
)
1036 r
= fd_wait_for_event(fd
, POLLOUT
, SEND_TIMEOUT_USEC
);
1044 int manager_write(Manager
*m
, int fd
, DnsPacket
*p
) {
1047 log_debug("Sending %s packet with id %u", DNS_PACKET_QR(p
) ? "response" : "query", DNS_PACKET_ID(p
));
1049 r
= write_loop(fd
, DNS_PACKET_DATA(p
), p
->size
);
1056 static int manager_ipv4_send(Manager
*m
, int fd
, int ifindex
, const struct in_addr
*addr
, uint16_t port
, DnsPacket
*p
) {
1057 union sockaddr_union sa
= {
1058 .in
.sin_family
= AF_INET
,
1061 struct cmsghdr header
; /* For alignment */
1062 uint8_t buffer
[CMSG_SPACE(sizeof(struct in_pktinfo
))];
1064 struct msghdr mh
= {};
1073 iov
.iov_base
= DNS_PACKET_DATA(p
);
1074 iov
.iov_len
= p
->size
;
1076 sa
.in
.sin_addr
= *addr
;
1077 sa
.in
.sin_port
= htobe16(port
),
1081 mh
.msg_name
= &sa
.sa
;
1082 mh
.msg_namelen
= sizeof(sa
.in
);
1085 struct cmsghdr
*cmsg
;
1086 struct in_pktinfo
*pi
;
1090 mh
.msg_control
= &control
;
1091 mh
.msg_controllen
= CMSG_LEN(sizeof(struct in_pktinfo
));
1093 cmsg
= CMSG_FIRSTHDR(&mh
);
1094 cmsg
->cmsg_len
= mh
.msg_controllen
;
1095 cmsg
->cmsg_level
= IPPROTO_IP
;
1096 cmsg
->cmsg_type
= IP_PKTINFO
;
1098 pi
= (struct in_pktinfo
*) CMSG_DATA(cmsg
);
1099 pi
->ipi_ifindex
= ifindex
;
1102 return sendmsg_loop(fd
, &mh
, 0);
1105 static int manager_ipv6_send(Manager
*m
, int fd
, int ifindex
, const struct in6_addr
*addr
, uint16_t port
, DnsPacket
*p
) {
1106 union sockaddr_union sa
= {
1107 .in6
.sin6_family
= AF_INET6
,
1110 struct cmsghdr header
; /* For alignment */
1111 uint8_t buffer
[CMSG_SPACE(sizeof(struct in6_pktinfo
))];
1113 struct msghdr mh
= {};
1122 iov
.iov_base
= DNS_PACKET_DATA(p
);
1123 iov
.iov_len
= p
->size
;
1125 sa
.in6
.sin6_addr
= *addr
;
1126 sa
.in6
.sin6_port
= htobe16(port
),
1127 sa
.in6
.sin6_scope_id
= ifindex
;
1131 mh
.msg_name
= &sa
.sa
;
1132 mh
.msg_namelen
= sizeof(sa
.in6
);
1135 struct cmsghdr
*cmsg
;
1136 struct in6_pktinfo
*pi
;
1140 mh
.msg_control
= &control
;
1141 mh
.msg_controllen
= CMSG_LEN(sizeof(struct in6_pktinfo
));
1143 cmsg
= CMSG_FIRSTHDR(&mh
);
1144 cmsg
->cmsg_len
= mh
.msg_controllen
;
1145 cmsg
->cmsg_level
= IPPROTO_IPV6
;
1146 cmsg
->cmsg_type
= IPV6_PKTINFO
;
1148 pi
= (struct in6_pktinfo
*) CMSG_DATA(cmsg
);
1149 pi
->ipi6_ifindex
= ifindex
;
1152 return sendmsg_loop(fd
, &mh
, 0);
1155 int manager_send(Manager
*m
, int fd
, int ifindex
, int family
, const union in_addr_union
*addr
, uint16_t port
, DnsPacket
*p
) {
1162 log_debug("Sending %s packet with id %u on interface %i/%s", DNS_PACKET_QR(p
) ? "response" : "query", DNS_PACKET_ID(p
), ifindex
, af_to_name(family
));
1164 if (family
== AF_INET
)
1165 return manager_ipv4_send(m
, fd
, ifindex
, &addr
->in
, port
, p
);
1166 else if (family
== AF_INET6
)
1167 return manager_ipv6_send(m
, fd
, ifindex
, &addr
->in6
, port
, p
);
1169 return -EAFNOSUPPORT
;
1172 DnsServer
* manager_find_dns_server(Manager
*m
, int family
, const union in_addr_union
*in_addr
) {
1178 LIST_FOREACH(servers
, s
, m
->dns_servers
)
1179 if (s
->family
== family
&& in_addr_equal(family
, &s
->address
, in_addr
) > 0)
1182 LIST_FOREACH(servers
, s
, m
->fallback_dns_servers
)
1183 if (s
->family
== family
&& in_addr_equal(family
, &s
->address
, in_addr
) > 0)
1189 DnsServer
*manager_set_dns_server(Manager
*m
, DnsServer
*s
) {
1192 if (m
->current_dns_server
== s
)
1196 _cleanup_free_
char *ip
= NULL
;
1198 in_addr_to_string(s
->family
, &s
->address
, &ip
);
1199 log_info("Switching to system DNS server %s.", strna(ip
));
1202 m
->current_dns_server
= s
;
1204 if (m
->unicast_scope
)
1205 dns_cache_flush(&m
->unicast_scope
->cache
);
1210 DnsServer
*manager_get_dns_server(Manager
*m
) {
1214 /* Try to read updates resolv.conf */
1215 manager_read_resolv_conf(m
);
1217 if (!m
->current_dns_server
)
1218 manager_set_dns_server(m
, m
->dns_servers
);
1220 if (!m
->current_dns_server
) {
1224 /* No DNS servers configured, let's see if there are
1225 * any on any links. If not, we use the fallback
1228 HASHMAP_FOREACH(l
, m
->links
, i
)
1229 if (l
->dns_servers
) {
1235 manager_set_dns_server(m
, m
->fallback_dns_servers
);
1238 return m
->current_dns_server
;
1241 void manager_next_dns_server(Manager
*m
) {
1244 /* If there's currently no DNS server set, then the next
1245 * manager_get_dns_server() will find one */
1246 if (!m
->current_dns_server
)
1249 /* Change to the next one */
1250 if (m
->current_dns_server
->servers_next
) {
1251 manager_set_dns_server(m
, m
->current_dns_server
->servers_next
);
1255 /* If there was no next one, then start from the beginning of
1257 if (m
->current_dns_server
->type
== DNS_SERVER_FALLBACK
)
1258 manager_set_dns_server(m
, m
->fallback_dns_servers
);
1260 manager_set_dns_server(m
, m
->dns_servers
);
1263 uint32_t manager_find_mtu(Manager
*m
) {
1268 /* If we don't know on which link a DNS packet would be
1269 * delivered, let's find the largest MTU that works on all
1270 * interfaces we know of */
1272 HASHMAP_FOREACH(l
, m
->links
, i
) {
1276 if (mtu
<= 0 || l
->mtu
< mtu
)
1283 int manager_find_ifindex(Manager
*m
, int family
, const union in_addr_union
*in_addr
) {
1288 a
= manager_find_link_address(m
, family
, in_addr
);
1290 return a
->link
->ifindex
;
1295 void manager_refresh_rrs(Manager
*m
) {
1301 m
->llmnr_host_ipv4_key
= dns_resource_key_unref(m
->llmnr_host_ipv4_key
);
1302 m
->llmnr_host_ipv6_key
= dns_resource_key_unref(m
->llmnr_host_ipv6_key
);
1304 HASHMAP_FOREACH(l
, m
->links
, i
) {
1305 link_add_rrs(l
, true);
1306 link_add_rrs(l
, false);
1310 int manager_next_hostname(Manager
*m
) {
1318 p
= strchr(m
->llmnr_hostname
, 0);
1321 while (p
> m
->llmnr_hostname
) {
1322 if (!strchr("0123456789", p
[-1]))
1328 if (*p
== 0 || safe_atou64(p
, &u
) < 0 || u
<= 0)
1331 /* Add a random number to the old value. This way we can avoid
1332 * that two hosts pick the same hostname, win on IPv4 and lose
1333 * on IPv6 (or vice versa), and pick the same hostname
1334 * replacement hostname, ad infinitum. We still want the
1335 * numbers to go up monotonically, hence we just add a random
1338 random_bytes(&a
, sizeof(a
));
1341 if (asprintf(&h
, "%.*s%" PRIu64
, (int) (p
- m
->llmnr_hostname
), m
->llmnr_hostname
, u
) < 0)
1344 r
= dns_name_concat(h
, "local", &k
);
1350 log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m
->llmnr_hostname
, h
);
1352 free(m
->llmnr_hostname
);
1353 m
->llmnr_hostname
= h
;
1355 free(m
->mdns_hostname
);
1356 m
->mdns_hostname
= k
;
1358 manager_refresh_rrs(m
);
1363 LinkAddress
* manager_find_link_address(Manager
*m
, int family
, const union in_addr_union
*in_addr
) {
1369 HASHMAP_FOREACH(l
, m
->links
, i
) {
1372 a
= link_find_address(l
, family
, in_addr
);
1380 bool manager_our_packet(Manager
*m
, DnsPacket
*p
) {
1384 return !!manager_find_link_address(m
, p
->family
, &p
->sender
);
1387 DnsScope
* manager_find_scope(Manager
*m
, DnsPacket
*p
) {
1393 l
= hashmap_get(m
->links
, INT_TO_PTR(p
->ifindex
));
1397 if (p
->protocol
== DNS_PROTOCOL_LLMNR
) {
1398 if (p
->family
== AF_INET
)
1399 return l
->llmnr_ipv4_scope
;
1400 else if (p
->family
== AF_INET6
)
1401 return l
->llmnr_ipv6_scope
;
1407 void manager_verify_all(Manager
*m
) {
1412 LIST_FOREACH(scopes
, s
, m
->dns_scopes
)
1413 dns_zone_verify_all(&s
->zone
);
1416 void manager_flush_dns_servers(Manager
*m
, DnsServerType t
) {
1421 if (t
== DNS_SERVER_SYSTEM
)
1422 while (m
->dns_servers
) {
1425 LIST_REMOVE(servers
, m
->dns_servers
, s
);
1426 dns_server_unref(s
);
1429 if (t
== DNS_SERVER_FALLBACK
)
1430 while (m
->fallback_dns_servers
) {
1431 s
= m
->fallback_dns_servers
;
1433 LIST_REMOVE(servers
, m
->fallback_dns_servers
, s
);
1434 dns_server_unref(s
);
1438 int manager_is_own_hostname(Manager
*m
, const char *name
) {
1444 if (m
->llmnr_hostname
) {
1445 r
= dns_name_equal(name
, m
->llmnr_hostname
);
1450 if (m
->mdns_hostname
)
1451 return dns_name_equal(name
, m
->mdns_hostname
);
1456 static const char* const support_table
[_SUPPORT_MAX
] = {
1457 [SUPPORT_NO
] = "no",
1458 [SUPPORT_YES
] = "yes",
1459 [SUPPORT_RESOLVE
] = "resolve",
1461 DEFINE_STRING_TABLE_LOOKUP(support
, Support
);