HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/resolved-dns-server.c

53,622 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: b231a3d92962b7ed0fb15ed7d353bff05462da20

Lines 1001–1391 of 1,391

                if (r <= 0)
                        return r;
 
                r = manager_add_search_domain_by_string(m, word);
                if (r < 0)
                        log_warning_errno(r, "Failed to add search domain '%s', ignoring: %m", word);
        }
}
 
DnsServer *manager_get_first_dns_server(Manager *m, DnsServerType t) {
        assert(m);
 
        switch (t) {
 
        case DNS_SERVER_SYSTEM:
                return m->dns_servers;
 
        case DNS_SERVER_FALLBACK:
                return m->fallback_dns_servers;
 
        default:
                return NULL;
        }
}
 
DnsServer *manager_set_dns_server(Manager *m, DnsServer *s) {
        assert(m);
 
        if (m->current_dns_server == s)
                return s;
 
        /* Let's log about the server switch, at debug level. Except if we switch from a non-fallback server
         * to a fallback server or back, since that is noteworthy and possibly a configuration issue */
        if (s)
                log_full((s->type == DNS_SERVER_FALLBACK) != (m->current_dns_server && m->current_dns_server->type == DNS_SERVER_FALLBACK) ? LOG_NOTICE : LOG_DEBUG,
                         "Switching to %s DNS server %s.", dns_server_type_to_string(s->type), strna(dns_server_string_full(s)));
 
        dns_server_unref(m->current_dns_server);
        m->current_dns_server = dns_server_ref(s);
 
        /* Skip flushing the cache if server stale feature is enabled. */
        if (m->unicast_scope && m->stale_retention_usec == 0)
                dns_cache_flush(&m->unicast_scope->cache);
 
        (void) manager_send_changed(m, "CurrentDNSServer");
        (void) manager_send_dns_configuration_changed(m, NULL, /* reset= */ false);
 
        return s;
}
 
static bool manager_search_default_route_dns_server(Manager *m) {
        assert(m);
 
        LIST_FOREACH(scopes, scope, m->dns_scopes) {
                /* Ignore the global scope, it's handled separately */
                if (scope->origin == DNS_SCOPE_GLOBAL)
                        continue;
 
                /* Scope has no DNS server? */
                if (dns_scope_get_n_dns_servers(scope) == 0)
                        continue;
 
                /* If this is suitable as default route, we found what we are looking for */
                if (dns_scope_is_default_route(scope))
                        return true;
        }
 
        return false;
}
 
DnsServer *manager_get_dns_server(Manager *m) {
        assert(m);
 
        /* Try to read updates resolv.conf */
        manager_read_resolv_conf(m);
 
        /* If no DNS server was chosen so far, pick the first one */
        if (!m->current_dns_server ||
            /* In case m->current_dns_server != m->dns_servers */
            manager_server_is_stub(m, m->current_dns_server))
                manager_set_dns_server(m, m->dns_servers);
 
        while (m->current_dns_server &&
               manager_server_is_stub(m, m->current_dns_server)) {
                manager_next_dns_server(m, NULL);
                if (m->current_dns_server == m->dns_servers)
                        manager_set_dns_server(m, NULL);
        }
 
        /* If no DNS servers are configured, let's see if there are any on any links or delegates. If not, we
         * use the fallback servers */
        if (!m->current_dns_server && !manager_search_default_route_dns_server(m))
                manager_set_dns_server(m, m->fallback_dns_servers);
 
        return m->current_dns_server;
}
 
void manager_next_dns_server(Manager *m, DnsServer *if_current) {
        assert(m);
 
        /* If the DNS server is already a different one than the one specified in 'if_current' don't do anything */
        if (if_current && m->current_dns_server != if_current)
                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, but make sure to follow the linked list only if the server is still
         * linked. */
        if (m->current_dns_server->linked && m->current_dns_server->servers_next) {
                manager_set_dns_server(m, m->current_dns_server->servers_next);
                return;
        }
 
        /* 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);
}
 
DnssecMode dns_server_get_dnssec_mode(DnsServer *s) {
        assert(s);
 
        if (s->link)
                return link_get_dnssec_mode(s->link);
 
        return manager_get_dnssec_mode(s->manager);
}
 
DnsOverTlsMode dns_server_get_dns_over_tls_mode(DnsServer *s) {
        assert(s);
 
        if (s->link)
                return link_get_dns_over_tls_mode(s->link);
 
        return manager_get_dns_over_tls_mode(s->manager);
}
 
void dns_server_flush_cache(DnsServer *s) {
        DnsServer *current;
        DnsScope *scope;
 
        assert(s);
 
        /* Flush the cache of the scope this server belongs to */
 
        current =   s->link ? s->link->current_dns_server :
                s->delegate ? s->delegate->current_dns_server :
                              s->manager->current_dns_server;
        if (current != s)
                return;
 
        scope =     s->link ? s->link->unicast_scope :
                s->delegate ? s->delegate->scope :
                              s->manager->unicast_scope;
        if (!scope)
                return;
 
        /* Skip flushing the cache if server stale feature is enabled. */
        if (s->manager->stale_retention_usec > 0)
                return;
 
        dns_cache_flush(&scope->cache);
}
 
