HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/resolved-manager.c

82,564 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 529912ff5267cc02c1e62a798e59c89544d7d165

Lines 1–1000 of 2,387

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <fcntl.h>
#include <linux/ipv6.h>
#include <netinet/in.h>
#include <poll.h>
#include <unistd.h>
 
#include "sd-bus.h"
#include "sd-netlink.h"
#include "sd-network.h"
 
#include "af-list.h"
#include "alloc-util.h"
#include "daemon-util.h"
#include "dirent-util.h"
#include "dns-answer.h"
#include "dns-domain.h"
#include "dns-packet.h"
#include "dns-question.h"
#include "dns-rr.h"
#include "errno-util.h"
#include "event-util.h"
#include "fd-util.h"
#include "hostname-setup.h"
#include "hostname-util.h"
#include "io-util.h"
#include "iovec-util.h"
#include "json-util.h"
#include "memstream-util.h"
#include "missing-network.h"
#include "ordered-set.h"
#include "parse-util.h"
#include "random-util.h"
#include "resolved-bus.h"
#include "resolved-conf.h"
#include "resolved-dns-delegate.h"
#include "resolved-dns-query.h"
#include "resolved-dns-scope.h"
#include "resolved-dns-search-domain.h"
#include "resolved-dns-server.h"
#include "resolved-dns-stub.h"
#include "resolved-dns-transaction.h"
#include "resolved-dnssd.h"
#include "resolved-etc-hosts.h"
#include "resolved-link.h"
#include "resolved-llmnr.h"
#include "resolved-manager.h"
#include "resolved-mdns.h"
#include "resolved-resolv-conf.h"
#include "resolved-socket-graveyard.h"
#include "resolved-static-records.h"
#include "resolved-util.h"
#include "resolved-varlink.h"
#include "set.h"
#include "socket-util.h"
#include "string-util.h"
#include "time-util.h"
#include "varlink-util.h"
 
#define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
 
static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
        uint16_t type;
        Link *l;
        int ifindex, r;
 
        assert(rtnl);
        assert(mm);
 
        r = sd_netlink_message_get_type(mm, &type);
        if (r < 0)
                goto fail;
 
        r = sd_rtnl_message_link_get_ifindex(mm, &ifindex);
        if (r < 0)
                goto fail;
 
        l = hashmap_get(m->links, INT_TO_PTR(ifindex));
 
        switch (type) {
 
        case RTM_NEWLINK:{
                bool is_new = !l;
 
                if (!l) {
                        r = link_new(m, &l, ifindex);
                        if (r < 0)
                                goto fail;
                }
 
                r = link_process_rtnl(l, mm);
                if (r < 0)
                        goto fail;
 
                r = link_update(l);
                if (r < 0)
                        goto fail;
 
                if (is_new)
                        log_debug("Found new link %i/%s", ifindex, l->ifname);
 
                break;
        }
 
        case RTM_DELLINK:
                if (l) {
                        log_debug("Removing link %i/%s", l->ifindex, l->ifname);
                        link_remove_user(l);
                        link_free(l);
 
                        /* Make sure DNS servers are dropped from written resolv.conf if their link goes away */
                        manager_write_resolv_conf(m);
                }
 
                break;
        }
 
        /* Now check all the links, and if mDNS/llmr are disabled everywhere, stop them globally too. */
        manager_llmnr_maybe_stop(m);
        manager_mdns_maybe_stop(m);
 
        /* The accessible flag on link DNS servers will have been reset by
         * link_update(). Just reset the global DNS servers. */
        (void) manager_send_dns_configuration_changed(m, NULL, /* reset= */ true);
 
        return 0;
 
fail:
        log_warning_errno(r, "Failed to process RTNL link message: %m");
        return 0;
}
 
