HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/resolved-dns-cache.c

58,993 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: bf36434083a7c30757f60f59efccada15c359952

Lines 1001–1550 of 1,550

                usec_t current) {
 
        _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *patched = NULL, *patched_rrsig = NULL;
        int r;
 
        assert(answer);
        assert(rr);
 
        if (FLAGS_SET(query_flags, SD_RESOLVED_CLAMP_TTL)) {
                uint32_t left_ttl;
 
                assert(current > 0);
 
                /* Let's determine how much time is left for this cache entry. Note that we round down, but
                 * clamp this to be 1s at minimum, since we usually want records to remain cached better too
                 * short a time than too long a time, but otoh don't want to return 0 ever, since that has
                 * special semantics in various contexts — in particular in mDNS */
 
                left_ttl = MAX(1U, LESS_BY(until, current) / USEC_PER_SEC);
 
                patched = dns_resource_record_ref(rr);
 
                r = dns_resource_record_clamp_ttl(&patched, left_ttl);
                if (r < 0)
                        return r;
 
                rr = patched;
 
                if (rrsig) {
                        patched_rrsig = dns_resource_record_ref(rrsig);
                        r = dns_resource_record_clamp_ttl(&patched_rrsig, left_ttl);
                        if (r < 0)
                                return r;
 
                        rrsig = patched_rrsig;
                }
        }
 
        r = dns_answer_add_extend_full(answer, rr, ifindex, answer_flags, rrsig, until);
        if (r < 0)
                return r;
 
        return 0;
}
 