void dns_server_reset_features(DnsServer *s) {
        assert(s);
 
        s->verified_feature_level = _DNS_SERVER_FEATURE_LEVEL_INVALID;
        s->possible_feature_level = DNS_SERVER_FEATURE_LEVEL_BEST;
 
        s->received_udp_fragment_max = DNS_PACKET_UNICAST_SIZE_MAX;
 
        s->packet_bad_opt = false;
        s->packet_rrsig_missing = false;
        s->packet_do_off = false;
 
        s->features_grace_period_usec = DNS_SERVER_FEATURE_GRACE_PERIOD_MIN_USEC;
 
        s->warned_downgrade = false;
 
        dns_server_reset_counters(s);
 
        /* Let's close the default stream, so that we reprobe with the new features */
        dns_server_unref_stream(s);
}
 
void dns_server_reset_features_all(DnsServer *s) {
        LIST_FOREACH(servers, i, s)
                dns_server_reset_features(i);
}
 
void dns_server_dump(DnsServer *s, FILE *f) {
        assert(s);
 
        if (!f)
                f = stdout;
 
        fputs("[Server ", f);
        fputs(strna(dns_server_string_full(s)), f);
        fputs(" type=", f);
        fputs(dns_server_type_to_string(s->type), f);
 
        if (s->type == DNS_SERVER_LINK) {
                assert(s->link);
 
                fputs(" interface=", f);
                fputs(s->link->ifname, f);
        }
 
        fputs("]\n", f);
 
        fputs("\tVerified feature level: ", f);
        fputs(strna(dns_server_feature_level_to_string(s->verified_feature_level)), f);
        fputc('\n', f);
 
        fputs("\tPossible feature level: ", f);
        fputs(strna(dns_server_feature_level_to_string(s->possible_feature_level)), f);
        fputc('\n', f);
 
        fputs("\tDNSSEC Mode: ", f);
        fputs(strna(dnssec_mode_to_string(dns_server_get_dnssec_mode(s))), f);
        fputc('\n', f);
 
        fputs("\tCan do DNSSEC: ", f);
        fputs(yes_no(dns_server_dnssec_supported(s)), f);
        fputc('\n', f);
 
        fprintf(f,
                "\tMaximum UDP fragment size received: %zu\n"
                "\tFailed UDP attempts: %u\n"
                "\tFailed TCP attempts: %u\n"
                "\tSeen truncated packet: %s\n"
                "\tSeen OPT RR getting lost: %s\n"
                "\tSeen RRSIG RR missing: %s\n"
                "\tSeen invalid packet: %s\n"
                "\tServer dropped DO flag: %s\n",
                s->received_udp_fragment_max,
                s->n_failed_udp,
                s->n_failed_tcp,
                yes_no(s->packet_truncated),
                yes_no(s->packet_bad_opt),
                yes_no(s->packet_rrsig_missing),
                yes_no(s->packet_invalid),
                yes_no(s->packet_do_off));
}
 
void dns_server_unref_stream(DnsServer *s) {
        DnsStream *ref;
 
        assert(s);
 
        /* Detaches the default stream of this server. Some special care needs to be taken here, as that stream and
         * this server reference each other. First, take the stream out of the server. It's destructor will check if it
         * is registered with us, hence let's invalidate this separately, so that it is already unregistered. */
        ref = TAKE_PTR(s->stream);
 
        /* And then, unref it */
        dns_stream_unref(ref);
}
 
DnsScope *dns_server_scope(DnsServer *s) {
        assert(s);
        assert(s->linked);
        assert((s->type == DNS_SERVER_LINK) == !!s->link);
        assert((s->type == DNS_SERVER_DELEGATE) == !!s->delegate);
 
        if (s->link)
                return s->link->unicast_scope;
        if (s->delegate)
                return s->delegate->scope;
 
        return s->manager->unicast_scope;
}
 
static const char* const dns_server_type_table[_DNS_SERVER_TYPE_MAX] = {
        [DNS_SERVER_SYSTEM]   = "system",
        [DNS_SERVER_FALLBACK] = "fallback",
        [DNS_SERVER_LINK]     = "link",
};
DEFINE_STRING_TABLE_LOOKUP(dns_server_type, DnsServerType);
 
static const char* const dns_server_feature_level_table[_DNS_SERVER_FEATURE_LEVEL_MAX] = {
        [DNS_SERVER_FEATURE_LEVEL_TCP]       = "TCP",
        [DNS_SERVER_FEATURE_LEVEL_UDP]       = "UDP",
        [DNS_SERVER_FEATURE_LEVEL_EDNS0]     = "UDP+EDNS0",
        [DNS_SERVER_FEATURE_LEVEL_TLS_PLAIN] = "TLS+EDNS0",
        [DNS_SERVER_FEATURE_LEVEL_DO]        = "UDP+EDNS0+DO",
        [DNS_SERVER_FEATURE_LEVEL_TLS_DO]    = "TLS+EDNS0+DO",
};
DEFINE_STRING_TABLE_LOOKUP(dns_server_feature_level, DnsServerFeatureLevel);
 