static int manager_process_address(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
        union in_addr_union address, broadcast = {};
        uint16_t type;
        int r, ifindex, family;
        LinkAddress *a;
        Link *l;
 
        assert(rtnl);
        assert(mm);
 
        r = sd_netlink_message_get_type(mm, &type);
        if (r < 0)
                goto fail;
 
        r = sd_rtnl_message_addr_get_ifindex(mm, &ifindex);
        if (r < 0)
                goto fail;
 
        l = hashmap_get(m->links, INT_TO_PTR(ifindex));
        if (!l)
                return 0;
 
        r = sd_rtnl_message_addr_get_family(mm, &family);
        if (r < 0)
                goto fail;
 
        switch (family) {
 
        case AF_INET:
                sd_netlink_message_read_in_addr(mm, IFA_BROADCAST, &broadcast.in);
                r = sd_netlink_message_read_in_addr(mm, IFA_LOCAL, &address.in);
                if (r < 0) {
                        r = sd_netlink_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
                        if (r < 0)
                                goto fail;
                }
 
                break;
 
        case AF_INET6:
                r = sd_netlink_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
                if (r < 0) {
                        r = sd_netlink_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
                        if (r < 0)
                                goto fail;
                }
 
                break;
 
        default:
                return 0;
        }
 
        a = link_find_address(l, family, &address);
 
        switch (type) {
 
        case RTM_NEWADDR:
 
                if (!a) {
                        r = link_address_new(l, &a, family, &address, &broadcast);
                        if (r < 0)
                                return r;
                }
 
                r = link_address_update_rtnl(a, mm);
                if (r < 0)
                        return r;
 
                break;
 
        case RTM_DELADDR:
                link_address_free(a);
                break;
        }
 
        (void) manager_send_dns_configuration_changed(m, l, /* reset= */ true);
 
        return 0;
 
fail:
        log_warning_errno(r, "Failed to process RTNL address message: %m");
        return 0;
}
 
static int manager_process_route(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
        Link *l = NULL;
        uint16_t type;
        uint32_t ifindex = 0;
        int r;
 
        assert(rtnl);
        assert(mm);
 
        r = sd_netlink_message_get_type(mm, &type);
        if (r < 0) {
                log_warning_errno(r, "Failed to get rtnl message type, ignoring: %m");
                return 0;
        }
 
        if (!IN_SET(type, RTM_NEWROUTE, RTM_DELROUTE)) {
                log_warning("Unexpected message type %u when processing route, ignoring.", type);
                return 0;
        }
 
        r = sd_netlink_message_read_u32(mm, RTA_OIF, &ifindex);
        if (r < 0)
                log_full_errno(r == -ENODATA ? LOG_DEBUG : LOG_WARNING, r, "Failed to get route ifindex, ignoring: %m");
        else
                l = hashmap_get(m->links, INT_TO_PTR(ifindex));
 
        (void) manager_send_dns_configuration_changed(m, l, /* reset= */ true);
 
        return 0;
}
 
static int manager_rtnl_listen(Manager *m) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
        int r;
 
        assert(m);
 
        /* First, subscribe to interfaces coming and going */
        r = sd_netlink_open(&m->rtnl);
        if (r < 0)
                return r;
 
        r = sd_netlink_attach_event(m->rtnl, m->event, SD_EVENT_PRIORITY_IMPORTANT);
        if (r < 0)
                return r;
 
        r = sd_netlink_add_match(m->rtnl, NULL, RTM_NEWLINK, manager_process_link, NULL, m, "resolve-NEWLINK");
        if (r < 0)
                return r;
 
        r = sd_netlink_add_match(m->rtnl, NULL, RTM_DELLINK, manager_process_link, NULL, m, "resolve-DELLINK");
        if (r < 0)
                return r;
 
        r = sd_netlink_add_match(m->rtnl, NULL, RTM_NEWADDR, manager_process_address, NULL, m, "resolve-NEWADDR");
        if (r < 0)
                return r;
 
        r = sd_netlink_add_match(m->rtnl, NULL, RTM_DELADDR, manager_process_address, NULL, m, "resolve-DELADDR");
        if (r < 0)
                return r;
 
        /* Then, enumerate all links */
        r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
        if (r < 0)
                return r;
 
        r = sd_netlink_message_set_request_dump(req, true);
        if (r < 0)
                return r;
 
        r = sd_netlink_call(m->rtnl, req, 0, &reply);
        if (r < 0)
                return r;
 
        for (sd_netlink_message *i = reply; i; i = sd_netlink_message_next(i)) {
                r = manager_process_link(m->rtnl, i, m);
                if (r < 0)
                        return r;
        }
 
        req = sd_netlink_message_unref(req);
        reply = sd_netlink_message_unref(reply);
 
        /* Finally, enumerate all addresses, too */
        r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC);
        if (r < 0)
                return r;
 
        r = sd_netlink_message_set_request_dump(req, true);
        if (r < 0)
                return r;
 
        r = sd_netlink_call(m->rtnl, req, 0, &reply);
        if (r < 0)
                return r;
 
        for (sd_netlink_message *i = reply; i; i = sd_netlink_message_next(i)) {
                r = manager_process_address(m->rtnl, i, m);
                if (r < 0)
                        return r;
        }
 
        return r;
}
 