int dns_cache_lookup(
                DnsCache *c,
                DnsResourceKey *key,
                uint64_t query_flags,
                int *ret_rcode,
                DnsAnswer **ret_answer,
                DnsPacket **ret_full_packet,
                uint64_t *ret_query_flags,
                DnssecResult *ret_dnssec_result) {
 
        _cleanup_(dns_packet_unrefp) DnsPacket *full_packet = NULL;
        _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
        char key_str[DNS_RESOURCE_KEY_STRING_MAX];
        unsigned n = 0;
        int r;
        bool nxdomain = false;
        DnsCacheItem *first, *nsec = NULL;
        bool have_authenticated = false, have_non_authenticated = false, have_confidential = false, have_non_confidential = false;
        usec_t current = 0;
        int found_rcode = -1;
        DnssecResult dnssec_result = -1;
        int have_dnssec_result = -1;
 
        assert(c);
        assert(key);
 
        if (key->type == DNS_TYPE_ANY || key->class == DNS_CLASS_ANY) {
                /* If we have ANY lookups we don't use the cache, so that the caller refreshes via the
                 * network. */
 
                log_debug("Ignoring cache for ANY lookup: %s",
                          dns_resource_key_to_string(key, key_str, sizeof key_str));
                goto miss;
        }
 
        first = dns_cache_get_by_key_follow_cname_dname_nsec(c, key, query_flags);
        if (!first) {
                /* If one question cannot be answered we need to refresh */
 
                log_debug("Cache miss for %s",
                          dns_resource_key_to_string(key, key_str, sizeof key_str));
                goto miss;
        }
 
        if ((query_flags & (SD_RESOLVED_CLAMP_TTL | SD_RESOLVED_NO_STALE)) != 0) {
                /* 'current' is always passed to answer_add_clamp_ttl(), but is only used conditionally.
                 * We'll do the same assert there to make sure that it was initialized properly.
                 * 'current' is also used below when SD_RESOLVED_NO_STALE is set. */
                current = now(CLOCK_BOOTTIME);
                assert(current > 0);
        }
 
        LIST_FOREACH(by_key, j, first) {
                /* If the caller doesn't allow us to answer questions from cache data learned from
                 * "side-effect", skip this entry. */
                if (FLAGS_SET(query_flags, SD_RESOLVED_REQUIRE_PRIMARY) &&
                    !DNS_CACHE_ITEM_IS_PRIMARY(j)) {
                        log_debug("Primary answer was requested for cache lookup for %s, which we don't have.",
                                  dns_resource_key_to_string(key, key_str, sizeof key_str));
 
                        goto miss;
                }
 
                /* Skip the next part if ttl is expired and requested with no stale flag. */
                if (FLAGS_SET(query_flags, SD_RESOLVED_NO_STALE) && j->until_valid < current) {
                        log_debug("Requested with no stale and TTL expired for %s",
                                                dns_resource_key_to_string(key, key_str, sizeof key_str));
 
                        goto miss;
                }
 
                if (j->type == DNS_CACHE_NXDOMAIN)
                        nxdomain = true;
                else if (j->type == DNS_CACHE_RCODE)
                        found_rcode = j->rcode;
                else if (j->rr) {
                        if (j->rr->key->type == DNS_TYPE_NSEC)
                                nsec = j;
 
                        n++;
                }
 
                if (FLAGS_SET(j->query_flags, SD_RESOLVED_AUTHENTICATED))
                        have_authenticated = true;
                else
                        have_non_authenticated = true;
 
                if (FLAGS_SET(j->query_flags, SD_RESOLVED_CONFIDENTIAL))
                        have_confidential = true;
                else
                        have_non_confidential = true;
 
                if (j->dnssec_result < 0) {
                        have_dnssec_result = false; /* an entry without dnssec result? then invalidate things for good */
                        dnssec_result = _DNSSEC_RESULT_INVALID;
                } else if (have_dnssec_result < 0) {
                        have_dnssec_result = true; /* So far no result seen, let's pick this one up */
                        dnssec_result = j->dnssec_result;
                } else if (have_dnssec_result > 0 && j->dnssec_result != dnssec_result) {
                        have_dnssec_result = false; /* conflicting result seen? then invalidate for good */
                        dnssec_result = _DNSSEC_RESULT_INVALID;
                }
 
                /* An entry served past its TTL expiry (possible only when SD_RESOLVED_NO_STALE is
                 * unset, see above) reports its expiry as CACHE_STALE_TTL_MAX_USEC from now instead,
                 * so that clients don't hold on to the stale data for longer than that. The clamp is
                 * gated on SD_RESOLVED_CLAMP_TTL, its only consumer (see answer_add_clamp_ttl()),
                 * which also guarantees 'current' is set here. An entry whose TTL has not expired
                 * always reports its real expiry time, whether or not stale data was acceptable to
                 * the caller — flag-less lookups (the mDNS browse path) thus always see cache
                 * truth. */
                usec_t until = FLAGS_SET(query_flags, SD_RESOLVED_CLAMP_TTL) && j->until_valid < current ?
                               usec_add(current, CACHE_STALE_TTL_MAX_USEC) : j->until_valid;
 
                /* Append the answer RRs to our answer. Ideally we have the answer object, which we
                 * preferably use. But if the cached entry was generated as "side-effect" of a reply,
                 * i.e. from validated auxiliary records rather than from the main reply, then we use the
                 * individual RRs only instead. */
                if (j->answer) {
 
                        /* Minor optimization, if the full answer object of this and the previous RR is the
                         * same, don't bother adding it again. Typically we store a full RRset here, hence
                         * that should be the case. */
                        if (!j->by_key_prev || j->answer != j->by_key_prev->answer) {
                                DnsAnswerItem *item;
 
                                DNS_ANSWER_FOREACH_ITEM(item, j->answer) {
                                        r = answer_add_clamp_ttl(
                                                        &answer,
                                                        item->rr,
                                                        item->ifindex,
                                                        item->flags,
                                                        item->rrsig,
                                                        query_flags,
                                                        until,
                                                        current);
                                        if (r < 0)
                                                return r;
                                }
                        }
 
                } else if (j->rr) {
                        r = answer_add_clamp_ttl(
                                        &answer,
                                        j->rr,
                                        j->ifindex,
                                        FLAGS_SET(j->query_flags, SD_RESOLVED_AUTHENTICATED) ? DNS_ANSWER_AUTHENTICATED : 0,
                                        NULL,
                                        query_flags,
                                        until,
                                        current);
                        if (r < 0)
                                return r;
                }
 
                /* We'll return any packet we have for this. Typically all cache entries for the same key
                 * should come from the same packet anyway, hence it doesn't really matter which packet we
                 * return here, they should all resolve to the same anyway. */
                if (!full_packet && j->full_packet)
                        full_packet = dns_packet_ref(j->full_packet);
        }
 
        if (found_rcode >= 0) {
                log_debug("RCODE %s cache hit for %s",
                          FORMAT_DNS_RCODE(found_rcode),
                          dns_resource_key_to_string(key, key_str, sizeof(key_str)));
 
                if (ret_rcode)
                        *ret_rcode = found_rcode;
                if (ret_answer)
                        *ret_answer = TAKE_PTR(answer);
                if (ret_full_packet)
                        *ret_full_packet = TAKE_PTR(full_packet);
                if (ret_query_flags)
                        *ret_query_flags = 0;
                if (ret_dnssec_result)
                        *ret_dnssec_result = dnssec_result;
 
                c->n_hit++;
                return 1;
        }
 
        if (nsec && !IN_SET(key->type, DNS_TYPE_NSEC, DNS_TYPE_DS)) {
                /* Note that we won't derive information for DS RRs from an NSEC, because we only cache NSEC
                 * RRs from the lower-zone of a zone cut, but the DS RRs are on the upper zone. */
 
                log_debug("NSEC NODATA cache hit for %s",
                          dns_resource_key_to_string(key, key_str, sizeof key_str));
 
                /* We only found an NSEC record that matches our name.  If it says the type doesn't exist
                 * report NODATA. Otherwise report a cache miss. */
 
                if (ret_rcode)
                        *ret_rcode = DNS_RCODE_SUCCESS;
                if (ret_answer)
                        *ret_answer = TAKE_PTR(answer);
                if (ret_full_packet)
                        *ret_full_packet = TAKE_PTR(full_packet);
                if (ret_query_flags)
                        *ret_query_flags = nsec->query_flags;
                if (ret_dnssec_result)
                        *ret_dnssec_result = nsec->dnssec_result;
 
                if (!bitmap_isset(nsec->rr->nsec.types, key->type) &&
                    !bitmap_isset(nsec->rr->nsec.types, DNS_TYPE_CNAME) &&
                    !bitmap_isset(nsec->rr->nsec.types, DNS_TYPE_DNAME)) {
                        c->n_hit++;
                        return 1;
                }
 
                c->n_miss++;
                return 0;
        }
 
        log_debug("%s cache hit for %s",
                  n > 0    ? "Positive" :
                  nxdomain ? "NXDOMAIN" : "NODATA",
                  dns_resource_key_to_string(key, key_str, sizeof key_str));
 
        if (n <= 0) {
                c->n_hit++;
 
                if (ret_rcode)
                        *ret_rcode = nxdomain ? DNS_RCODE_NXDOMAIN : DNS_RCODE_SUCCESS;
                if (ret_answer)
                        *ret_answer = TAKE_PTR(answer);
                if (ret_full_packet)
                        *ret_full_packet = TAKE_PTR(full_packet);
                if (ret_query_flags)
                        *ret_query_flags =
                                ((have_authenticated && !have_non_authenticated) ? SD_RESOLVED_AUTHENTICATED : 0) |
                                ((have_confidential && !have_non_confidential) ? SD_RESOLVED_CONFIDENTIAL : 0);
                if (ret_dnssec_result)
                        *ret_dnssec_result = dnssec_result;
 
                return 1;
        }
 
        c->n_hit++;
 
        if (ret_rcode)
                *ret_rcode = DNS_RCODE_SUCCESS;
        if (ret_answer)
                *ret_answer = TAKE_PTR(answer);
        if (ret_full_packet)
                *ret_full_packet = TAKE_PTR(full_packet);
        if (ret_query_flags)
                *ret_query_flags =
                        ((have_authenticated && !have_non_authenticated) ? SD_RESOLVED_AUTHENTICATED : 0) |
                        ((have_confidential && !have_non_confidential) ? SD_RESOLVED_CONFIDENTIAL : 0);
        if (ret_dnssec_result)
                *ret_dnssec_result = dnssec_result;
 
        return n;
 
miss:
        if (ret_rcode)
                *ret_rcode = DNS_RCODE_SUCCESS;
        if (ret_answer)
                *ret_answer = NULL;
        if (ret_full_packet)
                *ret_full_packet = NULL;
        if (ret_query_flags)
                *ret_query_flags = 0;
        if (ret_dnssec_result)
                *ret_dnssec_result = _DNSSEC_RESULT_INVALID;
 
        c->n_miss++;
        return 0;
}
 
