| From: Pranav Batra <batrapranav@chromium.org> |
| Subject: Cache mDNS host name records (IPv4, record A) for 12-24 hours after expiration. |
| |
| By default, the address record for a .local mDNS domain name is removed from the cache after 2 minutes. |
| When resolving a host name, if the address record is not found in the cache, avahi attempts to query the |
| network for the record. If a response is not received within 5 seconds (see TIMEOUT_MSEC in |
| avahi-core/resolve_service.c), avahi will return an error. |
| |
| With this patch, instead of returning an error, avahi will attempt to query a backup resource record |
| cache that holds IPv4 address records (A) for an additional 12-24 hours and if a record is found, |
| return that record instead of an error. |
| |
| Note that as the code block that adds entries to the cache and the code block that queries the cache |
| both run under the same process id and thread id, no mutex is necessary. |
| |
| Also note that avahi is configured with IPv6 support disabled, so there is no need |
| to store AAAA records in the backup resource record cache. |
| --- a/avahi-core/browse.h |
| +++ b/avahi-core/browse.h |
| @@ -20,6 +20,8 @@ |
| USA. |
| ***/ |
| |
| +#include <time.h> |
| + |
| #include <avahi-common/llist.h> |
| |
| #include "core.h" |
| @@ -28,6 +30,17 @@ |
| #include "dns.h" |
| #include "lookup.h" |
| |
| +extern AvahiHashmap *host_cache_archive; |
| +extern AvahiHashmap *host_cache_current; |
| +extern AvahiIfIndex host_interface; |
| + |
| +typedef struct HostCacheRecord HostCacheRecord; |
| + |
| +struct HostCacheRecord { |
| + AvahiRecord *record; |
| + time_t time; |
| +}; |
| + |
| typedef struct AvahiSRBLookup AvahiSRBLookup; |
| |
| struct AvahiSRecordBrowser { |
| --- a/avahi-core/resolve-host-name.c |
| +++ b/avahi-core/resolve-host-name.c |
| @@ -84,17 +84,59 @@ static void finish(AvahiSHostNameResolver *r, AvahiResolverEvent event) { |
| } |
| char addr[AVAHI_ADDRESS_STR_MAX]; |
| avahi_address_snprint(addr, sizeof(addr), &a); |
| - avahi_log_info("Resolved hostname %s: %s", r->host_name, addr); |
| - |
| + avahi_log_info("Resolved hostname %s (%s): %s (interface %d, protocol %d, flags %d, IPv4 %s, IPv6 %s, ttl %d)", |
| + r->host_name, |
| + r->address_record->key->name, |
| + addr, |
| + r->interface, |
| + r->protocol, |
| + r->flags, |
| + r->record_browser_a?"yes":"no", |
| + r->record_browser_aaaa?"yes":"no", |
| + r->address_record->ttl); |
| r->callback(r, r->interface, r->protocol, AVAHI_RESOLVER_FOUND, r->address_record->key->name, &a, r->flags, r->userdata); |
| break; |
| |
| } |
| |
| - case AVAHI_RESOLVER_FAILURE: |
| - avahi_log_warn("Failed to resolve hostname %s", r->host_name); |
| - r->callback(r, r->interface, r->protocol, event, r->host_name, NULL, r->flags, r->userdata); |
| + case AVAHI_RESOLVER_FAILURE: { |
| + HostCacheRecord *record = NULL; |
| + if (host_cache_current) |
| + record = avahi_hashmap_lookup(host_cache_current, r->host_name); |
| + if (!record && host_cache_archive) |
| + record = avahi_hashmap_lookup(host_cache_archive, r->host_name); |
| + if (!record || |
| + !r->record_browser_a || |
| + (r->protocol != AVAHI_PROTO_INET && r->protocol != AVAHI_PROTO_UNSPEC) || |
| + r->address_record) { |
| + // Although avahi is configured to only use the IPv4 mDNS broadcast address (224.0.0.251), |
| + // it turns out IPv6 host address records (AAAA) can be sent via IPv4. |
| + // r->protocol is based on the mDNS broadcast address used and will generally always be |
| + // -1 (any protocol) or 0 (IPv4; AVAHI_PROTO_INET). |
| + // If an IPv4 address is requested (avahi-resolve-host-name -4), r->record_browser_a will be initialized. |
| + // If an IPv6 address is requested (avahi-resolve-host-name -6), r->record_browser_aaaa will be initialized. |
| + // Both data structures will be initialized if the address type aprotocol is unspecified. |
| + avahi_log_warn("Failed to resolve hostname %s (interface %d, protocol %d, flags %d, IPv4 %s, IPv6 %s)", |
| + r->host_name, |
| + r->interface, |
| + r->protocol, |
| + r->flags, |
| + r->record_browser_a?"yes":"no", |
| + r->record_browser_aaaa?"yes":"no"); |
| + if (r->address_record) |
| + avahi_log_error("Assertion failed: !r->address_record"); |
| + r->callback(r, r->interface, r->protocol, event, r->host_name, NULL, r->flags, r->userdata); |
| + break; |
| + } |
| + avahi_log_warn("Using stale mDNS A record for %s (%d seconds old)", r->host_name, time(NULL) - record->time); |
| + r->flags = AVAHI_LOOKUP_RESULT_CACHED | AVAHI_LOOKUP_RESULT_MULTICAST; // 5 |
| + r->protocol = AVAHI_PROTO_INET; |
| + if (r->interface <= 0) |
| + r->interface = host_interface; |
| + r->address_record = avahi_record_ref(record->record); |
| + finish(r, AVAHI_RESOLVER_FOUND); |
| break; |
| + } |
| } |
| } |
| |
| --- a/avahi-core/server.c |
| +++ b/avahi-core/server.c |
| @@ -26,12 +26,14 @@ |
| #include <netinet/in.h> |
| #include <arpa/inet.h> |
| #include <string.h> |
| +#include <strings.h> |
| #include <sys/utsname.h> |
| #include <unistd.h> |
| #include <errno.h> |
| #include <stdio.h> |
| #include <assert.h> |
| #include <stdlib.h> |
| +#include <ctype.h> |
| |
| #include <avahi-common/domain.h> |
| #include <avahi-common/timeval.h> |
| @@ -51,6 +53,11 @@ |
| |
| #define AVAHI_DEFAULT_CACHE_ENTRIES_MAX 4096 |
| |
| +AvahiHashmap *host_cache_archive = NULL; |
| +AvahiHashmap *host_cache_current = NULL; |
| +AvahiIfIndex host_interface = AVAHI_IF_UNSPEC; |
| +time_t host_time = 0; |
| + |
| static void enum_aux_records(AvahiServer *s, AvahiInterface *i, const char *name, uint16_t type, void (*callback)(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata), void* userdata) { |
| assert(s); |
| assert(i); |
| @@ -655,6 +662,45 @@ fail: |
| avahi_record_list_flush(s->record_list); |
| } |
| |
| +static unsigned string_case_hash(const void *data) { |
| + const char *p = data; |
| + unsigned hash = 0; |
| + |
| + assert(p); |
| + |
| + for (; *p; p++) |
| + hash = 31 * hash + tolower(*p); |
| + |
| + return hash; |
| +} |
| + |
| +static int string_case_equal(const void *a, const void *b) { |
| + const char *p = a, *q = b; |
| + |
| + assert(p); |
| + assert(q); |
| + |
| + return strcasecmp(p, q) == 0; |
| +} |
| + |
| +static void free_host_record(void* p) { |
| + HostCacheRecord *r = p; |
| + assert(r); |
| + avahi_record_unref(r->record); |
| + avahi_free(r); |
| +} |
| + |
| +static AvahiHashmap *new_host_hashmap() { |
| + return avahi_hashmap_new(string_case_hash, string_case_equal, avahi_free, free_host_record); |
| +} |
| + |
| +static HostCacheRecord *new_host_record(AvahiRecord *r, time_t t) { |
| + HostCacheRecord *record = avahi_new(HostCacheRecord, 1); |
| + record->record = avahi_record_ref(r); |
| + record->time = t; |
| + return record; |
| +} |
| + |
| static void handle_response_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, int from_local_iface) { |
| unsigned n; |
| |
| @@ -680,6 +726,23 @@ static void handle_response_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInter |
| reflect_response(s, i, record, cache_flush); |
| avahi_cache_update(i->cache, record, cache_flush, a); |
| avahi_response_scheduler_incoming(i->response_scheduler, record, cache_flush); |
| + if (record->key->type == AVAHI_DNS_TYPE_A) { |
| + host_interface = i->hardware->index; |
| + // This is always called before we resolve an address if we've seen valid records. |
| + if (!host_cache_archive) |
| + host_cache_archive = new_host_hashmap(); |
| + if (!host_cache_current) |
| + host_cache_current = new_host_hashmap(); |
| + time_t current_time = time(NULL); |
| + if (current_time > host_time + 12*3600) { // Rotate the cache every 12 hours. |
| + host_time = current_time; |
| + avahi_hashmap_free(host_cache_archive); |
| + host_cache_archive = host_cache_current; |
| + host_cache_current = new_host_hashmap(); |
| + } |
| + avahi_hashmap_remove(host_cache_archive, record->key->name); |
| + avahi_hashmap_replace(host_cache_current, avahi_strdup(record->key->name), new_host_record(record, current_time)); |
| + } |
| } |
| } |
| |