static int on_network_event(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
        Link *l;
        int r;
 
        sd_network_monitor_flush(m->network_monitor);
 
        HASHMAP_FOREACH(l, m->links) {
                r = link_update(l);
                if (r < 0)
                        log_warning_errno(r, "Failed to update monitor information for %i: %m", l->ifindex);
        }
 
        (void) manager_write_resolv_conf(m);
        (void) manager_send_changed(m, "DNS");
        (void) manager_send_dns_configuration_changed(m, NULL, /* reset= */ true);
 
        /* Now check all the links, and if mDNS/llmr are disabled everywhere, stop them globally too. */
        manager_llmnr_maybe_stop(m);
        manager_mdns_maybe_stop(m);
        return 0;
}
 
static int manager_network_monitor_listen(Manager *m) {
        int r, fd, events;
 
        assert(m);
 
        r = sd_network_monitor_new(&m->network_monitor, NULL);
        if (r < 0)
                return r;
 
        fd = sd_network_monitor_get_fd(m->network_monitor);
        if (fd < 0)
                return fd;
 
        events = sd_network_monitor_get_events(m->network_monitor);
        if (events < 0)
                return events;
 
        r = sd_event_add_io(m->event, &m->network_event_source, fd, events, &on_network_event, m);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_priority(m->network_event_source, SD_EVENT_PRIORITY_IMPORTANT-5);
        if (r < 0)
                return r;
 
        (void) sd_event_source_set_description(m->network_event_source, "network-monitor");
 
        return 0;
}
 
static int manager_clock_change_listen(Manager *m);
 
static int on_clock_change(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
 
        /* The clock has changed, let's flush all caches. Why that? That's because DNSSEC validation takes
         * the system clock into consideration, and if the clock changes the old validations might have been
         * wrong. Let's redo all validation with the new, correct time.
         *
         * (Also, this is triggered after system suspend, which is also a good reason to drop caches, since
         * we might be connected to a different network now without this being visible in a dropped link
         * carrier or so.) */
 
        log_info("Clock change detected. Flushing caches.");
        manager_flush_caches(m, LOG_DEBUG /* downgrade the functions own log message, since we already logged here at LOG_INFO level */);
 
        /* The clock change timerfd is unusable after it triggered once, create a new one. */
        return manager_clock_change_listen(m);
}
 
static int manager_clock_change_listen(Manager *m) {
        int r;
 
        assert(m);
 
        m->clock_change_event_source = sd_event_source_disable_unref(m->clock_change_event_source);
 
        r = event_add_time_change(m->event, &m->clock_change_event_source, on_clock_change, m);
        if (r < 0)
                return log_error_errno(r, "Failed to create clock change event source: %m");
 
        return 0;
}
 
