HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/resolved-link.c

51,732 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: ea089c1e100c74add96aa63a3f454690543e68a4

Lines 1001–1511 of 1,511

 
                        r = dns_zone_put(&a->link->llmnr_ipv4_scope->zone, a->link->llmnr_ipv4_scope, a->llmnr_address_rr, true);
                        if (r < 0)
                                log_link_warning_errno(a->link, r, "Failed to add A record to LLMNR zone, ignoring: %m");
 
                        r = dns_zone_put(&a->link->llmnr_ipv4_scope->zone, a->link->llmnr_ipv4_scope, a->llmnr_ptr_rr, false);
                        if (r < 0)
                                log_link_warning_errno(a->link, r, "Failed to add IPv4 PTR record to LLMNR zone, ignoring: %m");
                } else {
                        if (a->llmnr_address_rr) {
                                if (a->link->llmnr_ipv4_scope)
                                        dns_zone_remove_rr(&a->link->llmnr_ipv4_scope->zone, a->llmnr_address_rr);
                                a->llmnr_address_rr = dns_resource_record_unref(a->llmnr_address_rr);
                        }
 
                        if (a->llmnr_ptr_rr) {
                                if (a->link->llmnr_ipv4_scope)
                                        dns_zone_remove_rr(&a->link->llmnr_ipv4_scope->zone, a->llmnr_ptr_rr);
                                a->llmnr_ptr_rr = dns_resource_record_unref(a->llmnr_ptr_rr);
                        }
                }
 
                if (!force_remove &&
                    link_address_relevant(a, true) &&
                    a->link->mdns_ipv4_scope &&
                    link_get_mdns_support(a->link) == RESOLVE_SUPPORT_YES) {
                        if (!a->link->manager->mdns_host_ipv4_key) {
                                a->link->manager->mdns_host_ipv4_key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, a->link->manager->mdns_hostname);
                                if (!a->link->manager->mdns_host_ipv4_key) {
                                        r = -ENOMEM;
                                        goto fail;
                                }
                        }
 
                        if (!a->mdns_address_rr) {
                                a->mdns_address_rr = dns_resource_record_new(a->link->manager->mdns_host_ipv4_key);
                                if (!a->mdns_address_rr) {
                                        r = -ENOMEM;
                                        goto fail;
                                }
 
                                a->mdns_address_rr->a.in_addr = a->in_addr.in;
                                a->mdns_address_rr->ttl = MDNS_DEFAULT_TTL;
                        }
 
                        if (!a->mdns_ptr_rr) {
                                r = dns_resource_record_new_reverse(&a->mdns_ptr_rr, a->family, &a->in_addr, a->link->manager->mdns_hostname);
                                if (r < 0)
                                        goto fail;
 
                                a->mdns_ptr_rr->ttl = MDNS_DEFAULT_TTL;
                        }
 
                        r = dns_zone_put(&a->link->mdns_ipv4_scope->zone, a->link->mdns_ipv4_scope, a->mdns_address_rr, true);
                        if (r < 0)
                                log_link_warning_errno(a->link, r, "Failed to add A record to MDNS zone, ignoring: %m");
 
                        r = dns_zone_put(&a->link->mdns_ipv4_scope->zone, a->link->mdns_ipv4_scope, a->mdns_ptr_rr, false);
                        if (r < 0)
                                log_link_warning_errno(a->link, r, "Failed to add IPv4 PTR record to MDNS zone, ignoring: %m");
                } else {
                        if (a->mdns_address_rr) {
                                if (a->link->mdns_ipv4_scope)
                                        dns_zone_remove_rr(&a->link->mdns_ipv4_scope->zone, a->mdns_address_rr);
                                a->mdns_address_rr = dns_resource_record_unref(a->mdns_address_rr);
                        }
 
                        if (a->mdns_ptr_rr) {
                                if (a->link->mdns_ipv4_scope)
                                        dns_zone_remove_rr(&a->link->mdns_ipv4_scope->zone, a->mdns_ptr_rr);
                                a->mdns_ptr_rr = dns_resource_record_unref(a->mdns_ptr_rr);
                        }
                }
        }
 
        if (a->family == AF_INET6) {
 
                if (!force_remove &&
                    link_address_relevant(a, true) &&
                    a->link->llmnr_ipv6_scope &&
                    link_get_llmnr_support(a->link) == RESOLVE_SUPPORT_YES) {
 
                        if (!a->link->manager->llmnr_host_ipv6_key) {
                                a->link->manager->llmnr_host_ipv6_key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_AAAA, a->link->manager->llmnr_hostname);
                                if (!a->link->manager->llmnr_host_ipv6_key) {
                                        r = -ENOMEM;
                                        goto fail;
                                }
                        }
 
                        if (!a->llmnr_address_rr) {
                                a->llmnr_address_rr = dns_resource_record_new(a->link->manager->llmnr_host_ipv6_key);
                                if (!a->llmnr_address_rr) {
                                        r = -ENOMEM;
                                        goto fail;
                                }
 
                                a->llmnr_address_rr->aaaa.in6_addr = a->in_addr.in6;
                                a->llmnr_address_rr->ttl = LLMNR_DEFAULT_TTL;
                        }
 
                        if (!a->llmnr_ptr_rr) {
                                r = dns_resource_record_new_reverse(&a->llmnr_ptr_rr, a->family, &a->in_addr, a->link->manager->llmnr_hostname);
                                if (r < 0)
                                        goto fail;
 
                                a->llmnr_ptr_rr->ttl = LLMNR_DEFAULT_TTL;
                        }
 
                        r = dns_zone_put(&a->link->llmnr_ipv6_scope->zone, a->link->llmnr_ipv6_scope, a->llmnr_address_rr, true);
                        if (r < 0)
                                log_link_warning_errno(a->link, r, "Failed to add AAAA record to LLMNR zone, ignoring: %m");
 
                        r = dns_zone_put(&a->link->llmnr_ipv6_scope->zone, a->link->llmnr_ipv6_scope, a->llmnr_ptr_rr, false);
                        if (r < 0)
                                log_link_warning_errno(a->link, r, "Failed to add IPv6 PTR record to LLMNR zone, ignoring: %m");
                } else {
                        if (a->llmnr_address_rr) {
                                if (a->link->llmnr_ipv6_scope)
                                        dns_zone_remove_rr(&a->link->llmnr_ipv6_scope->zone, a->llmnr_address_rr);
                                a->llmnr_address_rr = dns_resource_record_unref(a->llmnr_address_rr);
                        }
 
                        if (a->llmnr_ptr_rr) {
                                if (a->link->llmnr_ipv6_scope)
                                        dns_zone_remove_rr(&a->link->llmnr_ipv6_scope->zone, a->llmnr_ptr_rr);
                                a->llmnr_ptr_rr = dns_resource_record_unref(a->llmnr_ptr_rr);
                        }
                }
 
                if (!force_remove &&
                    link_address_relevant(a, true) &&
                    a->link->mdns_ipv6_scope &&
                    link_get_mdns_support(a->link) == RESOLVE_SUPPORT_YES) {
 
                        if (!a->link->manager->mdns_host_ipv6_key) {
                                a->link->manager->mdns_host_ipv6_key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_AAAA, a->link->manager->mdns_hostname);
                                if (!a->link->manager->mdns_host_ipv6_key) {
                                        r = -ENOMEM;
                                        goto fail;
                                }
                        }
 
                        if (!a->mdns_address_rr) {
                                a->mdns_address_rr = dns_resource_record_new(a->link->manager->mdns_host_ipv6_key);
                                if (!a->mdns_address_rr) {
                                        r = -ENOMEM;
                                        goto fail;
                                }
 
                                a->mdns_address_rr->aaaa.in6_addr = a->in_addr.in6;
                                a->mdns_address_rr->ttl = MDNS_DEFAULT_TTL;
                        }
 
                        if (!a->mdns_ptr_rr) {
                                r = dns_resource_record_new_reverse(&a->mdns_ptr_rr, a->family, &a->in_addr, a->link->manager->mdns_hostname);
                                if (r < 0)
                                        goto fail;
 
                                a->mdns_ptr_rr->ttl = MDNS_DEFAULT_TTL;
                        }
 
                        r = dns_zone_put(&a->link->mdns_ipv6_scope->zone, a->link->mdns_ipv6_scope, a->mdns_address_rr, true);
                        if (r < 0)
                                log_link_warning_errno(a->link, r, "Failed to add AAAA record to MDNS zone, ignoring: %m");
 
                        r = dns_zone_put(&a->link->mdns_ipv6_scope->zone, a->link->mdns_ipv6_scope, a->mdns_ptr_rr, false);
                        if (r < 0)
                                log_link_warning_errno(a->link, r, "Failed to add IPv6 PTR record to MDNS zone, ignoring: %m");
                } else {
                        if (a->mdns_address_rr) {
                                if (a->link->mdns_ipv6_scope)
                                        dns_zone_remove_rr(&a->link->mdns_ipv6_scope->zone, a->mdns_address_rr);
                                a->mdns_address_rr = dns_resource_record_unref(a->mdns_address_rr);
                        }
 
                        if (a->mdns_ptr_rr) {
                                if (a->link->mdns_ipv6_scope)
                                        dns_zone_remove_rr(&a->link->mdns_ipv6_scope->zone, a->mdns_ptr_rr);
                                a->mdns_ptr_rr = dns_resource_record_unref(a->mdns_ptr_rr);
                        }
                }
        }
 
        return;
 