int dns_server_dump_state_to_json(DnsServer *server, sd_json_variant **ret) {
 
        assert(server);
        assert(ret);
 
        return sd_json_buildo(
                        ret,
                        SD_JSON_BUILD_PAIR_STRING("Server", strna(dns_server_string_full(server))),
                        SD_JSON_BUILD_PAIR_STRING("Type", strna(dns_server_type_to_string(server->type))),
                        SD_JSON_BUILD_PAIR_CONDITION(server->type == DNS_SERVER_LINK, "Interface", SD_JSON_BUILD_STRING(server->link ? server->link->ifname : NULL)),
                        SD_JSON_BUILD_PAIR_CONDITION(server->type == DNS_SERVER_LINK, "InterfaceIndex", SD_JSON_BUILD_UNSIGNED(server->link ? server->link->ifindex : 0)),
                        SD_JSON_BUILD_PAIR_STRING("VerifiedFeatureLevel", strna(dns_server_feature_level_to_string(server->verified_feature_level))),
                        SD_JSON_BUILD_PAIR_STRING("PossibleFeatureLevel", strna(dns_server_feature_level_to_string(server->possible_feature_level))),
                        SD_JSON_BUILD_PAIR_STRING("DNSSECMode", strna(dnssec_mode_to_string(dns_server_get_dnssec_mode(server)))),
                        SD_JSON_BUILD_PAIR_BOOLEAN("DNSSECSupported", dns_server_dnssec_supported(server)),
                        SD_JSON_BUILD_PAIR_UNSIGNED("ReceivedUDPFragmentMax", server->received_udp_fragment_max),
                        SD_JSON_BUILD_PAIR_UNSIGNED("FailedUDPAttempts", server->n_failed_udp),
                        SD_JSON_BUILD_PAIR_UNSIGNED("FailedTCPAttempts", server->n_failed_tcp),
                        SD_JSON_BUILD_PAIR_BOOLEAN("PacketTruncated", server->packet_truncated),
                        SD_JSON_BUILD_PAIR_BOOLEAN("PacketBadOpt", server->packet_bad_opt),
                        SD_JSON_BUILD_PAIR_BOOLEAN("PacketRRSIGMissing", server->packet_rrsig_missing),
                        SD_JSON_BUILD_PAIR_BOOLEAN("PacketInvalid", server->packet_invalid),
                        SD_JSON_BUILD_PAIR_BOOLEAN("PacketDoOff", server->packet_do_off));
}
 
int dns_server_is_accessible(DnsServer *s) {
        _cleanup_close_ int fd = -EBADF;
        union sockaddr_union sa;
        int r;
 
        assert(s);
 
        if (s->accessible >= 0)
                return s->accessible;
 
        r = sockaddr_set_in_addr(&sa, s->family, &s->address, dns_server_port(s));
        if (r < 0)
                return r;
 
        fd = socket(s->family, SOCK_DGRAM|SOCK_CLOEXEC, 0);
        if (fd < 0)
                return -errno;
 
        if (s->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &s->address)) {
                /* Connecting to ipv6 link-local requires binding to an interface. */
                r = socket_bind_to_ifindex(fd, dns_server_ifindex(s));
                if (r < 0)
                        return r;
        }
 
        r = RET_NERRNO(connect(fd, &sa.sa, sockaddr_len(&sa)));
        if (!IN_SET(r,
                    0,
                    -ENETUNREACH,
                    -EHOSTDOWN,
                    -EHOSTUNREACH,
                    -ENETDOWN,
                    -ENETRESET,
                    -ENONET))
                /* If we did not receive one of the expected return values,
                 * then leave the accessible flag untouched. */
                return r;
 
        return (s->accessible = r >= 0);
}
 
void dns_server_reset_accessible_all(DnsServer *first) {
        LIST_FOREACH(servers, s, first)
                dns_server_reset_accessible(s);
}
 
int dns_server_dump_configuration_to_json(DnsServer *server, sd_json_variant **ret) {
        bool accessible = false;
        int ifindex, r;
 
        assert(server);
        assert(ret);
 
        ifindex = dns_server_ifindex(server);
 
        r = dns_server_is_accessible(server);
        if (r < 0)
                log_debug_errno(r, "Failed to check if %s is accessible, assume not: %m", dns_server_string_full(server));
        else
                accessible = r;
 
        return sd_json_buildo(
                        ret,
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("addressString", dns_server_string(server)),
                        JSON_BUILD_PAIR_IN_ADDR("address", server->family, &server->address),
                        SD_JSON_BUILD_PAIR_INTEGER("family", server->family),
                        SD_JSON_BUILD_PAIR_UNSIGNED("port", dns_server_port(server)),
                        SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_UNSIGNED(ifindex)),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("name", server->server_name),
                        SD_JSON_BUILD_PAIR_BOOLEAN("accessible", accessible));
}