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 <arpa/inet.h>
25 #include <sys/ioctl.h>
27 #include <netinet/in.h>
29 #include "rtnl-util.h"
30 #include "event-util.h"
31 #include "network-util.h"
32 #include "network-internal.h"
33 #include "conf-parser.h"
34 #include "socket-util.h"
38 #include "resolved-dns-domain.h"
39 #include "resolved-conf.h"
40 #include "resolved-bus.h"
41 #include "resolved-manager.h"
43 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
45 static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
46 Manager *m = userdata;
55 r = sd_rtnl_message_get_type(mm, &type);
59 r = sd_rtnl_message_link_get_ifindex(mm, &ifindex);
63 l = hashmap_get(m->links, INT_TO_PTR(ifindex));
71 r = link_new(m, &l, ifindex);
76 r = link_update_rtnl(l, mm);
80 r = link_update_monitor(l);
85 log_debug("Found new link %i/%s", ifindex, l->name);
92 log_debug("Removing link %i/%s", l->ifindex, l->name);
102 log_warning("Failed to process RTNL link message: %s", strerror(-r));
106 static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
107 Manager *m = userdata;
108 union in_addr_union address;
110 int r, ifindex, family;
118 r = sd_rtnl_message_get_type(mm, &type);
122 r = sd_rtnl_message_addr_get_ifindex(mm, &ifindex);
126 l = hashmap_get(m->links, INT_TO_PTR(ifindex));
130 r = sd_rtnl_message_addr_get_family(mm, &family);
137 r = sd_rtnl_message_read_in_addr(mm, IFA_LOCAL, &address.in);
139 r = sd_rtnl_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
147 r = sd_rtnl_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
149 r = sd_rtnl_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
160 a = link_find_address(l, family, &address);
167 r = link_address_new(l, &a, family, &address);
172 r = link_address_update_rtnl(a, mm);
180 link_address_free(a);
187 log_warning("Failed to process RTNL address message: %s", strerror(-r));
191 static int manager_rtnl_listen(Manager *m) {
192 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
198 /* First, subscibe to interfaces coming and going */
199 r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR);
203 r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
207 r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, manager_process_link, m);
211 r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, manager_process_link, m);
215 r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, manager_process_address, m);
219 r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, manager_process_address, m);
223 /* Then, enumerate all links */
224 r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
228 r = sd_rtnl_message_request_dump(req, true);
232 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
236 for (i = reply; i; i = sd_rtnl_message_next(i)) {
237 r = manager_process_link(m->rtnl, i, m);
242 req = sd_rtnl_message_unref(req);
243 reply = sd_rtnl_message_unref(reply);
245 /* Finally, enumerate all addresses, too */
246 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC);
250 r = sd_rtnl_message_request_dump(req, true);
254 r = sd_rtnl_call(m->rtnl, req, 0, &reply);
258 for (i = reply; i; i = sd_rtnl_message_next(i)) {
259 r = manager_process_address(m->rtnl, i, m);
267 static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
268 Manager *m = userdata;
275 sd_network_monitor_flush(m->network_monitor);
277 HASHMAP_FOREACH(l, m->links, i) {
278 r = link_update_monitor(l);
280 log_warning("Failed to update monitor information for %i: %s", l->ifindex, strerror(-r));
283 r = manager_write_resolv_conf(m);
285 log_warning("Could not update resolv.conf: %s", strerror(-r));
290 static int manager_network_monitor_listen(Manager *m) {
295 r = sd_network_monitor_new(&m->network_monitor, NULL);
299 fd = sd_network_monitor_get_fd(m->network_monitor);
303 events = sd_network_monitor_get_events(m->network_monitor);
307 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, &on_network_event, m);
314 static int determine_hostname(char **ret) {
315 _cleanup_free_ char *h = NULL, *n = NULL;
320 h = gethostname_malloc();
324 if (!utf8_is_valid(h)) {
325 log_error("System hostname is not UTF-8 clean.");
329 r = dns_name_normalize(h, &n);
331 log_error("System hostname '%s' cannot be normalized.", h);
341 static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
342 _cleanup_free_ char *h = NULL;
343 Manager *m = userdata;
348 r = determine_hostname(&h);
350 return 0; /* ignore invalid hostnames */
352 if (streq(h, m->hostname))
355 log_info("System hostname changed to '%s'.", h);
360 manager_refresh_rrs(m);
365 static int manager_watch_hostname(Manager *m) {
370 m->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NDELAY|O_NOCTTY);
371 if (m->hostname_fd < 0) {
372 log_warning("Failed to watch hostname: %m");
376 r = sd_event_add_io(m->event, &m->hostname_event_source, m->hostname_fd, 0, on_hostname_change, m);
379 /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */
380 m->hostname_fd = safe_close(m->hostname_fd);
382 log_error("Failed to add hostname event source: %s", strerror(-r));
387 r = determine_hostname(&m->hostname);
389 log_info("Defaulting to hostname 'linux'.");
390 m->hostname = strdup("linux");
394 log_info("Using system hostname '%s'.", m->hostname);
399 static void manager_llmnr_stop(Manager *m) {
402 m->llmnr_ipv4_udp_event_source = sd_event_source_unref(m->llmnr_ipv4_udp_event_source);
403 m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd);
405 m->llmnr_ipv6_udp_event_source = sd_event_source_unref(m->llmnr_ipv6_udp_event_source);
406 m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd);
408 m->llmnr_ipv4_tcp_event_source = sd_event_source_unref(m->llmnr_ipv4_tcp_event_source);
409 m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd);
411 m->llmnr_ipv6_tcp_event_source = sd_event_source_unref(m->llmnr_ipv6_tcp_event_source);
412 m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd);
415 static int manager_llmnr_start(Manager *m) {
420 if (m->llmnr_support == SUPPORT_NO)
423 r = manager_llmnr_ipv4_udp_fd(m);
424 if (r == -EADDRINUSE)
429 r = manager_llmnr_ipv6_udp_fd(m);
430 if (r == -EADDRINUSE)
435 r = manager_llmnr_ipv4_tcp_fd(m);
436 if (r == -EADDRINUSE)
441 r = manager_llmnr_ipv6_tcp_fd(m);
442 if (r == -EADDRINUSE)
450 log_warning("There appears to be another LLMNR respondering running. Turning off LLMNR support.");
451 m->llmnr_support = SUPPORT_NO;
452 manager_llmnr_stop(m);
456 int manager_new(Manager **ret) {
457 _cleanup_(manager_freep) Manager *m = NULL;
462 m = new0(Manager, 1);
466 m->dns_ipv4_fd = m->dns_ipv6_fd = -1;
467 m->llmnr_ipv4_udp_fd = m->llmnr_ipv6_udp_fd = -1;
468 m->llmnr_ipv4_tcp_fd = m->llmnr_ipv6_tcp_fd = -1;
471 m->llmnr_support = SUPPORT_YES;
472 m->read_resolv_conf = true;
474 r = manager_parse_dns_server(m, DNS_SERVER_FALLBACK, DNS_SERVERS);
478 r = sd_event_default(&m->event);
482 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
483 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
485 sd_event_set_watchdog(m->event, true);
487 r = manager_watch_hostname(m);
491 r = dns_scope_new(m, &m->unicast_scope, NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
495 r = manager_network_monitor_listen(m);
499 r = manager_rtnl_listen(m);
503 r = manager_connect_bus(m);
513 int manager_start(Manager *m) {
518 r = manager_llmnr_start(m);
525 Manager *manager_free(Manager *m) {
531 while ((l = hashmap_first(m->links)))
534 while (m->dns_queries)
535 dns_query_free(m->dns_queries);
537 dns_scope_free(m->unicast_scope);
539 while (m->dns_servers)
540 dns_server_free(m->dns_servers);
541 while (m->fallback_dns_servers)
542 dns_server_free(m->fallback_dns_servers);
544 hashmap_free(m->links);
545 hashmap_free(m->dns_transactions);
547 sd_event_source_unref(m->network_event_source);
548 sd_network_monitor_unref(m->network_monitor);
550 sd_event_source_unref(m->dns_ipv4_event_source);
551 sd_event_source_unref(m->dns_ipv6_event_source);
552 safe_close(m->dns_ipv4_fd);
553 safe_close(m->dns_ipv6_fd);
555 manager_llmnr_stop(m);
557 sd_event_source_unref(m->bus_retry_event_source);
558 sd_bus_unref(m->bus);
560 sd_event_unref(m->event);
562 dns_resource_key_unref(m->host_ipv4_key);
563 dns_resource_key_unref(m->host_ipv6_key);
565 safe_close(m->hostname_fd);
566 sd_event_source_unref(m->hostname_event_source);
574 int manager_read_resolv_conf(Manager *m) {
575 _cleanup_fclose_ FILE *f = NULL;
584 /* Reads the system /etc/resolv.conf, if it exists and is not
585 * symlinked to our own resolv.conf instance */
587 if (!m->read_resolv_conf)
590 r = stat("/etc/resolv.conf", &st);
593 log_warning("Failed to open /etc/resolv.conf: %m");
598 /* Have we already seen the file? */
599 t = timespec_load(&st.st_mtim);
600 if (t == m->resolv_conf_mtime)
603 m->resolv_conf_mtime = t;
605 /* Is it symlinked to our own file? */
606 if (stat("/run/systemd/resolve/resolv.conf", &own) >= 0 &&
607 st.st_dev == own.st_dev &&
608 st.st_ino == own.st_ino) {
613 f = fopen("/etc/resolv.conf", "re");
616 log_warning("Failed to open /etc/resolv.conf: %m");
621 if (fstat(fileno(f), &st) < 0) {
622 log_error("Failed to stat open file: %m");
627 LIST_FOREACH(servers, s, m->dns_servers)
630 FOREACH_LINE(line, f, r = -errno; goto clear) {
631 union in_addr_union address;
639 if (*l == '#' || *l == ';')
642 a = first_word(l, "nameserver");
646 r = in_addr_from_string_auto(a, &family, &address);
648 log_warning("Failed to parse name server %s.", a);
652 LIST_FOREACH(servers, s, m->dns_servers)
653 if (s->family == family && in_addr_equal(family, &s->address, &address) > 0)
659 r = dns_server_new(m, NULL, DNS_SERVER_SYSTEM, NULL, family, &address);
665 LIST_FOREACH_SAFE(servers, s, nx, m->dns_servers)
672 while (m->dns_servers)
673 dns_server_free(m->dns_servers);
678 static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) {
679 _cleanup_free_ char *t = NULL;
686 r = in_addr_to_string(s->family, &s->address, &t);
688 log_warning("Invalid DNS address. Ignoring: %s", strerror(-r));
693 fputs("# Too many DNS servers configured, the following entries may be ignored\n", f);
695 fprintf(f, "nameserver %s\n", t);
699 int manager_write_resolv_conf(Manager *m) {
700 static const char path[] = "/run/systemd/resolve/resolv.conf";
701 _cleanup_free_ char *temp_path = NULL;
702 _cleanup_fclose_ FILE *f = NULL;
711 /* Read the system /etc/resolv.conf first */
712 manager_read_resolv_conf(m);
714 r = fopen_temporary(path, &f, &temp_path);
718 fchmod(fileno(f), 0644);
720 fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n"
721 "# Third party programs must not access this file directly, but\n"
722 "# only through the symlink at /etc/resolv.conf. To manage\n"
723 "# resolv.conf(5) in a different way, replace the symlink by a\n"
724 "# static file or a different symlink.\n\n", f);
726 LIST_FOREACH(servers, s, m->dns_servers)
727 write_resolve_conf_server(s, f, &count);
729 HASHMAP_FOREACH(l, m->links, i)
730 LIST_FOREACH(servers, s, l->dns_servers)
731 write_resolve_conf_server(s, f, &count);
734 LIST_FOREACH(servers, s, m->fallback_dns_servers)
735 write_resolve_conf_server(s, f, &count);
738 r = fflush_and_check(f);
742 if (rename(temp_path, path) < 0) {
755 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
756 _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
758 struct cmsghdr header; /* For alignment */
759 uint8_t buffer[CMSG_SPACE(MAX(sizeof(struct in_pktinfo), sizeof(struct in6_pktinfo)))
760 + CMSG_SPACE(int) /* ttl/hoplimit */
761 + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
763 union sockaddr_union sa;
764 struct msghdr mh = {};
765 struct cmsghdr *cmsg;
774 r = ioctl(fd, FIONREAD, &ms);
780 r = dns_packet_new(&p, protocol, ms);
784 iov.iov_base = DNS_PACKET_DATA(p);
785 iov.iov_len = p->allocated;
787 mh.msg_name = &sa.sa;
788 mh.msg_namelen = sizeof(sa);
791 mh.msg_control = &control;
792 mh.msg_controllen = sizeof(control);
794 l = recvmsg(fd, &mh, 0);
796 if (errno == EAGAIN || errno == EINTR)
805 assert(!(mh.msg_flags & MSG_CTRUNC));
806 assert(!(mh.msg_flags & MSG_TRUNC));
808 p->size = (size_t) l;
810 p->family = sa.sa.sa_family;
811 p->ipproto = IPPROTO_UDP;
812 if (p->family == AF_INET) {
813 p->sender.in = sa.in.sin_addr;
814 p->sender_port = be16toh(sa.in.sin_port);
815 } else if (p->family == AF_INET6) {
816 p->sender.in6 = sa.in6.sin6_addr;
817 p->sender_port = be16toh(sa.in6.sin6_port);
818 p->ifindex = sa.in6.sin6_scope_id;
820 return -EAFNOSUPPORT;
822 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
824 if (cmsg->cmsg_level == IPPROTO_IPV6) {
825 assert(p->family == AF_INET6);
827 switch (cmsg->cmsg_type) {
830 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
833 p->ifindex = i->ipi6_ifindex;
835 p->destination.in6 = i->ipi6_addr;
840 p->ttl = *(int *) CMSG_DATA(cmsg);
844 } else if (cmsg->cmsg_level == IPPROTO_IP) {
845 assert(p->family == AF_INET);
847 switch (cmsg->cmsg_type) {
850 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
853 p->ifindex = i->ipi_ifindex;
855 p->destination.in = i->ipi_addr;
860 p->ttl = *(int *) CMSG_DATA(cmsg);
866 /* The Linux kernel sets the interface index to the loopback
867 * device if the packet came from the local host since it
868 * avoids the routing table in such a case. Let's unset the
869 * interface index in such a case. */
870 if (p->ifindex > 0 && manager_ifindex_is_loopback(m, p->ifindex) != 0)
873 /* If we don't know the interface index still, we look for the
874 * first local interface with a matching address. Yuck! */
876 p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
884 static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
885 _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
886 DnsTransaction *t = NULL;
887 Manager *m = userdata;
890 r = manager_recv(m, fd, DNS_PROTOCOL_DNS, &p);
894 if (dns_packet_validate_reply(p) > 0) {
895 t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
899 dns_transaction_process_reply(t, p);
902 log_debug("Invalid DNS packet.");
907 int manager_dns_ipv4_fd(Manager *m) {
913 if (m->dns_ipv4_fd >= 0)
914 return m->dns_ipv4_fd;
916 m->dns_ipv4_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
917 if (m->dns_ipv4_fd < 0)
920 r = setsockopt(m->dns_ipv4_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
926 r = sd_event_add_io(m->event, &m->dns_ipv4_event_source, m->dns_ipv4_fd, EPOLLIN, on_dns_packet, m);
930 return m->dns_ipv4_fd;
933 m->dns_ipv4_fd = safe_close(m->dns_ipv4_fd);
937 int manager_dns_ipv6_fd(Manager *m) {
943 if (m->dns_ipv6_fd >= 0)
944 return m->dns_ipv6_fd;
946 m->dns_ipv6_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
947 if (m->dns_ipv6_fd < 0)
950 r = setsockopt(m->dns_ipv6_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
956 r = sd_event_add_io(m->event, &m->dns_ipv6_event_source, m->dns_ipv6_fd, EPOLLIN, on_dns_packet, m);
960 return m->dns_ipv6_fd;
963 m->dns_ipv6_fd = safe_close(m->dns_ipv6_fd);
967 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
974 if (sendmsg(fd, mh, flags) >= 0)
983 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
991 static int manager_ipv4_send(Manager *m, int fd, int ifindex, const struct in_addr *addr, uint16_t port, DnsPacket *p) {
992 union sockaddr_union sa = {
993 .in.sin_family = AF_INET,
996 struct cmsghdr header; /* For alignment */
997 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
999 struct msghdr mh = {};
1008 iov.iov_base = DNS_PACKET_DATA(p);
1009 iov.iov_len = p->size;
1011 sa.in.sin_addr = *addr;
1012 sa.in.sin_port = htobe16(port),
1016 mh.msg_name = &sa.sa;
1017 mh.msg_namelen = sizeof(sa.in);
1020 struct cmsghdr *cmsg;
1021 struct in_pktinfo *pi;
1025 mh.msg_control = &control;
1026 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
1028 cmsg = CMSG_FIRSTHDR(&mh);
1029 cmsg->cmsg_len = mh.msg_controllen;
1030 cmsg->cmsg_level = IPPROTO_IP;
1031 cmsg->cmsg_type = IP_PKTINFO;
1033 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
1034 pi->ipi_ifindex = ifindex;
1037 return sendmsg_loop(fd, &mh, 0);
1040 static int manager_ipv6_send(Manager *m, int fd, int ifindex, const struct in6_addr *addr, uint16_t port, DnsPacket *p) {
1041 union sockaddr_union sa = {
1042 .in6.sin6_family = AF_INET6,
1045 struct cmsghdr header; /* For alignment */
1046 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
1048 struct msghdr mh = {};
1057 iov.iov_base = DNS_PACKET_DATA(p);
1058 iov.iov_len = p->size;
1060 sa.in6.sin6_addr = *addr;
1061 sa.in6.sin6_port = htobe16(port),
1062 sa.in6.sin6_scope_id = ifindex;
1066 mh.msg_name = &sa.sa;
1067 mh.msg_namelen = sizeof(sa.in6);
1070 struct cmsghdr *cmsg;
1071 struct in6_pktinfo *pi;
1075 mh.msg_control = &control;
1076 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
1078 cmsg = CMSG_FIRSTHDR(&mh);
1079 cmsg->cmsg_len = mh.msg_controllen;
1080 cmsg->cmsg_level = IPPROTO_IPV6;
1081 cmsg->cmsg_type = IPV6_PKTINFO;
1083 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
1084 pi->ipi6_ifindex = ifindex;
1087 return sendmsg_loop(fd, &mh, 0);
1090 int manager_send(Manager *m, int fd, int ifindex, int family, const union in_addr_union *addr, uint16_t port, DnsPacket *p) {
1097 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));
1099 if (family == AF_INET)
1100 return manager_ipv4_send(m, fd, ifindex, &addr->in, port, p);
1101 else if (family == AF_INET6)
1102 return manager_ipv6_send(m, fd, ifindex, &addr->in6, port, p);
1104 return -EAFNOSUPPORT;
1107 DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) {
1113 LIST_FOREACH(servers, s, m->dns_servers)
1114 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1117 LIST_FOREACH(servers, s, m->fallback_dns_servers)
1118 if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0)
1124 DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) {
1127 if (m->current_dns_server == s)
1131 _cleanup_free_ char *ip = NULL;
1133 in_addr_to_string(s->family, &s->address, &ip);
1134 log_info("Switching to system DNS server %s.", strna(ip));
1137 m->current_dns_server = s;
1139 if (m->unicast_scope)
1140 dns_cache_flush(&m->unicast_scope->cache);
1145 DnsServer *manager_get_dns_server(Manager *m) {
1149 /* Try to read updates resolv.conf */
1150 manager_read_resolv_conf(m);
1152 if (!m->current_dns_server)
1153 manager_set_dns_server(m, m->dns_servers);
1155 if (!m->current_dns_server) {
1159 /* No DNS servers configured, let's see if there are
1160 * any on any links. If not, we use the fallback
1163 HASHMAP_FOREACH(l, m->links, i)
1164 if (l->dns_servers) {
1170 manager_set_dns_server(m, m->fallback_dns_servers);
1173 return m->current_dns_server;
1176 void manager_next_dns_server(Manager *m) {
1179 /* If there's currently no DNS server set, then the next
1180 * manager_get_dns_server() will find one */
1181 if (!m->current_dns_server)
1184 /* Change to the next one */
1185 if (m->current_dns_server->servers_next) {
1186 manager_set_dns_server(m, m->current_dns_server->servers_next);
1190 /* If there was no next one, then start from the beginning of
1192 if (m->current_dns_server->type == DNS_SERVER_FALLBACK)
1193 manager_set_dns_server(m, m->fallback_dns_servers);
1195 manager_set_dns_server(m, m->dns_servers);
1198 uint32_t manager_find_mtu(Manager *m) {
1203 /* If we don't know on which link a DNS packet would be
1204 * delivered, let's find the largest MTU that works on all
1205 * interfaces we know of */
1207 HASHMAP_FOREACH(l, m->links, i) {
1211 if (mtu <= 0 || l->mtu < mtu)
1218 static int on_llmnr_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1219 _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
1220 DnsTransaction *t = NULL;
1221 Manager *m = userdata;
1224 r = manager_recv(m, fd, DNS_PROTOCOL_LLMNR, &p);
1228 if (dns_packet_validate_reply(p) > 0) {
1229 log_debug("Got reply packet for id %u", DNS_PACKET_ID(p));
1231 t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
1235 dns_transaction_process_reply(t, p);
1237 } else if (dns_packet_validate_query(p) > 0) {
1240 l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1242 DnsScope *scope = NULL;
1244 if (p->family == AF_INET)
1245 scope = l->llmnr_ipv4_scope;
1246 else if (p->family == AF_INET6)
1247 scope = l->llmnr_ipv6_scope;
1250 dns_scope_process_query(scope, NULL, p);
1253 log_debug("Invalid LLMNR packet.");
1258 int manager_llmnr_ipv4_udp_fd(Manager *m) {
1259 union sockaddr_union sa = {
1260 .in.sin_family = AF_INET,
1261 .in.sin_port = htobe16(5355),
1263 static const int one = 1, pmtu = IP_PMTUDISC_DONT, ttl = 255;
1268 if (m->llmnr_ipv4_udp_fd >= 0)
1269 return m->llmnr_ipv4_udp_fd;
1271 m->llmnr_ipv4_udp_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1272 if (m->llmnr_ipv4_udp_fd < 0)
1275 /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */
1276 r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
1282 r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
1288 r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(one));
1294 r = setsockopt(m->llmnr_ipv4_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1300 r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
1306 r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one));
1312 /* Disable Don't-Fragment bit in the IP header */
1313 r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
1319 r = bind(m->llmnr_ipv4_udp_fd, &sa.sa, sizeof(sa.in));
1325 r = sd_event_add_io(m->event, &m->llmnr_ipv4_udp_event_source, m->llmnr_ipv4_udp_fd, EPOLLIN, on_llmnr_packet, m);
1329 return m->llmnr_ipv4_udp_fd;
1332 m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd);
1336 int manager_llmnr_ipv6_udp_fd(Manager *m) {
1337 union sockaddr_union sa = {
1338 .in6.sin6_family = AF_INET6,
1339 .in6.sin6_port = htobe16(5355),
1341 static const int one = 1, ttl = 255;
1346 if (m->llmnr_ipv6_udp_fd >= 0)
1347 return m->llmnr_ipv6_udp_fd;
1349 m->llmnr_ipv6_udp_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1350 if (m->llmnr_ipv6_udp_fd < 0)
1353 r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl));
1359 /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */
1360 r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl));
1366 r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &one, sizeof(one));
1372 r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
1378 r = setsockopt(m->llmnr_ipv6_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1384 r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
1390 r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
1396 r = bind(m->llmnr_ipv6_udp_fd, &sa.sa, sizeof(sa.in6));
1402 r = sd_event_add_io(m->event, &m->llmnr_ipv6_udp_event_source, m->llmnr_ipv6_udp_fd, EPOLLIN, on_llmnr_packet, m);
1408 return m->llmnr_ipv6_udp_fd;
1411 m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd);
1415 static int on_llmnr_stream_packet(DnsStream *s) {
1418 if (dns_packet_validate_query(s->read_packet) > 0) {
1421 l = hashmap_get(s->manager->links, INT_TO_PTR(s->read_packet->ifindex));
1423 DnsScope *scope = NULL;
1425 if (s->read_packet->family == AF_INET)
1426 scope = l->llmnr_ipv4_scope;
1427 else if (s->read_packet->family == AF_INET6)
1428 scope = l->llmnr_ipv6_scope;
1431 dns_scope_process_query(scope, s, s->read_packet);
1433 /* If no reply packet was set, we free the stream */
1434 if (s->write_packet)
1444 static int on_llmnr_stream(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1446 Manager *m = userdata;
1449 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1451 if (errno == EAGAIN || errno == EINTR)
1457 r = dns_stream_new(m, &stream, DNS_PROTOCOL_LLMNR, cfd);
1463 stream->on_packet = on_llmnr_stream_packet;
1467 int manager_llmnr_ipv4_tcp_fd(Manager *m) {
1468 union sockaddr_union sa = {
1469 .in.sin_family = AF_INET,
1470 .in.sin_port = htobe16(5355),
1472 static const int one = 1, pmtu = IP_PMTUDISC_DONT;
1477 if (m->llmnr_ipv4_tcp_fd >= 0)
1478 return m->llmnr_ipv4_tcp_fd;
1480 m->llmnr_ipv4_tcp_fd = socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1481 if (m->llmnr_ipv4_tcp_fd < 0)
1484 /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */
1485 r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_TTL, &one, sizeof(one));
1491 r = setsockopt(m->llmnr_ipv4_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1497 r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
1503 r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one));
1509 /* Disable Don't-Fragment bit in the IP header */
1510 r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
1516 r = bind(m->llmnr_ipv4_tcp_fd, &sa.sa, sizeof(sa.in));
1522 r = listen(m->llmnr_ipv4_tcp_fd, SOMAXCONN);
1528 r = sd_event_add_io(m->event, &m->llmnr_ipv4_tcp_event_source, m->llmnr_ipv4_tcp_fd, EPOLLIN, on_llmnr_stream, m);
1532 return m->llmnr_ipv4_tcp_fd;
1535 m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd);
1539 int manager_llmnr_ipv6_tcp_fd(Manager *m) {
1540 union sockaddr_union sa = {
1541 .in6.sin6_family = AF_INET6,
1542 .in6.sin6_port = htobe16(5355),
1544 static const int one = 1;
1549 if (m->llmnr_ipv6_tcp_fd >= 0)
1550 return m->llmnr_ipv6_tcp_fd;
1552 m->llmnr_ipv6_tcp_fd = socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1553 if (m->llmnr_ipv6_tcp_fd < 0)
1556 /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */
1557 r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &one, sizeof(one));
1563 r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
1569 r = setsockopt(m->llmnr_ipv6_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1575 r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
1581 r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
1587 r = bind(m->llmnr_ipv6_tcp_fd, &sa.sa, sizeof(sa.in6));
1593 r = listen(m->llmnr_ipv6_tcp_fd, SOMAXCONN);
1599 r = sd_event_add_io(m->event, &m->llmnr_ipv6_tcp_event_source, m->llmnr_ipv6_tcp_fd, EPOLLIN, on_llmnr_stream, m);
1605 return m->llmnr_ipv6_tcp_fd;
1608 m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd);
1612 int manager_ifindex_is_loopback(Manager *m, int ifindex) {
1619 l = hashmap_get(m->links, INT_TO_PTR(ifindex));
1620 if (l->flags & IFF_LOOPBACK)
1626 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1631 a = manager_find_link_address(m, family, in_addr);
1633 return a->link->ifindex;
1638 void manager_refresh_rrs(Manager *m) {
1644 m->host_ipv4_key = dns_resource_key_unref(m->host_ipv4_key);
1645 m->host_ipv6_key = dns_resource_key_unref(m->host_ipv6_key);
1647 HASHMAP_FOREACH(l, m->links, i) {
1648 link_add_rrs(l, true);
1649 link_add_rrs(l, false);
1653 int manager_next_hostname(Manager *m) {
1660 p = strchr(m->hostname, 0);
1663 while (p > m->hostname) {
1664 if (!strchr("0123456789", p[-1]))
1670 if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0)
1675 if (asprintf(&h, "%.*s%" PRIu64, (int) (p - m->hostname), m->hostname, u) < 0)
1678 log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->hostname, h);
1683 manager_refresh_rrs(m);
1688 LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
1694 HASHMAP_FOREACH(l, m->links, i) {
1697 a = link_find_address(l, family, in_addr);
1705 int manager_our_packet(Manager *m, DnsPacket *p) {
1709 return !!manager_find_link_address(m, p->family, &p->sender);
1712 static const char* const support_table[_SUPPORT_MAX] = {
1713 [SUPPORT_NO] = "no",
1714 [SUPPORT_YES] = "yes",
1715 [SUPPORT_RESOLVE] = "resolve",
1717 DEFINE_STRING_TABLE_LOOKUP(support, Support);