int dns_cache_check_conflicts(DnsCache *cache, DnsResourceRecord *rr, int owner_family, const union in_addr_union *owner_address) {
        DnsCacheItem *first;
        bool same_owner = true;
 
        assert(cache);
        assert(rr);
 
        dns_cache_prune(cache);
 
        /* See if there's a cache entry for the same key. If there
         * isn't there's no conflict */
        first = hashmap_get(cache->by_key, rr->key);
        if (!first)
                return 0;
 
        /* See if the RR key is owned by the same owner, if so, there
         * isn't a conflict either */
        LIST_FOREACH(by_key, i, first) {
                if (i->owner_family != owner_family ||
                    !in_addr_equal(owner_family, &i->owner_address, owner_address)) {
                        same_owner = false;
                        break;
                }
        }
        if (same_owner)
                return 0;
 
        /* See if there's the exact same RR in the cache. If yes, then
         * there's no conflict. */
        if (dns_cache_get(cache, rr))
                return 0;
 
        /* There's a conflict */
        return 1;
}
 
int dns_cache_export_shared_to_packet(DnsCache *cache, DnsPacket *p, usec_t ts, unsigned max_rr) {
        unsigned ancount = 0;
        DnsCacheItem *i;
        int r;
 
        assert(cache);
        assert(p);
        assert(p->protocol == DNS_PROTOCOL_MDNS);
 
        HASHMAP_FOREACH(i, cache->by_key)
                LIST_FOREACH(by_key, j, i) {
                        if (!j->rr)
                                continue;
 
                        if (!j->shared_owner)
                                continue;
 
                        /* Ignore cached goodby packet. See on_mdns_packet() and RFC 6762 section 10.1. */
                        if (j->rr->ttl <= 1)
                                continue;
 
                        /* RFC6762 7.1: Don't append records with less than half the TTL remaining
                         * as known answers. */
                        if (usec_sub_unsigned(j->until, ts) < j->rr->ttl * USEC_PER_SEC / 2)
                                continue;
 
                        if (max_rr > 0 && ancount >= max_rr) {
                                DNS_PACKET_HEADER(p)->ancount = htobe16(ancount);
                                ancount = 0;
 
                                r = dns_packet_new_query(&p->more, p->protocol, 0, true);
                                if (r < 0)
                                        return r;
 
                                p = p->more;
 
                                max_rr = UINT_MAX;
                        }
 
                        r = dns_packet_append_rr(p, j->rr, 0, NULL, NULL);
                        if (r == -EMSGSIZE) {
                                if (max_rr == 0)
                                        /* If max_rr == 0, do not allocate more packets. */
                                        goto finalize;
 
                                /* If we're unable to stuff all known answers into the given packet, allocate
                                 * a new one, push the RR into that one and link it to the current one. */
 
                                DNS_PACKET_HEADER(p)->ancount = htobe16(ancount);
                                ancount = 0;
 
                                r = dns_packet_new_query(&p->more, p->protocol, 0, true);
                                if (r < 0)
                                        return r;
 
                                /* continue with new packet */
                                p = p->more;
                                r = dns_packet_append_rr(p, j->rr, 0, NULL, NULL);
                        }
 
                        if (r < 0)
                                return r;
 
                        ancount++;
                }
 
finalize:
        DNS_PACKET_HEADER(p)->ancount = htobe16(ancount);
 
        return 0;
}
 