static int determine_hostnames(char **full_hostname, char **llmnr_hostname, char **mdns_hostname) {
        _cleanup_free_ char *h = NULL, *n = NULL;
        int r;
 
        assert(full_hostname);
        assert(llmnr_hostname);
        assert(mdns_hostname);
 
        r = resolve_system_hostname(&h, &n);
        if (r < 0)
                return r;
 
        r = dns_name_concat(n, "local", 0, mdns_hostname);
        if (r < 0)
                return log_error_errno(r, "Failed to determine mDNS hostname: %m");
 
        *llmnr_hostname = TAKE_PTR(n);
        *full_hostname = TAKE_PTR(h);
 
        return 0;
}
 
static char* fallback_hostname(void) {
 
        /* Determine the fall back hostname. For exposing this system to the outside world, we cannot have it
         * to be "localhost" even if that's the default hostname. In this case, let's revert to "linux"
         * instead. */
 
        _cleanup_free_ char *n = get_default_hostname_or_fallback();
        if (!n)
                return NULL;
 
        if (is_localhost(n))
                return strdup("linux");
 
        return TAKE_PTR(n);
}
 
static int make_fallback_hostnames(char **full_hostname, char **llmnr_hostname, char **mdns_hostname) {
        _cleanup_free_ char *h = NULL, *n = NULL, *m = NULL;
        char label[DNS_LABEL_MAX+1];
        const char *p;
        int r;
 
        assert(full_hostname);
        assert(llmnr_hostname);
        assert(mdns_hostname);
 
        p = h = fallback_hostname();
        if (!h)
                return log_oom();
 
        r = dns_label_unescape(&p, label, sizeof label, 0);
        if (r < 0)
                return log_error_errno(r, "Failed to unescape fallback hostname: %m");
 
        assert(r > 0); /* The fallback hostname must have at least one label */
 
        r = dns_label_escape_new(label, r, &n);
        if (r < 0)
                return log_error_errno(r, "Failed to escape fallback hostname: %m");
 
        r = dns_name_concat(n, "local", 0, &m);
        if (r < 0)
                return log_error_errno(r, "Failed to concatenate mDNS hostname: %m");
 
        *llmnr_hostname = TAKE_PTR(n);
        *mdns_hostname = TAKE_PTR(m);
        *full_hostname = TAKE_PTR(h);
 
        return 0;
}
 
static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
        _cleanup_free_ char *full_hostname = NULL, *llmnr_hostname = NULL, *mdns_hostname = NULL;
        Manager *m = ASSERT_PTR(userdata);
        bool llmnr_hostname_changed;
        int r;
 
        r = determine_hostnames(&full_hostname, &llmnr_hostname, &mdns_hostname);
        if (r < 0) {
                log_warning_errno(r, "Failed to determine the local hostname and LLMNR/mDNS names, ignoring: %m");
                return 0; /* ignore invalid hostnames */
        }
 
        llmnr_hostname_changed = !streq(llmnr_hostname, m->llmnr_hostname);
        if (streq(full_hostname, m->full_hostname) &&
            !llmnr_hostname_changed &&
            streq(mdns_hostname, m->mdns_hostname))
                return 0;
 
        log_info("System hostname changed to '%s'.", full_hostname);
 
        free_and_replace(m->full_hostname, full_hostname);
        free_and_replace(m->llmnr_hostname, llmnr_hostname);
        free_and_replace(m->mdns_hostname, mdns_hostname);
 
        manager_refresh_rrs(m);
        (void) manager_send_changed(m, "LLMNRHostname");
 
        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_NONBLOCK|O_NOCTTY);
        if (m->hostname_fd < 0) {
                log_warning_errno(errno, "Failed to watch hostname: %m");
                return 0;
        }
 
        r = sd_event_add_io(m->event, &m->hostname_event_source, m->hostname_fd, 0, on_hostname_change, m);
        if (r < 0)
                return log_error_errno(r, "Failed to add hostname event source: %m");
 
        (void) sd_event_source_set_description(m->hostname_event_source, "hostname");
 
        r = determine_hostnames(&m->full_hostname, &m->llmnr_hostname, &m->mdns_hostname);
        if (r < 0) {
                _cleanup_free_ char *d = NULL;
 
                d = fallback_hostname();
                if (!d)
                        return log_oom();
 
                log_info("Defaulting to hostname '%s'.", d);
 
                r = make_fallback_hostnames(&m->full_hostname, &m->llmnr_hostname, &m->mdns_hostname);
                if (r < 0)
                        return r;
        } else
                log_info("Using system hostname '%s'.", m->full_hostname);
 
        return 0;
}
 
