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=5061d39c4630b6ac9f1994adc492e708182eef53;hp=dc6deeb7e54ee704499366bc650abb869f08d841;hb=edc501d4674dadc304d45a7e1c5b69e207eb8cd4;hpb=74b2466e14a1961bf3ac0e8a60cfaceec705bd59

diff --git a/src/resolve/resolved-manager.c b/src/resolve/resolved-manager.c
index dc6deeb7e..5061d39c4 100644
--- a/src/resolve/resolved-manager.c
+++ b/src/resolve/resolved-manager.c
@@ -21,7 +21,7 @@
 
 #include <arpa/inet.h>
 #include <resolv.h>
-#include <linux/if.h>
+#include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/poll.h>
 #include <netinet/in.h>
@@ -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,15 @@ static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userda
                 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);
                 }
 
@@ -94,9 +102,8 @@ fail:
 static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
         Manager *m = userdata;
         union in_addr_union address;
-        unsigned char family;
         uint16_t type;
-        int r, ifindex;
+        int r, ifindex, family;
         LinkAddress *a;
         Link *l;
 
@@ -177,7 +184,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;
@@ -282,7 +288,7 @@ static int manager_network_monitor_listen(Manager *m) {
 
         assert(m);
 
-        r = sd_network_monitor_new(NULL, &m->network_monitor);
+        r = sd_network_monitor_new(&m->network_monitor, NULL);
         if (r < 0)
                 return r;
 
@@ -301,90 +307,145 @@ 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];
-                unsigned family;
-                union in_addr_union addr;
-
-                memcpy(buffer, word, length);
-                buffer[length] = 0;
+        assert(ret);
 
-                r = in_addr_from_string_auto(buffer, &family, &addr);
-                if (r < 0) {
-                        log_warning("Ignoring invalid DNS address '%s'", buffer);
-                        continue;
-                }
+        h = gethostname_malloc();
+        if (!h)
+                return log_oom();
 
-                /* 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);
+
+        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);
 
-        r = config_parse(NULL,
-                         "/etc/systemd/resolved.conf", NULL,
-                         "Resolve\0",
-                         config_item_perf_lookup, (void*) resolved_gperf_lookup,
-                         false, false, 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_ipv6_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;
+
+        r = manager_llmnr_ipv6_tcp_fd(m);
+        if (r == -EADDRINUSE)
+                goto eaddrinuse;
         if (r < 0)
-                log_warning("Failed to parse configuration file: %s", strerror(-r));
+                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;
 }
 
@@ -399,8 +460,14 @@ int manager_new(Manager **ret) {
                 return -ENOMEM;
 
         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->llmnr_support = SUPPORT_YES;
+        m->read_resolv_conf = true;
 
-        r = parse_dns_server_string(m, /* "172.31.0.125 2001:4860:4860::8888 2001:4860:4860::8889" */ DNS_SERVERS);
+        r = manager_parse_dns_server(m, DNS_SERVER_FALLBACK, DNS_SERVERS);
         if (r < 0)
                 return r;
 
