9df3ba6c6c
Rather than fixing this to 5s for unicast DNS and 1s for LLMNR, start at a tenth of those values and increase exponentially until the old values are reached. For LLMNR the recommended timeout for IEEE802 networks (which basically means all of the ones we care about) is 100ms, so that should be uncontroversial. For unicast DNS I have found no recommended value. However, it seems vastly more likely that hitting a 500ms timeout is casued by a packet loss, rather than the RTT genuinely being greater than 500ms, so taking this as a startnig value seems reasonable to me. In the common case this greatly reduces the latency due to normal packet loss. Moreover, once we get support for probing for features, this means that we can send more packets before degrading the feature level whilst still allowing us to settle on the correct feature level in a reasonable timeframe. The timeouts are tracked per server (or per scope for the multicast protocols), and once a server (or scope) receives a successfull package the timeout is reset. We also track the largest RTT for the given server/scope, and always start our timouts at twice the largest observed RTT.
165 lines
4.6 KiB
C
165 lines
4.6 KiB
C
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
|
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2014 Lennart Poettering
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#include "siphash24.h"
|
|
|
|
#include "resolved-dns-server.h"
|
|
|
|
/* After how much time to repeat classic DNS requests */
|
|
#define DNS_TIMEOUT_MIN_USEC (500 * USEC_PER_MSEC)
|
|
#define DNS_TIMEOUT_MAX_USEC (5 * USEC_PER_SEC)
|
|
|
|
int dns_server_new(
|
|
Manager *m,
|
|
DnsServer **ret,
|
|
DnsServerType type,
|
|
Link *l,
|
|
int family,
|
|
const union in_addr_union *in_addr) {
|
|
|
|
DnsServer *s, *tail;
|
|
|
|
assert(m);
|
|
assert((type == DNS_SERVER_LINK) == !!l);
|
|
assert(in_addr);
|
|
|
|
s = new0(DnsServer, 1);
|
|
if (!s)
|
|
return -ENOMEM;
|
|
|
|
s->n_ref = 1;
|
|
s->type = type;
|
|
s->family = family;
|
|
s->address = *in_addr;
|
|
s->resend_timeout = DNS_TIMEOUT_MIN_USEC;
|
|
|
|
if (type == DNS_SERVER_LINK) {
|
|
LIST_FIND_TAIL(servers, l->dns_servers, tail);
|
|
LIST_INSERT_AFTER(servers, l->dns_servers, tail, s);
|
|
s->link = l;
|
|
} else if (type == DNS_SERVER_SYSTEM) {
|
|
LIST_FIND_TAIL(servers, m->dns_servers, tail);
|
|
LIST_INSERT_AFTER(servers, m->dns_servers, tail, s);
|
|
} else if (type == DNS_SERVER_FALLBACK) {
|
|
LIST_FIND_TAIL(servers, m->fallback_dns_servers, tail);
|
|
LIST_INSERT_AFTER(servers, m->fallback_dns_servers, tail, s);
|
|
} else
|
|
assert_not_reached("Unknown server type");
|
|
|
|
s->manager = m;
|
|
|
|
/* A new DNS server that isn't fallback is added and the one
|
|
* we used so far was a fallback one? Then let's try to pick
|
|
* the new one */
|
|
if (type != DNS_SERVER_FALLBACK &&
|
|
m->current_dns_server &&
|
|
m->current_dns_server->type == DNS_SERVER_FALLBACK)
|
|
manager_set_dns_server(m, NULL);
|
|
|
|
if (ret)
|
|
*ret = s;
|
|
|
|
return 0;
|
|
}
|
|
|
|
DnsServer* dns_server_ref(DnsServer *s) {
|
|
if (!s)
|
|
return NULL;
|
|
|
|
assert(s->n_ref > 0);
|
|
|
|
s->n_ref ++;
|
|
|
|
return s;
|
|
}
|
|
|
|
static DnsServer* dns_server_free(DnsServer *s) {
|
|
if (!s)
|
|
return NULL;
|
|
|
|
if (s->link && s->link->current_dns_server == s)
|
|
link_set_dns_server(s->link, NULL);
|
|
|
|
if (s->manager && s->manager->current_dns_server == s)
|
|
manager_set_dns_server(s->manager, NULL);
|
|
|
|
free(s);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
DnsServer* dns_server_unref(DnsServer *s) {
|
|
if (!s)
|
|
return NULL;
|
|
|
|
assert(s->n_ref > 0);
|
|
|
|
if (s->n_ref == 1)
|
|
dns_server_free(s);
|
|
else
|
|
s->n_ref --;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void dns_server_packet_received(DnsServer *s, usec_t rtt) {
|
|
assert(s);
|
|
|
|
if (rtt > s->max_rtt) {
|
|
s->max_rtt = rtt;
|
|
s->resend_timeout = MIN(MAX(DNS_TIMEOUT_MIN_USEC, s->max_rtt * 2),
|
|
DNS_TIMEOUT_MAX_USEC);
|
|
}
|
|
}
|
|
|
|
void dns_server_packet_lost(DnsServer *s, usec_t usec) {
|
|
assert(s);
|
|
|
|
if (s->resend_timeout <= usec)
|
|
s->resend_timeout = MIN(s->resend_timeout * 2, DNS_TIMEOUT_MAX_USEC);
|
|
}
|
|
|
|
static unsigned long dns_server_hash_func(const void *p, const uint8_t hash_key[HASH_KEY_SIZE]) {
|
|
const DnsServer *s = p;
|
|
uint64_t u;
|
|
|
|
siphash24((uint8_t*) &u, &s->address, FAMILY_ADDRESS_SIZE(s->family), hash_key);
|
|
u = u * hash_key[0] + u + s->family;
|
|
|
|
return u;
|
|
}
|
|
|
|
static int dns_server_compare_func(const void *a, const void *b) {
|
|
const DnsServer *x = a, *y = b;
|
|
|
|
if (x->family < y->family)
|
|
return -1;
|
|
if (x->family > y->family)
|
|
return 1;
|
|
|
|
return memcmp(&x->address, &y->address, FAMILY_ADDRESS_SIZE(x->family));
|
|
}
|
|
|
|
const struct hash_ops dns_server_hash_ops = {
|
|
.hash = dns_server_hash_func,
|
|
.compare = dns_server_compare_func
|
|
};
|