static int manager_sigusr1(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
        _cleanup_(memstream_done) MemStream ms = {};
        Manager *m = ASSERT_PTR(userdata);
        Link *l;
        FILE *f;
 
        assert(s);
        assert(si);
 
        f = memstream_init(&ms);
        if (!f)
                return log_oom();
 
        LIST_FOREACH(scopes, scope, m->dns_scopes)
                dns_scope_dump(scope, f);
 
        LIST_FOREACH(servers, server, m->dns_servers)
                dns_server_dump(server, f);
        LIST_FOREACH(servers, server, m->fallback_dns_servers)
                dns_server_dump(server, f);
        HASHMAP_FOREACH(l, m->links)
                LIST_FOREACH(servers, server, l->dns_servers)
                        dns_server_dump(server, f);
        DnsDelegate *delegate;
        HASHMAP_FOREACH(delegate, m->delegates)
                LIST_FOREACH(servers, server, delegate->dns_servers)
                        dns_server_dump(server, f);
 
        return memstream_dump(LOG_INFO, &ms);
}
 
static int manager_sigusr2(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
 
        assert(s);
        assert(si);
 
        manager_flush_caches(m, LOG_INFO);
 
        return 0;
}
 
static int manager_sigrtmin1(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
 
        assert(s);
        assert(si);
 
        manager_reset_server_features(m);
        return 0;
}
 
static int manager_memory_pressure(sd_event_source *s, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
 
        log_info("Under memory pressure, flushing caches.");
 
        manager_flush_caches(m, LOG_INFO);
        sd_event_trim_memory();
 
        return 0;
}
 
static int manager_memory_pressure_listen(Manager *m) {
        int r;
 
        assert(m);
 
        r = sd_event_add_memory_pressure(m->event, NULL, manager_memory_pressure, m);
        if (r < 0)
                log_full_errno(ERRNO_IS_NOT_SUPPORTED(r) || ERRNO_IS_PRIVILEGE(r) || (r == -EHOSTDOWN )? LOG_DEBUG : LOG_NOTICE, r,
                               "Failed to install memory pressure event source, ignoring: %m");
 
        return 0;
}
 
static void manager_set_defaults(Manager *m) {
        assert(m);
 
        m->llmnr_support = DEFAULT_LLMNR_MODE;
        m->mdns_support = DEFAULT_MDNS_MODE;
        m->dnssec_mode = DEFAULT_DNSSEC_MODE;
        m->dns_over_tls_mode = DEFAULT_DNS_OVER_TLS_MODE;
        m->enable_cache = DNS_CACHE_MODE_YES;
        m->dns_stub_listener_mode = DNS_STUB_LISTENER_YES;
        m->read_etc_hosts = true;
        m->read_static_records = true;
        m->resolve_unicast_single_label = false;
        m->cache_from_localhost = false;
        for (DnsProtocol p = 0; p < _DNS_PROTOCOL_MAX; p++)
                m->cache_max[p] = DEFAULT_CACHE_MAX;
        m->stale_retention_usec = 0;
        m->refuse_record_types = set_free(m->refuse_record_types);
        m->resolv_conf_stat = (struct stat) {};
}
 