void dns_cache_dump(DnsCache *cache, FILE *f) {
        DnsCacheItem *i;
 
        if (!cache)
                return;
 
        if (!f)
                f = stdout;
 
        HASHMAP_FOREACH(i, cache->by_key)
                LIST_FOREACH(by_key, j, i) {
 
                        fputc('\t', f);
 
                        if (j->rr) {
                                const char *t;
                                t = dns_resource_record_to_string(j->rr);
                                if (!t) {
                                        log_oom();
                                        continue;
                                }
 
                                fputs(t, f);
                                fputc('\n', f);
                        } else {
                                char key_str[DNS_RESOURCE_KEY_STRING_MAX];
 
                                fputs(dns_resource_key_to_string(j->key, key_str, sizeof key_str), f);
                                fputs(" -- ", f);
                                fputs(dns_cache_item_type_to_string(j), f);
                                fputc('\n', f);
                        }
                }
}
 
int dns_cache_dump_to_json(DnsCache *cache, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *c = NULL;
        DnsCacheItem *i;
        int r;
 
        assert(cache);
        assert(ret);
 
        HASHMAP_FOREACH(i, cache->by_key) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *d = NULL, *k = NULL;
 
                r = dns_resource_key_to_json(i->key, &k);
                if (r < 0)
                        return r;
 
                if (i->rr) {
                        _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
 
                        LIST_FOREACH(by_key, j, i) {
                                _cleanup_(sd_json_variant_unrefp) sd_json_variant *rj = NULL;
 
                                assert(j->rr);
 
                                r = dns_resource_record_to_json(j->rr, &rj);
                                if (r < 0)
                                        return r;
 
                                r = dns_resource_record_to_wire_format(j->rr, /* canonical= */ false); /* don't use DNSSEC canonical format, since it removes casing, but we want that for DNS_SD compat */
                                if (r < 0)
                                        return r;
 
                                r = sd_json_variant_append_arraybo(
                                                &l,
                                                SD_JSON_BUILD_PAIR_VARIANT("rr", rj),
                                                SD_JSON_BUILD_PAIR_BASE64("raw", j->rr->wire_format, j->rr->wire_format_size));
                                if (r < 0)
                                        return r;
                        }
 
                        if (!l) {
                                r = sd_json_variant_new_array(&l, NULL, 0);
                                if (r < 0)
                                        return r;
                        }
 
                        r = sd_json_buildo(
                                        &d,
                                        SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                        SD_JSON_BUILD_PAIR_VARIANT("rrs", l),
                                        SD_JSON_BUILD_PAIR_UNSIGNED("until", i->until));
                } else if (i->type == DNS_CACHE_NODATA) {
                        r = sd_json_buildo(
                                        &d,
                                        SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                        SD_JSON_BUILD_PAIR_EMPTY_ARRAY("rrs"),
                                        SD_JSON_BUILD_PAIR_UNSIGNED("until", i->until));
                } else
                        r = sd_json_buildo(
                                        &d,
                                        SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                        SD_JSON_BUILD_PAIR_STRING("type", dns_cache_item_type_to_string(i)),
                                        SD_JSON_BUILD_PAIR_UNSIGNED("until", i->until));
                if (r < 0)
                        return r;
 
                r = sd_json_variant_append_array(&c, d);
                if (r < 0)
                        return r;
        }
 
        if (!c)
                return sd_json_variant_new_array(ret, NULL, 0);
 
        *ret = TAKE_PTR(c);
        return 0;
}
 
bool dns_cache_is_empty(DnsCache *cache) {
        if (!cache)
                return true;
 
        return hashmap_isempty(cache->by_key);
}
 
unsigned dns_cache_size(DnsCache *cache) {
        if (!cache)
                return 0;
 
        return hashmap_size(cache->by_key);
}