@@ -413,7 +480,11 @@ int manager_new(Manager **ret) {
 
         sd_event_set_watchdog(m->event, true);
 
-        r = dns_scope_new(m, &m->unicast_scope, DNS_SCOPE_DNS);
+        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;
 
@@ -435,6 +506,18 @@ 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;
 
@@ -444,7 +527,7 @@ Manager *manager_free(Manager *m) {
         while (m->dns_queries)
                 dns_query_free(m->dns_queries);
 
-        hashmap_free(m->dns_query_transactions);
+        hashmap_free(m->dns_transactions);
 
         while ((l = hashmap_first(m->links)))
                link_free(l);
@@ -454,25 +537,140 @@ Manager *manager_free(Manager *m) {
 
         while (m->dns_servers)
                 dns_server_free(m->dns_servers);
+        while (m->fallback_dns_servers)
+                dns_server_free(m->fallback_dns_servers);
 
         sd_event_source_unref(m->network_event_source);
         sd_network_monitor_unref(m->network_monitor);
 
         sd_event_source_unref(m->dns_ipv4_event_source);
         sd_event_source_unref(m->dns_ipv6_event_source);
-
         safe_close(m->dns_ipv4_fd);
         safe_close(m->dns_ipv6_fd);
 
+        manager_llmnr_stop(m);
+
         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;
 }
 
+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_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) {
         _cleanup_free_ char *t  = NULL;
         int r;
@@ -483,7 +681,7 @@ static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) {
 
         r = in_addr_to_string(s->family, &s->address, &t);
         if (r < 0) {
-                log_warning("Invalid DNS address. Ignoring.");
+                log_warning("Invalid DNS address. Ignoring: %s", strerror(-r));
                 return;
         }
 
@@ -495,7 +693,7 @@ static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *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;
         unsigned count = 0;
@@ -506,6 +704,9 @@ int manager_write_resolv_conf(Manager *m) {
 
         assert(m);
 
+        /* Read the system /etc/resolv.conf first */
+        manager_read_resolv_conf(m);
+
         r = fopen_temporary(path, &f, &temp_path);
         if (r < 0)
                 return r;
@@ -518,17 +719,18 @@ 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)
+        LIST_FOREACH(servers, s, m->dns_servers)
+                write_resolve_conf_server(s, f, &count);
+
+        HASHMAP_FOREACH(l, m->links, i)
+                LIST_FOREACH(servers, s, l->dns_servers)
                         write_resolve_conf_server(s, f, &count);
 
-                LIST_FOREACH(servers, s, l->dhcp_dns_servers)
+        if (count == 0) {
+                LIST_FOREACH(servers, s, m->fallback_dns_servers)
                         write_resolve_conf_server(s, f, &count);
         }
 
-        LIST_FOREACH(servers, s, m->dns_servers)
-                write_resolve_conf_server(s, f, &count);
-
         r = fflush_and_check(f);
         if (r < 0)
                 goto fail;
@@ -546,39 +748,48 @@ fail:
         return r;
 }
 
-int manager_dns_ipv4_recv(Manager *m, DnsPacket **ret) {
+int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
+        union {
+                struct cmsghdr header; /* For alignment */
+                uint8_t buffer[CMSG_SPACE(MAX(sizeof(struct in_pktinfo), sizeof(struct in6_pktinfo)))
+                               + CMSG_SPACE(int) /* ttl/hoplimit */
+                               + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
+        } control;
+        union sockaddr_union sa;
         struct msghdr mh = {};
-        int fd, ms = 0, r;
+        struct cmsghdr *cmsg;
         struct iovec iov;
+        int ms = 0, r;
         ssize_t l;
 
         assert(m);
+        assert(fd >= 0);
         assert(ret);
 
-        fd = manager_dns_ipv4_fd(m);
-        if (fd < 0)
-                return fd;
-
         r = ioctl(fd, FIONREAD, &ms);
         if (r < 0)
                 return -errno;
         if (ms < 0)
                 return -EIO;
 
-        r = dns_packet_new(&p, ms);
+        r = dns_packet_new(&p, protocol, ms);
         if (r < 0)
                 return r;
 
         iov.iov_base = DNS_PACKET_DATA(p);
         iov.iov_len = p->allocated;
 
+        mh.msg_name = &sa.sa;
+        mh.msg_namelen = sizeof(sa);
         mh.msg_iov = &iov;
         mh.msg_iovlen = 1;
+        mh.msg_control = &control;
+        mh.msg_controllen = sizeof(control);
 
         l = recvmsg(fd, &mh, 0);
         if (l < 0) {
-                if (errno == EAGAIN)
+                if (errno == EAGAIN || errno == EINTR)
                         return 0;
 
                 return -errno;
@@ -587,56 +798,78 @@ int manager_dns_ipv4_recv(Manager *m, DnsPacket **ret) {
         if (l <= 0)
                 return -EIO;
 
+        assert(!(mh.msg_flags & MSG_CTRUNC));
+        assert(!(mh.msg_flags & MSG_TRUNC));
+
         p->size = (size_t) l;
 
-        *ret = p;
-        p = NULL;
+        p->family = sa.sa.sa_family;
+        p->ipproto = IPPROTO_UDP;
+        if (p->family == AF_INET) {
+                p->sender.in = sa.in.sin_addr;
+                p->sender_port = be16toh(sa.in.sin_port);
+        } else if (p->family == AF_INET6) {
+                p->sender.in6 = sa.in6.sin6_addr;
+                p->sender_port = be16toh(sa.in6.sin6_port);
+                p->ifindex = sa.in6.sin6_scope_id;
+        } else
+                return -EAFNOSUPPORT;
 
-        return 1;
-}
+        for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
 
-int manager_dns_ipv6_recv(Manager *m, DnsPacket **ret) {
-        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
-        struct msghdr mh = {};
-        struct iovec iov;
-        int fd, ms = 0, r;
-        ssize_t l;
+                if (cmsg->cmsg_level == IPPROTO_IPV6) {
+                        assert(p->family == AF_INET6);
 
-        assert(m);
-        assert(ret);
+                        switch (cmsg->cmsg_type) {
 
-        fd = manager_dns_ipv6_fd(m);
-        if (fd < 0)
-                return fd;
+                        case IPV6_PKTINFO: {
+                                struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
 
-        r = ioctl(fd, FIONREAD, &ms);
-        if (r < 0)
-                return -errno;
-        if (ms < 0)
-                return -EIO;
+                                if (p->ifindex <= 0)
+                                        p->ifindex = i->ipi6_ifindex;
 
-        r = dns_packet_new(&p, ms);
-        if (r < 0)
-                return r;
+                                p->destination.in6 = i->ipi6_addr;
+                                break;
+                        }
 
-        iov.iov_base = DNS_PACKET_DATA(p);
-        iov.iov_len = p->allocated;
+                        case IPV6_HOPLIMIT:
+                                p->ttl = *(int *) CMSG_DATA(cmsg);
+                                break;
 
-        mh.msg_iov = &iov;
-        mh.msg_iovlen = 1;
+                        }
+                } else if (cmsg->cmsg_level == IPPROTO_IP) {
+                        assert(p->family == AF_INET);
 
-        l = recvmsg(fd, &mh, 0);
-        if (l < 0) {
-                if (errno == EAGAIN)
-                        return 0;
+                        switch (cmsg->cmsg_type) {
 
-                return -errno;
+                        case IP_PKTINFO: {
+                                struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
+
+                                if (p->ifindex <= 0)
+                                        p->ifindex = i->ipi_ifindex;
+
+                                p->destination.in = i->ipi_addr;
+                                break;
+                        }
+
+                        case IP_TTL:
+                                p->ttl = *(int *) CMSG_DATA(cmsg);
+                                break;
+                        }
+                }
         }
 
-        if (l <= 0)
-                return -EIO;
+        /* 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;
 
-        p->size = (size_t) l;
+        /* 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;
@@ -644,41 +877,31 @@ int manager_dns_ipv6_recv(Manager *m, DnsPacket **ret) {
         return 1;
 }
 
-static int on_dns_ipv4_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+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;
 
-        r = manager_dns_ipv4_recv(m, &p);
+        r = manager_recv(m, fd, DNS_PROTOCOL_DNS, &p);
         if (r <= 0)
                 return r;
 
-        t = hashmap_get(m->dns_query_transactions, UINT_TO_PTR(DNS_PACKET_HEADER(p)->id));
-        if (!t)
-                return 0;
-
-        return dns_query_transaction_reply(t, p);
-}
-
-static int on_dns_ipv6_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
-        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
-        DnsQueryTransaction *t = NULL;
-        Manager *m = userdata;
-        int r;
+        if (dns_packet_validate_reply(p) > 0) {
+                t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
+                if (!t)
+                        return 0;
 
-        r = manager_dns_ipv6_recv(m, &p);
-        if (r <= 0)
-                return r;
+                dns_transaction_process_reply(t, p);
 
-        t = hashmap_get(m->dns_query_transactions, UINT_TO_PTR(DNS_PACKET_HEADER(p)->id));
-        if (!t)
-                return 0;
+        } else
+                log_debug("Invalid DNS packet.");
 
-        return dns_query_transaction_reply(t, p);
+        return 0;
 }
 
 int manager_dns_ipv4_fd(Manager *m) {
+        const int one = 1;
         int r;
 
         assert(m);
@@ -690,14 +913,25 @@ int manager_dns_ipv4_fd(Manager *m) {
         if (m->dns_ipv4_fd < 0)
                 return -errno;
 
-        r = sd_event_add_io(m->event, &m->dns_ipv4_event_source, m->dns_ipv4_fd, EPOLLIN, on_dns_ipv4_packet, m);
+        r = setsockopt(m->dns_ipv4_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = sd_event_add_io(m->event, &m->dns_ipv4_event_source, m->dns_ipv4_fd, EPOLLIN, on_dns_packet, m);
         if (r < 0)
-                return r;
+                goto fail;
 
         return m->dns_ipv4_fd;
+
+fail:
+        m->dns_ipv4_fd = safe_close(m->dns_ipv4_fd);
+        return r;
 }
 
 int manager_dns_ipv6_fd(Manager *m) {
+        const int one = 1;
         int r;
 
         assert(m);
@@ -709,11 +943,21 @@ int manager_dns_ipv6_fd(Manager *m) {
         if (m->dns_ipv6_fd < 0)
                 return -errno;
 
-        r = sd_event_add_io(m->event, &m->dns_ipv6_event_source, m->dns_ipv6_fd, EPOLLIN, on_dns_ipv6_packet, m);
+        r = setsockopt(m->dns_ipv6_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = sd_event_add_io(m->event, &m->dns_ipv6_event_source, m->dns_ipv6_fd, EPOLLIN, on_dns_packet, m);
         if (r < 0)
-                return r;
+                goto fail;
 
         return m->dns_ipv6_fd;
+
+fail:
+        m->dns_ipv6_fd = safe_close(m->dns_ipv6_fd);
+        return r;
 }
 
 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
@@ -740,28 +984,28 @@ static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
         }
 }
 
-int manager_dns_ipv4_send(Manager *m, DnsServer *srv, int ifindex, 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,
-                .in.sin_port = htobe16(53),
         };
+        union {
+                struct cmsghdr header; /* For alignment */
+                uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
+        } control;
         struct msghdr mh = {};
         struct iovec iov;
-        uint8_t control[CMSG_SPACE(sizeof(struct in_pktinfo))];
-        int fd;
 
         assert(m);
-        assert(srv);
+        assert(fd >= 0);
+        assert(addr);
+        assert(port > 0);
         assert(p);
 
-        fd = manager_dns_ipv4_fd(m);
-        if (fd < 0)
-                return fd;
-
         iov.iov_base = DNS_PACKET_DATA(p);
         iov.iov_len = p->size;
 
-        sa.in.sin_addr = srv->address.in;
+        sa.in.sin_addr = *addr;
+        sa.in.sin_port = htobe16(port),
 
         mh.msg_iov = &iov;
         mh.msg_iovlen = 1;
@@ -774,7 +1018,7 @@ int manager_dns_ipv4_send(Manager *m, DnsServer *srv, int ifindex, DnsPacket *p)
 
                 zero(control);
 
-                mh.msg_control = control;
+                mh.msg_control = &control;
                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
 
                 cmsg = CMSG_FIRSTHDR(&mh);
@@ -789,29 +1033,28 @@ int manager_dns_ipv4_send(Manager *m, DnsServer *srv, int ifindex, DnsPacket *p)
         return sendmsg_loop(fd, &mh, 0);
 }
 
-int manager_dns_ipv6_send(Manager *m, DnsServer *srv, int ifindex, 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,
-                .in6.sin6_port = htobe16(53),
         };
-
+        union {
+                struct cmsghdr header; /* For alignment */
+                uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
+        } control;
         struct msghdr mh = {};
         struct iovec iov;
-        uint8_t control[CMSG_SPACE(sizeof(struct in6_pktinfo))];
-        int fd;
 
         assert(m);
-        assert(srv);
+        assert(fd >= 0);
+        assert(addr);
+        assert(port > 0);
         assert(p);
 
-        fd = manager_dns_ipv6_fd(m);
-        if (fd < 0)
-                return fd;
-
         iov.iov_base = DNS_PACKET_DATA(p);
         iov.iov_len = p->size;
 
-        sa.in6.sin6_addr = srv->address.in6;
+        sa.in6.sin6_addr = *addr;
+        sa.in6.sin6_port = htobe16(port),
         sa.in6.sin6_scope_id = ifindex;
 
         mh.msg_iov = &iov;
@@ -825,7 +1068,7 @@ int manager_dns_ipv6_send(Manager *m, DnsServer *srv, int ifindex, DnsPacket *p)
 
                 zero(control);
 
-                mh.msg_control = control;
+                mh.msg_control = &control;
                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
 
                 cmsg = CMSG_FIRSTHDR(&mh);
@@ -840,27 +1083,88 @@ int manager_dns_ipv6_send(Manager *m, DnsServer *srv, int ifindex, DnsPacket *p)
         return sendmsg_loop(fd, &mh, 0);
 }
 
-DnsServer* manager_find_dns_server(Manager *m, unsigned char family, union in_addr_union *in_addr) {
+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)
+                return manager_ipv6_send(m, fd, ifindex, &addr->in6, port, p);
+
+        return -EAFNOSUPPORT;
+}
+
+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;
 }