static int manager_dispatch_reload_signal(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
        Link *l;
        int r;
 
        (void) notify_reloading();
 
        dns_server_unlink_on_reload(m->dns_servers);
        dns_server_unlink_on_reload(m->fallback_dns_servers);
        m->dns_extra_stub_listeners = ordered_set_free(m->dns_extra_stub_listeners);
        manager_dns_stub_stop(m);
        dnssd_registered_service_clear_on_reload(m->dnssd_registered_services);
        m->unicast_scope = dns_scope_free(m->unicast_scope);
        m->delegates = hashmap_free(m->delegates);
        dns_trust_anchor_flush(&m->trust_anchor);
        manager_etc_hosts_flush(m);
        manager_static_records_flush(m);
 
        m->etc_hosts_last = USEC_INFINITY;
        m->static_records_last = USEC_INFINITY;
 
        manager_set_defaults(m);
 
        r = dns_trust_anchor_load(&m->trust_anchor);
        if (r < 0)
                return sd_event_exit(sd_event_source_get_event(s), r);
 
        r = manager_parse_config_file(m);
        if (r < 0)
                log_warning_errno(r, "Failed to parse configuration file on reload, ignoring: %m");
        else
                log_info("Config file reloaded.");
 
        (void) dnssd_load(m);
        (void) manager_load_delegates(m);
 
        /* The default scope configuration is influenced by the manager's configuration (modes, etc.), so
         * recreate it on reload. */
        r = dns_scope_new(m, &m->unicast_scope, DNS_SCOPE_GLOBAL, /* link= */ NULL, /* delegate= */ NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
        if (r < 0)
                return sd_event_exit(sd_event_source_get_event(s), r);
 
        /* A link's unicast scope may also be influenced by the manager's configuration. I.e., DNSSEC= and DNSOverTLS=
         * from the manager will be used if not explicitly configured on the link. Free the scopes here so that
         * link_allocate_scopes() in on_network_event() re-creates them. */
        HASHMAP_FOREACH(l, m->links)
                l->unicast_scope = dns_scope_free(l->unicast_scope);
 
        /* The configuration has changed, so reload the per-interface configuration too in order to take
         * into account any changes (e.g.: enable/disable DNSSEC). */
        r = on_network_event(/* source= */ NULL, -EBADF, /* revents= */ 0, m);
        if (r < 0)
                log_warning_errno(r, "Failed to update network information on reload, ignoring: %m");
 
        /* We have new configuration, which means potentially new servers, so close all connections and drop
         * all caches, so that we can start fresh. */
        (void) dns_stream_disconnect_all(m);
        manager_flush_caches(m, LOG_INFO);
        manager_verify_all(m);
 
        r = manager_dns_stub_start(m);
        if (r < 0)
                return sd_event_exit(sd_event_source_get_event(s), r);
 
        (void) sd_notify(/* unset_environment= */ false, NOTIFY_READY_MESSAGE);
        return 0;
}
 
int manager_new(Manager **ret) {
        _cleanup_(manager_freep) Manager *m = NULL;
        int r;
 
        assert(ret);
 
        m = new(Manager, 1);
        if (!m)
                return -ENOMEM;
 
        *m = (Manager) {
                .llmnr_ipv4_udp_fd = -EBADF,
                .llmnr_ipv6_udp_fd = -EBADF,
                .llmnr_ipv4_tcp_fd = -EBADF,
                .llmnr_ipv6_tcp_fd = -EBADF,
                .mdns_ipv4_fd = -EBADF,
                .mdns_ipv6_fd = -EBADF,
                .hostname_fd = -EBADF,
 
                .read_resolv_conf = true,
                .need_builtin_fallbacks = true,
                .etc_hosts_last = USEC_INFINITY,
                .static_records_last = USEC_INFINITY,
 
                .sigrtmin18_info.memory_pressure_handler = manager_memory_pressure,
                .sigrtmin18_info.memory_pressure_userdata = m,
        };
 
        manager_set_defaults(m);
 
        r = dns_trust_anchor_load(&m->trust_anchor);
        if (r < 0)
                return r;
 
        r = manager_parse_config_file(m);
        if (r < 0)
                log_warning_errno(r, "Failed to parse configuration file, ignoring: %m");
 
        r = sd_event_default(&m->event);
        if (r < 0)
                return r;
 
        r = sd_event_set_signal_exit(m->event, true);
        if (r < 0)
                return r;
 
        (void) sd_event_set_watchdog(m->event, true);
 
        r = manager_watch_hostname(m);
        if (r < 0)
                return r;
 
        (void) dnssd_load(m);
        (void) manager_load_delegates(m);
 
        r = dns_scope_new(m, &m->unicast_scope, DNS_SCOPE_GLOBAL, /* link= */ NULL, /* delegate= */ NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
        if (r < 0)
                return r;
 
        r = manager_network_monitor_listen(m);
        if (r < 0)
                return r;
 
        r = manager_rtnl_listen(m);
        if (r < 0)
                return r;
 
        r = manager_clock_change_listen(m);
        if (r < 0)
                return r;
 
        r = manager_memory_pressure_listen(m);
        if (r < 0)
                return r;
 
        r = manager_connect_bus(m);
        if (r < 0)
                return r;
 
        r = sd_event_add_signal(m->event, /* ret= */ NULL, SIGHUP | SD_EVENT_SIGNAL_PROCMASK, manager_dispatch_reload_signal, m);
        if (r < 0)
                return log_debug_errno(r, "Failed to install SIGHUP handler: %m");
 
        r = sd_event_add_signal(m->event, /* ret= */ NULL, SIGUSR1 | SD_EVENT_SIGNAL_PROCMASK, manager_sigusr1, m);
        if (r < 0)
                return log_debug_errno(r, "Failed to install SIGUSR1 handler: %m");
 
        r = sd_event_add_signal(m->event, /* ret= */ NULL, SIGUSR2 | SD_EVENT_SIGNAL_PROCMASK, manager_sigusr2, m);
        if (r < 0)
                return log_debug_errno(r, "Failed to install SIGUSR2 handler: %m");
 
        r = sd_event_add_signal(m->event, /* ret= */ NULL, (SIGRTMIN+1) | SD_EVENT_SIGNAL_PROCMASK, manager_sigrtmin1, m);
        if (r < 0)
                return log_debug_errno(r, "Failed to install SIGRTMIN+1 handler: %m");
 
        r = sd_event_add_signal(m->event, /* ret= */ NULL, (SIGRTMIN+18) | SD_EVENT_SIGNAL_PROCMASK, sigrtmin18_handler, &m->sigrtmin18_info);
        if (r < 0)
                return log_debug_errno(r, "Failed to install SIGRTMIN+18 handler: %m");
 
        manager_cleanup_saved_user(m);
 
        *ret = TAKE_PTR(m);
 
        return 0;
}
 
int manager_start(Manager *m) {
        int r;
 
        assert(m);
 
        r = manager_dns_stub_start(m);
        if (r < 0)
                return r;
 
        r = manager_varlink_init(m);
        if (r < 0)
                return r;
 
        return 0;
}
 
Manager* manager_free(Manager *m) {
        Link *l;
        DnssdRegisteredService *s;
 
        if (!m)
                return NULL;
 
        dns_server_unlink_all(m->dns_servers);
        dns_server_unlink_all(m->fallback_dns_servers);
        dns_search_domain_unlink_all(m->search_domains);
 
        while ((l = hashmap_first(m->links)))
               link_free(l);
 
        m->delegates = hashmap_free(m->delegates);
 
        while (m->dns_queries)
                dns_query_free(m->dns_queries);
 
        m->stub_queries_by_packet = hashmap_free(m->stub_queries_by_packet);
        m->unicast_scope = dns_scope_free(m->unicast_scope);
 
        /* At this point only orphaned streams should remain. All others should have been freed already by their
         * owners */
        while (m->dns_streams)
                dns_stream_unref(m->dns_streams);
 
#if ENABLE_DNS_OVER_TLS
        dnstls_manager_free(m);
#endif
 
        set_free(m->refuse_record_types);
        hashmap_free(m->links);
        hashmap_free(m->dns_transactions);
 
        sd_event_source_unref(m->network_event_source);
        sd_network_monitor_unref(m->network_monitor);
 
        sd_netlink_slot_unref(m->netlink_new_route_slot);
        sd_netlink_slot_unref(m->netlink_del_route_slot);
        sd_netlink_unref(m->rtnl);
        sd_event_source_unref(m->rtnl_event_source);
        sd_event_source_unref(m->clock_change_event_source);
 
        sd_json_variant_unref(m->dns_configuration_json);
 
        manager_llmnr_stop(m);
        manager_mdns_stop(m);
        manager_dns_stub_stop(m);
        manager_varlink_done(m);
 
        set_free(m->varlink_query_results_subscription);
        set_free(m->varlink_dns_configuration_subscription);
 
        manager_socket_graveyard_clear(m);
 
        ordered_set_free(m->dns_extra_stub_listeners);
 
        hashmap_free(m->polkit_registry);
 
        sd_bus_flush_close_unref(m->bus);
 
        dns_resource_key_unref(m->llmnr_host_ipv4_key);
        dns_resource_key_unref(m->llmnr_host_ipv6_key);
        dns_resource_key_unref(m->mdns_host_ipv4_key);
        dns_resource_key_unref(m->mdns_host_ipv6_key);
 
        sd_event_source_unref(m->hostname_event_source);
        safe_close(m->hostname_fd);
 
        sd_event_unref(m->event);
 
        free(m->full_hostname);
        free(m->llmnr_hostname);
        free(m->mdns_hostname);
 
        while ((s = hashmap_first(m->dnssd_registered_services)))
               dnssd_registered_service_free(s);
        hashmap_free(m->dnssd_registered_services);
 
        dns_trust_anchor_flush(&m->trust_anchor);
        manager_etc_hosts_flush(m);
        manager_static_records_flush(m);
 
        hashmap_free(m->dns_service_browsers);
 
        hashmap_free(m->hooks);
 
        return mfree(m);
}
 
int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
        CMSG_BUFFER_TYPE(CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo))
                         + CMSG_SPACE(int) /* ttl/hoplimit */
                         + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */) control;
        union sockaddr_union sa;
        struct iovec iov;
        struct msghdr mh = {
                .msg_name = &sa.sa,
                .msg_namelen = sizeof(sa),
                .msg_iov = &iov,
                .msg_iovlen = 1,
                .msg_control = &control,
                .msg_controllen = sizeof(control),
        };
        struct cmsghdr *cmsg;
        ssize_t ms, l;
        int r;
 
        assert(m);
        assert(fd >= 0);
        assert(ret);
 
        ms = next_datagram_size_fd(fd);
        /* The MSG_PEEK recv() in next_datagram_size_fd() validates the datagram's checksum, and drops it if
         * it is bad. Hence we can end up here with nothing left to read even though the event source said
         * otherwise, and must treat that like the recvmsg_safe() below does: as "no packet", not as a
         * failure. Our callers propagate a failure to the event loop, which would then turn the listening
         * socket's event source off for good. */
        if (ERRNO_IS_NEG_TRANSIENT(ms))
                return 0;
        if (ms < 0)
                return ms;
 
        r = dns_packet_new(&p, protocol, ms, DNS_PACKET_SIZE_MAX);
        if (r < 0)
                return r;
 
        iov = IOVEC_MAKE(DNS_PACKET_DATA(p), p->allocated);
 
        l = recvmsg_safe(fd, &mh, 0);
        if (ERRNO_IS_NEG_TRANSIENT(l))
                return 0;
        if (l <= 0)
                return l;
 
        p->size = (size_t) l;
 
        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;
 
        p->timestamp = now(CLOCK_BOOTTIME);
 
        CMSG_FOREACH(cmsg, &mh) {
 
                if (cmsg->cmsg_level == IPPROTO_IPV6) {
                        assert(p->family == AF_INET6);
 
                        switch (cmsg->cmsg_type) {