X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fresolve%2Fresolved-manager.c;h=bfbdc7d55bc43aacd49cf64e4ec5075c9c4e2062;hp=19ea678de09703b7ecb6568d5dfb921daadc0b77;hb=bda2c408f8a739c19161818bcc842107f60652a2;hpb=faa133f3aa7a18f26563dc5d6b95898cb315c37a diff --git a/src/resolve/resolved-manager.c b/src/resolve/resolved-manager.c index 19ea678de..bfbdc7d55 100644 --- a/src/resolve/resolved-manager.c +++ b/src/resolve/resolved-manager.c @@ -29,12 +29,16 @@ #include "rtnl-util.h" #include "event-util.h" #include "network-util.h" -#include "sd-dhcp-lease.h" -#include "dhcp-lease-internal.h" #include "network-internal.h" #include "conf-parser.h" #include "socket-util.h" -#include "resolved.h" +#include "af-list.h" +#include "utf8.h" + +#include "resolved-dns-domain.h" +#include "resolved-conf.h" +#include "resolved-bus.h" +#include "resolved-manager.h" #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC) @@ -60,10 +64,10 @@ static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userda switch (type) { - case RTM_NEWLINK: - if (!l) { - log_debug("Found link %i", ifindex); + case RTM_NEWLINK:{ + bool is_new = !l; + if (!l) { r = link_new(m, &l, ifindex); if (r < 0) goto fail; @@ -73,11 +77,19 @@ static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userda if (r < 0) goto fail; + r = link_update_monitor(l); + if (r < 0) + goto fail; + + if (is_new) + log_debug("Found new link %i/%s", ifindex, l->name); + break; + } case RTM_DELLINK: if (l) { - log_debug("Removing link %i", l->ifindex); + log_debug("Removing link %i/%s", l->ifindex, l->name); link_free(l); } @@ -176,7 +188,6 @@ fail: return 0; } - static int manager_rtnl_listen(Manager *m) { _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL; sd_rtnl_message *i; @@ -300,84 +311,149 @@ static int manager_network_monitor_listen(Manager *m) { return 0; } -static int parse_dns_server_string(Manager *m, const char *string) { - char *word, *state; - size_t length; +static int determine_hostname(char **ret) { + _cleanup_free_ char *h = NULL, *n = NULL; int r; - assert(m); - assert(string); - - FOREACH_WORD_QUOTED(word, length, string, state) { - char buffer[length+1]; - int family; - union in_addr_union addr; + assert(ret); - memcpy(buffer, word, length); - buffer[length] = 0; + h = gethostname_malloc(); + if (!h) + return log_oom(); - r = in_addr_from_string_auto(buffer, &family, &addr); - if (r < 0) { - log_warning("Ignoring invalid DNS address '%s'", buffer); - continue; - } - - /* filter out duplicates */ - if (manager_find_dns_server(m, family, &addr)) - continue; + if (!utf8_is_valid(h)) { + log_error("System hostname is not UTF-8 clean."); + return -EINVAL; + } - r = dns_server_new(m, NULL, DNS_SERVER_SYSTEM, NULL, family, &addr); - if (r < 0) - return r; + r = dns_name_normalize(h, &n); + if (r < 0) { + log_error("System hostname '%s' cannot be normalized.", h); + return r; } + *ret = n; + n = NULL; + return 0; } -int config_parse_dnsv( - const char *unit, - const char *filename, - unsigned line, - const char *section, - unsigned section_line, - const char *lvalue, - int ltype, - const char *rvalue, - void *data, - void *userdata) { - +static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) { + _cleanup_free_ char *h = NULL; Manager *m = userdata; int r; - assert(filename); - assert(lvalue); - assert(rvalue); assert(m); - /* Empty assignment means clear the list */ - if (isempty(rvalue)) { - while (m->dns_servers) - dns_server_free(m->dns_servers); + r = determine_hostname(&h); + if (r < 0) + return 0; /* ignore invalid hostnames */ + if (streq(h, m->hostname)) + return 0; + + log_info("System hostname changed to '%s'.", h); + free(m->hostname); + m->hostname = h; + h = NULL; + + manager_refresh_rrs(m); + + return 0; +} + +static int manager_watch_hostname(Manager *m) { + int r; + + assert(m); + + m->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NDELAY|O_NOCTTY); + if (m->hostname_fd < 0) { + log_warning("Failed to watch hostname: %m"); return 0; } - r = parse_dns_server_string(m, rvalue); + r = sd_event_add_io(m->event, &m->hostname_event_source, m->hostname_fd, 0, on_hostname_change, m); if (r < 0) { - log_error("Failed to parse DNS server string"); - return r; + if (r == -EPERM) + /* kernels prior to 3.2 don't support polling this file. Ignore the failure. */ + m->hostname_fd = safe_close(m->hostname_fd); + else { + log_error("Failed to add hostname event source: %s", strerror(-r)); + return r; + } } + r = determine_hostname(&m->hostname); + if (r < 0) { + log_info("Defaulting to hostname 'linux'."); + m->hostname = strdup("linux"); + if (!m->hostname) + return log_oom(); + } else + log_info("Using system hostname '%s'.", m->hostname); + return 0; } -int manager_parse_config_file(Manager *m) { +static void manager_llmnr_stop(Manager *m) { assert(m); - return config_parse(NULL, "/etc/systemd/resolved.conf", NULL, - "Resolve\0", - config_item_perf_lookup, resolved_gperf_lookup, - false, false, true, m); + m->llmnr_ipv4_udp_event_source = sd_event_source_unref(m->llmnr_ipv4_udp_event_source); + m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd); + + m->llmnr_ipv6_udp_event_source = sd_event_source_unref(m->llmnr_ipv6_udp_event_source); + m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd); + + m->llmnr_ipv4_tcp_event_source = sd_event_source_unref(m->llmnr_ipv4_tcp_event_source); + m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd); + + m->llmnr_ipv6_tcp_event_source = sd_event_source_unref(m->llmnr_ipv6_tcp_event_source); + m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd); +} + +static int manager_llmnr_start(Manager *m) { + int r; + + assert(m); + + if (m->llmnr_support == SUPPORT_NO) + return 0; + + r = manager_llmnr_ipv4_udp_fd(m); + if (r == -EADDRINUSE) + goto eaddrinuse; + if (r < 0) + return r; + + r = manager_llmnr_ipv4_tcp_fd(m); + if (r == -EADDRINUSE) + goto eaddrinuse; + if (r < 0) + return r; + + if (socket_ipv6_is_supported()) { + r = manager_llmnr_ipv6_udp_fd(m); + if (r == -EADDRINUSE) + goto eaddrinuse; + if (r < 0) + return r; + + r = manager_llmnr_ipv6_tcp_fd(m); + if (r == -EADDRINUSE) + goto eaddrinuse; + if (r < 0) + return r; + } + + return 0; + +eaddrinuse: + log_warning("There appears to be another LLMNR respondering running. Turning off LLMNR support."); + m->llmnr_support = SUPPORT_NO; + manager_llmnr_stop(m); + + return 0; } int manager_new(Manager **ret) { @@ -392,10 +468,13 @@ int manager_new(Manager **ret) { m->dns_ipv4_fd = m->dns_ipv6_fd = -1; m->llmnr_ipv4_udp_fd = m->llmnr_ipv6_udp_fd = -1; + m->llmnr_ipv4_tcp_fd = m->llmnr_ipv6_tcp_fd = -1; + m->hostname_fd = -1; - m->use_llmnr = true; + m->llmnr_support = SUPPORT_YES; + m->read_resolv_conf = true; - r = parse_dns_server_string(m, DNS_SERVERS); + r = manager_parse_dns_server(m, DNS_SERVER_FALLBACK, DNS_SERVERS); if (r < 0) return r; @@ -408,6 +487,10 @@ int manager_new(Manager **ret) { sd_event_set_watchdog(m->event, true); + r = manager_watch_hostname(m); + if (r < 0) + return r; + r = dns_scope_new(m, &m->unicast_scope, NULL, DNS_PROTOCOL_DNS, AF_UNSPEC); if (r < 0) return r; @@ -430,25 +513,37 @@ int manager_new(Manager **ret) { return 0; } +int manager_start(Manager *m) { + int r; + + assert(m); + + r = manager_llmnr_start(m); + if (r < 0) + return r; + + return 0; +} + Manager *manager_free(Manager *m) { Link *l; if (!m) return NULL; - while (m->dns_queries) - dns_query_free(m->dns_queries); - - hashmap_free(m->dns_query_transactions); - while ((l = hashmap_first(m->links))) link_free(l); - hashmap_free(m->links); + + while (m->dns_queries) + dns_query_free(m->dns_queries); dns_scope_free(m->unicast_scope); - while (m->dns_servers) - dns_server_free(m->dns_servers); + manager_flush_dns_servers(m, DNS_SERVER_SYSTEM); + manager_flush_dns_servers(m, DNS_SERVER_FALLBACK); + + hashmap_free(m->links); + hashmap_free(m->dns_transactions); sd_event_source_unref(m->network_event_source); sd_network_monitor_unref(m->network_monitor); @@ -458,21 +553,131 @@ Manager *manager_free(Manager *m) { safe_close(m->dns_ipv4_fd); safe_close(m->dns_ipv6_fd); - sd_event_source_unref(m->llmnr_ipv4_udp_event_source); - sd_event_source_unref(m->llmnr_ipv6_udp_event_source); - safe_close(m->llmnr_ipv4_udp_fd); - safe_close(m->llmnr_ipv6_udp_fd); + manager_llmnr_stop(m); + sd_bus_slot_unref(m->prepare_for_sleep_slot); sd_event_source_unref(m->bus_retry_event_source); sd_bus_unref(m->bus); sd_event_unref(m->event); + + dns_resource_key_unref(m->host_ipv4_key); + dns_resource_key_unref(m->host_ipv6_key); + + safe_close(m->hostname_fd); + sd_event_source_unref(m->hostname_event_source); + free(m->hostname); + free(m); return NULL; } -static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) { +int manager_read_resolv_conf(Manager *m) { + _cleanup_fclose_ FILE *f = NULL; + struct stat st, own; + char line[LINE_MAX]; + DnsServer *s, *nx; + usec_t t; + int r; + + assert(m); + + /* Reads the system /etc/resolv.conf, if it exists and is not + * symlinked to our own resolv.conf instance */ + + if (!m->read_resolv_conf) + return 0; + + r = stat("/etc/resolv.conf", &st); + if (r < 0) { + if (errno != ENOENT) + log_warning("Failed to open /etc/resolv.conf: %m"); + r = -errno; + goto clear; + } + + /* Have we already seen the file? */ + t = timespec_load(&st.st_mtim); + if (t == m->resolv_conf_mtime) + return 0; + + m->resolv_conf_mtime = t; + + /* Is it symlinked to our own file? */ + if (stat("/run/systemd/resolve/resolv.conf", &own) >= 0 && + st.st_dev == own.st_dev && + st.st_ino == own.st_ino) { + r = 0; + goto clear; + } + + f = fopen("/etc/resolv.conf", "re"); + if (!f) { + if (errno != ENOENT) + log_warning("Failed to open /etc/resolv.conf: %m"); + r = -errno; + goto clear; + } + + if (fstat(fileno(f), &st) < 0) { + log_error("Failed to stat open file: %m"); + r = -errno; + goto clear; + } + + LIST_FOREACH(servers, s, m->dns_servers) + s->marked = true; + + FOREACH_LINE(line, f, r = -errno; goto clear) { + union in_addr_union address; + int family; + char *l; + const char *a; + + truncate_nl(line); + + l = strstrip(line); + if (*l == '#' || *l == ';') + continue; + + a = first_word(l, "nameserver"); + if (!a) + continue; + + r = in_addr_from_string_auto(a, &family, &address); + if (r < 0) { + log_warning("Failed to parse name server %s.", a); + continue; + } + + LIST_FOREACH(servers, s, m->dns_servers) + if (s->family == family && in_addr_equal(family, &s->address, &address) > 0) + break; + + if (s) + s->marked = false; + else { + r = dns_server_new(m, NULL, DNS_SERVER_SYSTEM, NULL, family, &address); + if (r < 0) + goto clear; + } + } + + LIST_FOREACH_SAFE(servers, s, nx, m->dns_servers) + if (s->marked) + dns_server_free(s); + + return 0; + +clear: + while (m->dns_servers) + dns_server_free(m->dns_servers); + + return r; +} + +static void write_resolv_conf_server(DnsServer *s, FILE *f, unsigned *count) { _cleanup_free_ char *t = NULL; int r; @@ -481,22 +686,45 @@ static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) { assert(count); r = in_addr_to_string(s->family, &s->address, &t); - if (r < 0) { - log_warning("Invalid DNS address. Ignoring."); + if (r < 0) { + log_warning("Invalid DNS address. Ignoring: %s", strerror(-r)); return; } if (*count == MAXNS) - fputs("# Too many DNS servers configured, the following entries may be ignored\n", f); + fputs("# Too many DNS servers configured, the following entries may be ignored.\n", f); fprintf(f, "nameserver %s\n", t); (*count) ++; } +static void write_resolv_conf_search(const char *domain, FILE *f, + unsigned *length, unsigned *count) { + assert(domain); + assert(f); + assert(length); + + if (*count >= MAXDNSRCH || + *length + strlen(domain) > 256) { + if (*count == MAXDNSRCH) + fputs(" # Too many search domains configured, remaining ones ignored.", f); + if (*length <= 256) + fputs(" # Total length of all search domains is too long, remaining ones ignored.", f); + + return; + } + + fprintf(f, " %s", domain); + + (*length) += strlen(domain); + (*count) ++; +} + int manager_write_resolv_conf(Manager *m) { - const char *path = "/run/systemd/resolve/resolv.conf"; + static const char path[] = "/run/systemd/resolve/resolv.conf"; _cleanup_free_ char *temp_path = NULL; _cleanup_fclose_ FILE *f = NULL; + _cleanup_set_free_ Set *dns = NULL, *domains = NULL; unsigned count = 0; DnsServer *s; Iterator i; @@ -505,6 +733,62 @@ int manager_write_resolv_conf(Manager *m) { assert(m); + /* Read the system /etc/resolv.conf first */ + manager_read_resolv_conf(m); + + /* Add the full list to a set, to filter out duplicates */ + dns = set_new(dns_server_hash_func, dns_server_compare_func); + if (!dns) + return -ENOMEM; + + domains = set_new(dns_name_hash_func, dns_name_compare_func); + if (!domains) + return -ENOMEM; + + /* First add the system-wide servers */ + LIST_FOREACH(servers, s, m->dns_servers) { + r = set_put(dns, s); + if (r == -EEXIST) + continue; + if (r < 0) + return r; + } + + /* Then, add the per-link servers and domains */ + HASHMAP_FOREACH(l, m->links, i) { + char **domain; + + LIST_FOREACH(servers, s, l->dns_servers) { + r = set_put(dns, s); + if (r == -EEXIST) + continue; + if (r < 0) + return r; + } + + if (!l->unicast_scope) + continue; + + STRV_FOREACH(domain, l->unicast_scope->domains) { + r = set_put(domains, *domain); + if (r == -EEXIST) + continue; + if (r < 0) + return r; + } + } + + /* If we found nothing, add the fallback servers */ + if (set_isempty(dns)) { + LIST_FOREACH(servers, s, m->fallback_dns_servers) { + r = set_put(dns, s); + if (r == -EEXIST) + continue; + if (r < 0) + return r; + } + } + r = fopen_temporary(path, &f, &temp_path); if (r < 0) return r; @@ -517,16 +801,24 @@ int manager_write_resolv_conf(Manager *m) { "# resolv.conf(5) in a different way, replace the symlink by a\n" "# static file or a different symlink.\n\n", f); - HASHMAP_FOREACH(l, m->links, i) { - LIST_FOREACH(servers, s, l->link_dns_servers) - write_resolve_conf_server(s, f, &count); - - LIST_FOREACH(servers, s, l->dhcp_dns_servers) - write_resolve_conf_server(s, f, &count); + if (set_isempty(dns)) + fputs("# No DNS servers known.\n", f); + else { + SET_FOREACH(s, dns, i) + write_resolv_conf_server(s, f, &count); } - LIST_FOREACH(servers, s, m->dns_servers) - write_resolve_conf_server(s, f, &count); + if (!set_isempty(domains)) { + unsigned length = 0; + char *domain; + + count = 0; + + fputs("search", f); + SET_FOREACH(domain, domains, i) + write_resolv_conf_search(domain, f, &count, &length); + fputs("\n", f); + } r = fflush_and_check(f); if (r < 0) @@ -551,7 +843,7 @@ int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) { struct cmsghdr header; /* For alignment */ uint8_t buffer[CMSG_SPACE(MAX(sizeof(struct in_pktinfo), sizeof(struct in6_pktinfo))) + CMSG_SPACE(int) /* ttl/hoplimit */ - + 1024 /* kernel appears to require extra buffer space */]; + + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */]; } control; union sockaddr_union sa; struct msghdr mh = {}; @@ -601,11 +893,15 @@ int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) { p->size = (size_t) l; p->family = sa.sa.sa_family; - if (p->family == AF_INET) + p->ipproto = IPPROTO_UDP; + if (p->family == AF_INET) { p->sender.in = sa.in.sin_addr; - else if (p->family == AF_INET6) + p->sender_port = be16toh(sa.in.sin_port); + } else if (p->family == AF_INET6) { p->sender.in6 = sa.in6.sin6_addr; - else + p->sender_port = be16toh(sa.in6.sin6_port); + p->ifindex = sa.in6.sin6_scope_id; + } else return -EAFNOSUPPORT; for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) { @@ -618,7 +914,9 @@ int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) { case IPV6_PKTINFO: { struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg); - p->ifindex = i->ipi6_ifindex; + if (p->ifindex <= 0) + p->ifindex = i->ipi6_ifindex; + p->destination.in6 = i->ipi6_addr; break; } @@ -636,18 +934,32 @@ int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) { case IP_PKTINFO: { struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg); - p->ifindex = i->ipi_ifindex; + if (p->ifindex <= 0) + p->ifindex = i->ipi_ifindex; + p->destination.in = i->ipi_addr; break; } - case IP_RECVTTL: + case IP_TTL: p->ttl = *(int *) CMSG_DATA(cmsg); break; } } } + /* The Linux kernel sets the interface index to the loopback + * device if the packet came from the local host since it + * avoids the routing table in such a case. Let's unset the + * interface index in such a case. */ + if (p->ifindex > 0 && manager_ifindex_is_loopback(m, p->ifindex) != 0) + p->ifindex = 0; + + /* If we don't know the interface index still, we look for the + * first local interface with a matching address. Yuck! */ + if (p->ifindex <= 0) + p->ifindex = manager_find_ifindex(m, p->family, &p->destination); + *ret = p; p = NULL; @@ -656,7 +968,7 @@ int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) { static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) { _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL; - DnsQueryTransaction *t = NULL; + DnsTransaction *t = NULL; Manager *m = userdata; int r; @@ -664,14 +976,15 @@ static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *use if (r <= 0) return r; - if (dns_packet_validate_reply(p) >= 0) { - t = hashmap_get(m->dns_query_transactions, UINT_TO_PTR(DNS_PACKET_ID(p))); + if (dns_packet_validate_reply(p) > 0) { + t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p))); if (!t) return 0; - dns_query_transaction_process_reply(t, p); + dns_transaction_process_reply(t, p); + } else - log_debug("Invalid reply packet."); + log_debug("Invalid DNS packet."); return 0; } @@ -760,7 +1073,7 @@ static int sendmsg_loop(int fd, struct msghdr *mh, int flags) { } } -static int manager_ipv4_send(Manager *m, int fd, int ifindex, struct in_addr *addr, uint16_t port, DnsPacket *p) { +static int manager_ipv4_send(Manager *m, int fd, int ifindex, const struct in_addr *addr, uint16_t port, DnsPacket *p) { union sockaddr_union sa = { .in.sin_family = AF_INET, }; @@ -809,7 +1122,7 @@ static int manager_ipv4_send(Manager *m, int fd, int ifindex, struct in_addr *ad return sendmsg_loop(fd, &mh, 0); } -static int manager_ipv6_send(Manager *m, int fd, int ifindex, struct in6_addr *addr, uint16_t port, DnsPacket *p) { +static int manager_ipv6_send(Manager *m, int fd, int ifindex, const struct in6_addr *addr, uint16_t port, DnsPacket *p) { union sockaddr_union sa = { .in6.sin6_family = AF_INET6, }; @@ -859,13 +1172,15 @@ static int manager_ipv6_send(Manager *m, int fd, int ifindex, struct in6_addr *a return sendmsg_loop(fd, &mh, 0); } -int manager_send(Manager *m, int fd, int ifindex, int family, union in_addr_union *addr, uint16_t port, DnsPacket *p) { +int manager_send(Manager *m, int fd, int ifindex, int family, const union in_addr_union *addr, uint16_t port, DnsPacket *p) { assert(m); assert(fd >= 0); assert(addr); assert(port > 0); assert(p); + 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)); + if (family == AF_INET) return manager_ipv4_send(m, fd, ifindex, &addr->in, port, p); else if (family == AF_INET6) @@ -874,28 +1189,71 @@ int manager_send(Manager *m, int fd, int ifindex, int family, union in_addr_unio return -EAFNOSUPPORT; } - -DnsServer* manager_find_dns_server(Manager *m, int family, union in_addr_union *in_addr) { +DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) { DnsServer *s; assert(m); assert(in_addr); - LIST_FOREACH(servers, s, m->dns_servers) { + LIST_FOREACH(servers, s, m->dns_servers) + if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0) + return s; - if (s->family == family && - in_addr_equal(family, &s->address, in_addr)) + LIST_FOREACH(servers, s, m->fallback_dns_servers) + if (s->family == family && in_addr_equal(family, &s->address, in_addr) > 0) return s; - } return NULL; } +DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) { + assert(m); + + if (m->current_dns_server == s) + return s; + + if (s) { + _cleanup_free_ char *ip = NULL; + + in_addr_to_string(s->family, &s->address, &ip); + log_info("Switching to system DNS server %s.", strna(ip)); + } + + m->current_dns_server = s; + + if (m->unicast_scope) + dns_cache_flush(&m->unicast_scope->cache); + + return s; +} + DnsServer *manager_get_dns_server(Manager *m) { + Link *l; assert(m); + /* Try to read updates resolv.conf */ + manager_read_resolv_conf(m); + if (!m->current_dns_server) - m->current_dns_server = m->dns_servers; + manager_set_dns_server(m, m->dns_servers); + + if (!m->current_dns_server) { + bool found = false; + Iterator i; + + /* No DNS servers configured, let's see if there are + * any on any links. If not, we use the fallback + * servers */ + + HASHMAP_FOREACH(l, m->links, i) + if (l->dns_servers) { + found = true; + break; + } + + if (!found) + manager_set_dns_server(m, m->fallback_dns_servers); + } return m->current_dns_server; } @@ -903,20 +1261,23 @@ DnsServer *manager_get_dns_server(Manager *m) { void manager_next_dns_server(Manager *m) { assert(m); - if (!m->current_dns_server) { - m->current_dns_server = m->dns_servers; - return; - } - + /* If there's currently no DNS server set, then the next + * manager_get_dns_server() will find one */ if (!m->current_dns_server) return; + /* Change to the next one */ if (m->current_dns_server->servers_next) { - m->current_dns_server = m->current_dns_server->servers_next; + manager_set_dns_server(m, m->current_dns_server->servers_next); return; } - m->current_dns_server = m->dns_servers; + /* If there was no next one, then start from the beginning of + * the list */ + if (m->current_dns_server->type == DNS_SERVER_FALLBACK) + manager_set_dns_server(m, m->fallback_dns_servers); + else + manager_set_dns_server(m, m->dns_servers); } uint32_t manager_find_mtu(Manager *m) { @@ -941,22 +1302,37 @@ uint32_t manager_find_mtu(Manager *m) { static int on_llmnr_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) { _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL; - DnsQueryTransaction *t = NULL; + DnsTransaction *t = NULL; Manager *m = userdata; + DnsScope *scope; int r; r = manager_recv(m, fd, DNS_PROTOCOL_LLMNR, &p); if (r <= 0) return r; - if (dns_packet_validate_reply(p) >= 0) { - t = hashmap_get(m->dns_query_transactions, UINT_TO_PTR(DNS_PACKET_ID(p))); - if (!t) - return 0; - - dns_query_transaction_process_reply(t, p); + scope = manager_find_scope(m, p); + if (!scope) { + log_warning("Got LLMNR UDP packet on unknown scope. Ignoring."); + return 0; } + if (dns_packet_validate_reply(p) > 0) { + log_debug("Got reply packet for id %u", DNS_PACKET_ID(p)); + + dns_scope_check_conflicts(scope, p); + + t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p))); + if (t) + dns_transaction_process_reply(t, p); + + } else if (dns_packet_validate_query(p) > 0) { + log_debug("Got query packet for id %u", DNS_PACKET_ID(p)); + + dns_scope_process_query(scope, NULL, p); + } else + log_debug("Invalid LLMNR UDP packet."); + return 0; } @@ -965,7 +1341,7 @@ int manager_llmnr_ipv4_udp_fd(Manager *m) { .in.sin_family = AF_INET, .in.sin_port = htobe16(5355), }; - static const int one = 1, pmtu = IP_PMTUDISC_DONT; + static const int one = 1, pmtu = IP_PMTUDISC_DONT, ttl = 255; int r; assert(m); @@ -977,13 +1353,14 @@ int manager_llmnr_ipv4_udp_fd(Manager *m) { if (m->llmnr_ipv4_udp_fd < 0) return -errno; - r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_TTL, &one, sizeof(one)); + /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */ + r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl)); if (r < 0) { r = -errno; goto fail; } - r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_TTL, &one, sizeof(one)); + r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)); if (r < 0) { r = -errno; goto fail; @@ -1042,7 +1419,7 @@ int manager_llmnr_ipv6_udp_fd(Manager *m) { .in6.sin6_family = AF_INET6, .in6.sin6_port = htobe16(5355), }; - static const int one = 1; + static const int one = 1, ttl = 255; int r; assert(m); @@ -1054,13 +1431,14 @@ int manager_llmnr_ipv6_udp_fd(Manager *m) { if (m->llmnr_ipv6_udp_fd < 0) return -errno; - r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &one, sizeof(one)); + r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)); if (r < 0) { r = -errno; goto fail; } - r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &one, sizeof(one)); + /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */ + r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)); if (r < 0) { r = -errno; goto fail; @@ -1114,3 +1492,353 @@ fail: m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd); return r; } + +static int on_llmnr_stream_packet(DnsStream *s) { + DnsScope *scope; + + assert(s); + + scope = manager_find_scope(s->manager, s->read_packet); + if (!scope) { + log_warning("Got LLMNR TCP packet on unknown scope. Ignroing."); + return 0; + } + + if (dns_packet_validate_query(s->read_packet) > 0) { + log_debug("Got query packet for id %u", DNS_PACKET_ID(s->read_packet)); + + dns_scope_process_query(scope, s, s->read_packet); + + /* If no reply packet was set, we free the stream */ + if (s->write_packet) + return 0; + } else + log_debug("Invalid LLMNR TCP packet."); + + dns_stream_free(s); + return 0; +} + +static int on_llmnr_stream(sd_event_source *s, int fd, uint32_t revents, void *userdata) { + DnsStream *stream; + Manager *m = userdata; + int cfd, r; + + cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC); + if (cfd < 0) { + if (errno == EAGAIN || errno == EINTR) + return 0; + + return -errno; + } + + r = dns_stream_new(m, &stream, DNS_PROTOCOL_LLMNR, cfd); + if (r < 0) { + safe_close(cfd); + return r; + } + + stream->on_packet = on_llmnr_stream_packet; + return 0; +} + +int manager_llmnr_ipv4_tcp_fd(Manager *m) { + union sockaddr_union sa = { + .in.sin_family = AF_INET, + .in.sin_port = htobe16(5355), + }; + static const int one = 1, pmtu = IP_PMTUDISC_DONT; + int r; + + assert(m); + + if (m->llmnr_ipv4_tcp_fd >= 0) + return m->llmnr_ipv4_tcp_fd; + + m->llmnr_ipv4_tcp_fd = socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); + if (m->llmnr_ipv4_tcp_fd < 0) + return -errno; + + /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */ + r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_TTL, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = setsockopt(m->llmnr_ipv4_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + /* Disable Don't-Fragment bit in the IP header */ + r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = bind(m->llmnr_ipv4_tcp_fd, &sa.sa, sizeof(sa.in)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = listen(m->llmnr_ipv4_tcp_fd, SOMAXCONN); + if (r < 0) { + r = -errno; + goto fail; + } + + r = sd_event_add_io(m->event, &m->llmnr_ipv4_tcp_event_source, m->llmnr_ipv4_tcp_fd, EPOLLIN, on_llmnr_stream, m); + if (r < 0) + goto fail; + + return m->llmnr_ipv4_tcp_fd; + +fail: + m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd); + return r; +} + +int manager_llmnr_ipv6_tcp_fd(Manager *m) { + union sockaddr_union sa = { + .in6.sin6_family = AF_INET6, + .in6.sin6_port = htobe16(5355), + }; + static const int one = 1; + int r; + + assert(m); + + if (m->llmnr_ipv6_tcp_fd >= 0) + return m->llmnr_ipv6_tcp_fd; + + m->llmnr_ipv6_tcp_fd = socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); + if (m->llmnr_ipv6_tcp_fd < 0) + return -errno; + + /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */ + r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = setsockopt(m->llmnr_ipv6_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = bind(m->llmnr_ipv6_tcp_fd, &sa.sa, sizeof(sa.in6)); + if (r < 0) { + r = -errno; + goto fail; + } + + r = listen(m->llmnr_ipv6_tcp_fd, SOMAXCONN); + if (r < 0) { + r = -errno; + goto fail; + } + + r = sd_event_add_io(m->event, &m->llmnr_ipv6_tcp_event_source, m->llmnr_ipv6_tcp_fd, EPOLLIN, on_llmnr_stream, m); + if (r < 0) { + r = -errno; + goto fail; + } + + return m->llmnr_ipv6_tcp_fd; + +fail: + m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd); + return r; +} + +int manager_ifindex_is_loopback(Manager *m, int ifindex) { + Link *l; + assert(m); + + if (ifindex <= 0) + return -EINVAL; + + l = hashmap_get(m->links, INT_TO_PTR(ifindex)); + if (l->flags & IFF_LOOPBACK) + return 1; + + return 0; +} + +int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) { + LinkAddress *a; + + assert(m); + + a = manager_find_link_address(m, family, in_addr); + if (a) + return a->link->ifindex; + + return 0; +} + +void manager_refresh_rrs(Manager *m) { + Iterator i; + Link *l; + + assert(m); + + m->host_ipv4_key = dns_resource_key_unref(m->host_ipv4_key); + m->host_ipv6_key = dns_resource_key_unref(m->host_ipv6_key); + + HASHMAP_FOREACH(l, m->links, i) { + link_add_rrs(l, true); + link_add_rrs(l, false); + } +} + +int manager_next_hostname(Manager *m) { + const char *p; + uint64_t u, a; + char *h; + + assert(m); + + p = strchr(m->hostname, 0); + assert(p); + + while (p > m->hostname) { + if (!strchr("0123456789", p[-1])) + break; + + p--; + } + + if (*p == 0 || safe_atou64(p, &u) < 0 || u <= 0) + u = 1; + + /* Add a random number to the old value. This way we can avoid + * that two hosts pick the same hostname, win on IPv4 and lose + * on IPv6 (or vice versa), and pick the same hostname + * replacement hostname, ad infinitum. We still want the + * numbers to go up monotonically, hence we just add a random + * value 1..10 */ + + random_bytes(&a, sizeof(a)); + u += 1 + a % 10; + + if (asprintf(&h, "%.*s%" PRIu64, (int) (p - m->hostname), m->hostname, u) < 0) + return -ENOMEM; + + log_info("Hostname conflict, changing published hostname from '%s' to '%s'.", m->hostname, h); + + free(m->hostname); + m->hostname = h; + + manager_refresh_rrs(m); + + return 0; +} + +LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) { + Iterator i; + Link *l; + + assert(m); + + HASHMAP_FOREACH(l, m->links, i) { + LinkAddress *a; + + a = link_find_address(l, family, in_addr); + if (a) + return a; + } + + return NULL; +} + +bool manager_our_packet(Manager *m, DnsPacket *p) { + assert(m); + assert(p); + + return !!manager_find_link_address(m, p->family, &p->sender); +} + +DnsScope* manager_find_scope(Manager *m, DnsPacket *p) { + Link *l; + + assert(m); + assert(p); + + l = hashmap_get(m->links, INT_TO_PTR(p->ifindex)); + if (!l) + return NULL; + + if (p->protocol == DNS_PROTOCOL_LLMNR) { + if (p->family == AF_INET) + return l->llmnr_ipv4_scope; + else if (p->family == AF_INET6) + return l->llmnr_ipv6_scope; + } + + return NULL; +} + +void manager_verify_all(Manager *m) { + DnsScope *s; + + assert(m); + + LIST_FOREACH(scopes, s, m->dns_scopes) + dns_zone_verify_all(&s->zone); +} + +void manager_flush_dns_servers(Manager *m, DnsServerType t) { + assert(m); + + if (t == DNS_SERVER_SYSTEM) + while (m->dns_servers) + dns_server_free(m->dns_servers); + + if (t == DNS_SERVER_FALLBACK) + while (m->fallback_dns_servers) + dns_server_free(m->fallback_dns_servers); +} + +static const char* const support_table[_SUPPORT_MAX] = { + [SUPPORT_NO] = "no", + [SUPPORT_YES] = "yes", + [SUPPORT_RESOLVE] = "resolve", +}; +DEFINE_STRING_TABLE_LOOKUP(support, Support);