@@ -868,18 +1172,542 @@ 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) {
+        uint32_t mtu = 0;
+        Link *l;
+        Iterator i;
+
+        /* If we don't know on which link a DNS packet would be
+         * delivered, let's find the largest MTU that works on all
+         * interfaces we know of */
+
+        HASHMAP_FOREACH(l, m->links, i) {
+                if (l->mtu <= 0)
+                        continue;
+
+                if (mtu <= 0 || l->mtu < mtu)
+                        mtu = l->mtu;
+        }
+
+        return mtu;
+}
+
+static int on_llmnr_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
+        DnsTransaction *t = NULL;
+        Manager *m = userdata;
+        int r;
+
+        r = manager_recv(m, fd, DNS_PROTOCOL_LLMNR, &p);
+        if (r <= 0)
+                return r;
+
+        if (dns_packet_validate_reply(p) > 0) {
+                log_debug("Got reply packet for id %u", DNS_PACKET_ID(p));
+
+                t = hashmap_get(m->dns_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
+                if (!t)
+                        return 0;
+
+                dns_transaction_process_reply(t, p);
+
+        } else if (dns_packet_validate_query(p) > 0) {
+                Link *l;
+
+                l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
+                if (l) {
+                        DnsScope *scope = NULL;
+
+                        if (p->family == AF_INET)
+                                scope = l->llmnr_ipv4_scope;
+                        else if (p->family == AF_INET6)
+                                scope = l->llmnr_ipv6_scope;
+
+                        if (scope)
+                                dns_scope_process_query(scope, NULL, p);
+                }
+        } else
+                log_debug("Invalid LLMNR packet.");
+
+        return 0;
+}
+
+int manager_llmnr_ipv4_udp_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, ttl = 255;
+        int r;
+
+        assert(m);
+
+        if (m->llmnr_ipv4_udp_fd >= 0)
+                return m->llmnr_ipv4_udp_fd;
+
+        m->llmnr_ipv4_udp_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
+        if (m->llmnr_ipv4_udp_fd < 0)
+                return -errno;
+
+        /* 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, &ttl, sizeof(ttl));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = setsockopt(m->llmnr_ipv4_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = setsockopt(m->llmnr_ipv4_udp_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_udp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = bind(m->llmnr_ipv4_udp_fd, &sa.sa, sizeof(sa.in));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = sd_event_add_io(m->event, &m->llmnr_ipv4_udp_event_source, m->llmnr_ipv4_udp_fd, EPOLLIN, on_llmnr_packet, m);
+        if (r < 0)
+                goto fail;
+
+        return m->llmnr_ipv4_udp_fd;
+
+fail:
+        m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd);
+        return r;
+}
+
+int manager_llmnr_ipv6_udp_fd(Manager *m) {
+        union sockaddr_union sa = {
+                .in6.sin6_family = AF_INET6,
+                .in6.sin6_port = htobe16(5355),
+        };
+        static const int one = 1, ttl = 255;
+        int r;
+
+        assert(m);
+
+        if (m->llmnr_ipv6_udp_fd >= 0)
+                return m->llmnr_ipv6_udp_fd;
+
+        m->llmnr_ipv6_udp_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
+        if (m->llmnr_ipv6_udp_fd < 0)
+                return -errno;
+
+        r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        /* 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;
+        }
+
+        r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = setsockopt(m->llmnr_ipv6_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = bind(m->llmnr_ipv6_udp_fd, &sa.sa, sizeof(sa.in6));
+        if (r < 0) {
+                r = -errno;
+                goto fail;
+        }
+
+        r = sd_event_add_io(m->event, &m->llmnr_ipv6_udp_event_source, m->llmnr_ipv6_udp_fd, EPOLLIN, on_llmnr_packet, m);
+        if (r < 0)  {
+                r = -errno;
+                goto fail;
+        }
+
+        return m->llmnr_ipv6_udp_fd;
+
+fail:
+        m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd);
+        return r;
+}
+
+static int on_llmnr_stream_packet(DnsStream *s) {
+        assert(s);
+
+        if (dns_packet_validate_query(s->read_packet) > 0) {
+                Link *l;
+
+                l = hashmap_get(s->manager->links, INT_TO_PTR(s->read_packet->ifindex));
+                if (l) {
+                        DnsScope *scope = NULL;
+
+                        if (s->read_packet->family == AF_INET)
+                                scope = l->llmnr_ipv4_scope;
+                        else if (s->read_packet->family == AF_INET6)
+                                scope = l->llmnr_ipv6_scope;
+
+                        if (scope) {
+                                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;
+                        }
+                }
+        }
+
+        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;
+        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;
+
+        u++;
+
+        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;
+}
+
+int manager_our_packet(Manager *m, DnsPacket *p) {
+        assert(m);
+        assert(p);
+
+        return !!manager_find_link_address(m, p->family, &p->sender);
+}
+
+static const char* const support_table[_SUPPORT_MAX] = {
+        [SUPPORT_NO] = "no",
+        [SUPPORT_YES] = "yes",
+        [SUPPORT_RESOLVE] = "resolve",
+};
+DEFINE_STRING_TABLE_LOOKUP(support, Support);