fail:
        log_link_debug_errno(a->link, r, "Failed to update address RRs, ignoring: %m");
}
 
int link_address_update_rtnl(LinkAddress *a, sd_netlink_message *m) {
        int r;
 
        assert(a);
        assert(m);
 
        r = sd_netlink_message_read_u32(m, IFA_FLAGS, &a->flags);
        if (r < 0)
                return r;
 
        (void) sd_rtnl_message_addr_get_prefixlen(m, &a->prefixlen);
        (void) sd_rtnl_message_addr_get_scope(m, &a->scope);
 
        link_allocate_scopes(a->link);
        link_add_rrs(a->link, false);
 
        return 0;
}
 
bool link_address_relevant(LinkAddress *a, bool allow_link_local) {
        assert(a);
 
        if (a->flags & (IFA_F_DEPRECATED|IFA_F_TENTATIVE))
                return false;
 
        if (a->scope >= (allow_link_local ? RT_SCOPE_HOST : RT_SCOPE_LINK))
                return false;
 
        return true;
}
 
static bool link_needs_save(Link *l) {
        assert(l);
 
        /* Returns true if any of the settings where set different from the default */
 
        if (l->is_managed)
                return false;
 
        if (l->llmnr_support != RESOLVE_SUPPORT_YES ||
            l->mdns_support != RESOLVE_SUPPORT_YES ||
            l->dnssec_mode != _DNSSEC_MODE_INVALID ||
            l->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
                return true;
 
        if (l->dns_servers ||
            l->search_domains)
                return true;
 
        if (!set_isempty(l->dnssec_negative_trust_anchors))
                return true;
 
        if (l->default_route >= 0)
                return true;
 
        return false;
}
 
int link_save_user(Link *l) {
        _cleanup_(unlink_and_freep) char *temp_path = NULL;
        _cleanup_fclose_ FILE *f = NULL;
        const char *v;
        int r;
 
        assert(l);
        assert(l->state_file);
 
        if (!link_needs_save(l)) {
                (void) unlink(l->state_file);
                return 0;
        }
 
        r = mkdir_parents(l->state_file, 0700);
        if (r < 0)
                goto fail;
 
        r = fopen_temporary(l->state_file, &f, &temp_path);
        if (r < 0)
                goto fail;
 
        (void) fchmod(fileno(f), 0644);
 
        fputs("# This is private data. Do not parse.\n", f);
 
        v = resolve_support_to_string(l->llmnr_support);
        if (v)
                fprintf(f, "LLMNR=%s\n", v);
 
        v = resolve_support_to_string(l->mdns_support);
        if (v)
                fprintf(f, "MDNS=%s\n", v);
 
        v = dnssec_mode_to_string(l->dnssec_mode);
        if (v)
                fprintf(f, "DNSSEC=%s\n", v);
 
        v = dns_over_tls_mode_to_string(l->dns_over_tls_mode);
        if (v)
                fprintf(f, "DNSOVERTLS=%s\n", v);
 
        if (l->default_route >= 0)
                fprintf(f, "DEFAULT_ROUTE=%s\n", yes_no(l->default_route));
 
        if (l->dns_servers) {
                fputs("SERVERS=", f);
                LIST_FOREACH(servers, server, l->dns_servers) {
 
                        if (server != l->dns_servers)
                                fputc(' ', f);
 
                        v = dns_server_string_full(server);
                        if (!v) {
                                r = -ENOMEM;
                                goto fail;
                        }
 
                        fputs(v, f);
                }
                fputc('\n', f);
        }
 
        if (l->search_domains) {
                fputs("DOMAINS=", f);
                LIST_FOREACH(domains, domain, l->search_domains) {
 
                        if (domain != l->search_domains)
                                fputc(' ', f);
 
                        if (domain->route_only)
                                fputc('~', f);
 
                        fputs(DNS_SEARCH_DOMAIN_NAME(domain), f);
                }
                fputc('\n', f);
        }
 
        if (!set_isempty(l->dnssec_negative_trust_anchors)) {
                bool space = false;
                char *nta;
 
                fputs("NTAS=", f);
                SET_FOREACH(nta, l->dnssec_negative_trust_anchors) {
 
                        if (space)
                                fputc(' ', f);
 
                        fputs(nta, f);
                        space = true;
                }
                fputc('\n', f);
        }
 
        r = fflush_and_check(f);
        if (r < 0)
                goto fail;
 
        if (rename(temp_path, l->state_file) < 0) {
                r = -errno;
                goto fail;
        }
 
        temp_path = mfree(temp_path);
 
        return 0;
 
fail:
        (void) unlink(l->state_file);
 
        return log_link_error_errno(l, r, "Failed to save link data %s: %m", l->state_file);
}
 
int link_load_user(Link *l) {
        _cleanup_free_ char
                *llmnr = NULL,
                *mdns = NULL,
                *dnssec = NULL,
                *dns_over_tls = NULL,
                *servers = NULL,
                *domains = NULL,
                *ntas = NULL,
                *default_route = NULL;
 
        ResolveSupport s;
        const char *p;
        int r;
 
        assert(l);
        assert(l->state_file);
 
        /* Try to load only a single time */
        if (l->loaded)
                return 0;
        l->loaded = true;
 
        if (l->is_managed)
                return 0; /* if the device is managed, then networkd is our configuration source, not the bus API */
 
        r = parse_env_file(NULL, l->state_file,
                           "LLMNR", &llmnr,
                           "MDNS", &mdns,
                           "DNSSEC", &dnssec,
                           "DNSOVERTLS", &dns_over_tls,
                           "SERVERS", &servers,
                           "DOMAINS", &domains,
                           "NTAS", &ntas,
                           "DEFAULT_ROUTE", &default_route);
        if (r == -ENOENT)
                return 0;
        if (r < 0)
                goto fail;
 
        link_flush_settings(l);
 
        /* If we can't recognize the LLMNR or MDNS setting we don't override the default */
        s = resolve_support_from_string(llmnr);
        if (s >= 0)
                l->llmnr_support = s;
 
        s = resolve_support_from_string(mdns);
        if (s >= 0)
                l->mdns_support = s;
 
        r = parse_boolean(default_route);
        if (r >= 0)
                l->default_route = r;
 
        /* If we can't recognize the DNSSEC setting, then set it to invalid, so that the daemon default is used. */
        l->dnssec_mode = dnssec_mode_from_string(dnssec);
 
        /* Same for DNSOverTLS */
        l->dns_over_tls_mode = dns_over_tls_mode_from_string(dns_over_tls);
 
        for (p = servers;;) {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&p, &word, NULL, 0);
                if (r < 0)
                        goto fail;
                if (r == 0)
                        break;
 
                r = link_update_dns_server_one(l, word);
                if (r < 0) {
                        log_link_debug_errno(l, r, "Failed to load DNS server '%s', ignoring: %m", word);
                        continue;
                }
        }
 
        for (p = domains;;) {
                _cleanup_free_ char *word = NULL;
                const char *n;
                bool is_route;
 
                r = extract_first_word(&p, &word, NULL, 0);
                if (r < 0)
                        goto fail;
                if (r == 0)
                        break;
 
                is_route = word[0] == '~';
                n = is_route ? word + 1 : word;
 
                r = link_update_search_domain_one(l, n, is_route);
                if (r < 0) {
                        log_link_debug_errno(l, r, "Failed to load search domain '%s', ignoring: %m", word);
                        continue;
                }
        }
 
        if (ntas) {
                _cleanup_set_free_ Set *ns = NULL;
 
                ns = set_new(&dns_name_hash_ops_free);
                if (!ns) {
                        r = -ENOMEM;
                        goto fail;
                }
 
                r = set_put_strsplit(ns, ntas, NULL, 0);
                if (r < 0)
                        goto fail;
 
                l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
        }
 
        return 0;
 
fail:
        return log_link_error_errno(l, r, "Failed to load link data %s: %m", l->state_file);
}
 
void link_remove_user(Link *l) {
        assert(l);
        assert(l->state_file);
 
        (void) unlink(l->state_file);
}
 
bool link_negative_trust_anchor_lookup(Link *l, const char *name) {
        int r;
 
        assert(l);
        assert(name);
 
        /* Checks whether the specified domain (or any of its parent domains) are listed as per-link NTA. */
 
        for (;;) {
                if (set_contains(l->dnssec_negative_trust_anchors, name))
                        return true;
 
                /* And now, let's look at the parent, and check that too */
                r = dns_name_parent(&name);
                if (r < 0)
                        return r;
                if (r == 0)
                        break;
        }
 
        return false;
}