/* dnsmasq is Copyright (c) 2000-2009 Simon Kelley
|
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; version 2 dated June, 1991, or
|
(at your option) version 3 dated 29 June, 2007.
|
|
This program 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 General Public License for more details.
|
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
|
#include "dnsmasq.h"
|
|
static struct crec *cache_head = NULL, *cache_tail = NULL, **hash_table = NULL;
|
#ifdef HAVE_DHCP
|
static struct crec* dhcp_spare = NULL;
|
#endif
|
static struct crec* new_chain = NULL;
|
static int cache_inserted = 0, cache_live_freed = 0, insert_error;
|
static union bigname* big_free = NULL;
|
static int bignames_left, hash_size;
|
static int uid = 0;
|
static char* addrbuff = NULL;
|
|
/* type->string mapping: this is also used by the name-hash function as a mixing table. */
|
static const struct {
|
unsigned int type;
|
const char* const name;
|
} typestr[] = {{1, "A"}, {2, "NS"}, {5, "CNAME"}, {6, "SOA"}, {10, "NULL"},
|
{11, "WKS"}, {12, "PTR"}, {13, "HINFO"}, {15, "MX"}, {16, "TXT"},
|
{22, "NSAP"}, {23, "NSAP_PTR"}, {24, "SIG"}, {25, "KEY"}, {28, "AAAA"},
|
{33, "SRV"}, {35, "NAPTR"}, {36, "KX"}, {37, "CERT"}, {38, "A6"},
|
{39, "DNAME"}, {41, "OPT"}, {48, "DNSKEY"}, {249, "TKEY"}, {250, "TSIG"},
|
{251, "IXFR"}, {252, "AXFR"}, {253, "MAILB"}, {254, "MAILA"}, {255, "ANY"}};
|
|
static void cache_free(struct crec* crecp);
|
static void cache_unlink(struct crec* crecp);
|
static void cache_link(struct crec* crecp);
|
static void rehash(int size);
|
static void cache_hash(struct crec* crecp);
|
|
void cache_init(void) {
|
struct crec* crecp;
|
int i;
|
|
if (daemon->options & OPT_LOG) addrbuff = safe_malloc(ADDRSTRLEN);
|
|
bignames_left = daemon->cachesize / 10;
|
|
if (daemon->cachesize > 0) {
|
crecp = safe_malloc(daemon->cachesize * sizeof(struct crec));
|
|
for (i = 0; i < daemon->cachesize; i++, crecp++) {
|
cache_link(crecp);
|
crecp->flags = 0;
|
crecp->uid = uid++;
|
}
|
}
|
|
/* create initial hash table*/
|
rehash(daemon->cachesize);
|
}
|
|
/* In most cases, we create the hash table once here by calling this with (hash_table == NULL)
|
but if the hosts file(s) are big (some people have 50000 ad-block entries), the table
|
will be much too small, so the hosts reading code calls rehash every 1000 addresses, to
|
expand the table. */
|
static void rehash(int size) {
|
struct crec** new, **old, *p, *tmp;
|
int i, new_size, old_size;
|
|
/* hash_size is a power of two. */
|
for (new_size = 64; new_size < size / 10; new_size = new_size << 1)
|
;
|
|
/* must succeed in getting first instance, failure later is non-fatal */
|
if (!hash_table)
|
new = safe_malloc(new_size * sizeof(struct crec*));
|
else if (new_size <= hash_size || !(new = whine_malloc(new_size * sizeof(struct crec*))))
|
return;
|
|
for (i = 0; i < new_size; i++) new[i] = NULL;
|
|
old = hash_table;
|
old_size = hash_size;
|
hash_table = new;
|
hash_size = new_size;
|
|
if (old) {
|
for (i = 0; i < old_size; i++)
|
for (p = old[i]; p; p = tmp) {
|
tmp = p->hash_next;
|
cache_hash(p);
|
}
|
free(old);
|
}
|
}
|
|
static struct crec** hash_bucket(char* name) {
|
unsigned int c, val = 017465; /* Barker code - minimum self-correlation in cyclic shift */
|
const unsigned char* mix_tab = (const unsigned char*) typestr;
|
|
while ((c = (unsigned char) *name++)) {
|
/* don't use tolower and friends here - they may be messed up by LOCALE */
|
if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
|
val = ((val << 7) | (val >> (32 - 7))) + (mix_tab[(val + c) & 0x3F] ^ c);
|
}
|
|
/* hash_size is a power of two */
|
return hash_table + ((val ^ (val >> 16)) & (hash_size - 1));
|
}
|
|
static void cache_hash(struct crec* crecp) {
|
/* maintain an invariant that all entries with F_REVERSE set
|
are at the start of the hash-chain and all non-reverse
|
immortal entries are at the end of the hash-chain.
|
This allows reverse searches and garbage collection to be optimised */
|
|
struct crec** up = hash_bucket(cache_get_name(crecp));
|
|
if (!(crecp->flags & F_REVERSE)) {
|
while (*up && ((*up)->flags & F_REVERSE)) up = &((*up)->hash_next);
|
|
if (crecp->flags & F_IMMORTAL)
|
while (*up && !((*up)->flags & F_IMMORTAL)) up = &((*up)->hash_next);
|
}
|
crecp->hash_next = *up;
|
*up = crecp;
|
}
|
|
static void cache_free(struct crec* crecp) {
|
crecp->flags &= ~F_FORWARD;
|
crecp->flags &= ~F_REVERSE;
|
crecp->uid = uid++; /* invalidate CNAMES pointing to this. */
|
|
if (cache_tail)
|
cache_tail->next = crecp;
|
else
|
cache_head = crecp;
|
crecp->prev = cache_tail;
|
crecp->next = NULL;
|
cache_tail = crecp;
|
|
/* retrieve big name for further use. */
|
if (crecp->flags & F_BIGNAME) {
|
crecp->name.bname->next = big_free;
|
big_free = crecp->name.bname;
|
crecp->flags &= ~F_BIGNAME;
|
}
|
}
|
|
/* insert a new cache entry at the head of the list (youngest entry) */
|
static void cache_link(struct crec* crecp) {
|
if (cache_head) /* check needed for init code */
|
cache_head->prev = crecp;
|
crecp->next = cache_head;
|
crecp->prev = NULL;
|
cache_head = crecp;
|
if (!cache_tail) cache_tail = crecp;
|
}
|
|
/* remove an arbitrary cache entry for promotion */
|
static void cache_unlink(struct crec* crecp) {
|
if (crecp->prev)
|
crecp->prev->next = crecp->next;
|
else
|
cache_head = crecp->next;
|
|
if (crecp->next)
|
crecp->next->prev = crecp->prev;
|
else
|
cache_tail = crecp->prev;
|
}
|
|
char* cache_get_name(struct crec* crecp) {
|
if (crecp->flags & F_BIGNAME)
|
return crecp->name.bname->name;
|
else if (crecp->flags & (F_DHCP | F_CONFIG))
|
return crecp->name.namep;
|
|
return crecp->name.sname;
|
}
|
|
static int is_outdated_cname_pointer(struct crec* crecp) {
|
if (!(crecp->flags & F_CNAME)) return 0;
|
|
if (crecp->addr.cname.cache && crecp->addr.cname.uid == crecp->addr.cname.cache->uid) return 0;
|
|
return 1;
|
}
|
|
static int is_expired(time_t now, struct crec* crecp) {
|
if (crecp->flags & F_IMMORTAL) return 0;
|
|
if (difftime(now, crecp->ttd) < 0) return 0;
|
|
return 1;
|
}
|
|
static int cache_scan_free(char* name, struct all_addr* addr, time_t now, unsigned short flags) {
|
/* Scan and remove old entries.
|
If (flags & F_FORWARD) then remove any forward entries for name and any expired
|
entries but only in the same hash bucket as name.
|
If (flags & F_REVERSE) then remove any reverse entries for addr and any expired
|
entries in the whole cache.
|
If (flags == 0) remove any expired entries in the whole cache.
|
|
In the flags & F_FORWARD case, the return code is valid, and returns zero if the
|
name exists in the cache as a HOSTS or DHCP entry (these are never deleted)
|
|
We take advantage of the fact that hash chains have stuff in the order
|
<reverse>,<other>,<immortal> so that when we hit an entry which isn't reverse and is
|
immortal, we're done. */
|
|
struct crec *crecp, **up;
|
|
if (flags & F_FORWARD) {
|
for (up = hash_bucket(name), crecp = *up; crecp; crecp = crecp->hash_next)
|
if (is_expired(now, crecp) || is_outdated_cname_pointer(crecp)) {
|
*up = crecp->hash_next;
|
if (!(crecp->flags & (F_HOSTS | F_DHCP))) {
|
cache_unlink(crecp);
|
cache_free(crecp);
|
}
|
} else if ((crecp->flags & F_FORWARD) &&
|
((flags & crecp->flags & (F_IPV4 | F_IPV6)) ||
|
((crecp->flags | flags) & F_CNAME)) &&
|
hostname_isequal(cache_get_name(crecp), name)) {
|
if (crecp->flags & (F_HOSTS | F_DHCP)) return 0;
|
*up = crecp->hash_next;
|
cache_unlink(crecp);
|
cache_free(crecp);
|
} else
|
up = &crecp->hash_next;
|
} else {
|
int i;
|
#ifdef HAVE_IPV6
|
int addrlen = (flags & F_IPV6) ? IN6ADDRSZ : INADDRSZ;
|
#else
|
int addrlen = INADDRSZ;
|
#endif
|
for (i = 0; i < hash_size; i++)
|
for (crecp = hash_table[i], up = &hash_table[i];
|
crecp && ((crecp->flags & F_REVERSE) || !(crecp->flags & F_IMMORTAL));
|
crecp = crecp->hash_next)
|
if (is_expired(now, crecp)) {
|
*up = crecp->hash_next;
|
if (!(crecp->flags & (F_HOSTS | F_DHCP))) {
|
cache_unlink(crecp);
|
cache_free(crecp);
|
}
|
} else if (!(crecp->flags & (F_HOSTS | F_DHCP)) &&
|
(flags & crecp->flags & F_REVERSE) &&
|
(flags & crecp->flags & (F_IPV4 | F_IPV6)) &&
|
memcmp(&crecp->addr.addr, addr, addrlen) == 0) {
|
*up = crecp->hash_next;
|
cache_unlink(crecp);
|
cache_free(crecp);
|
} else
|
up = &crecp->hash_next;
|
}
|
|
return 1;
|
}
|
|
/* Note: The normal calling sequence is
|
cache_start_insert
|
cache_insert * n
|
cache_end_insert
|
|
but an abort can cause the cache_end_insert to be missed
|
in which can the next cache_start_insert cleans things up. */
|
|
void cache_start_insert(void) {
|
/* Free any entries which didn't get committed during the last
|
insert due to error.
|
*/
|
while (new_chain) {
|
struct crec* tmp = new_chain->next;
|
cache_free(new_chain);
|
new_chain = tmp;
|
}
|
new_chain = NULL;
|
insert_error = 0;
|
}
|
|
struct crec* cache_insert(char* name, struct all_addr* addr, time_t now, unsigned long ttl,
|
unsigned short flags) {
|
struct crec* new;
|
union bigname* big_name = NULL;
|
int freed_all = flags & F_REVERSE;
|
int free_avail = 0;
|
|
log_query(flags | F_UPSTREAM, name, addr, NULL);
|
|
/* CONFIG bit means something else when stored in cache entries */
|
flags &= ~F_CONFIG;
|
|
/* if previous insertion failed give up now. */
|
if (insert_error) return NULL;
|
|
/* First remove any expired entries and entries for the name/address we
|
are currently inserting. Fail is we attempt to delete a name from
|
/etc/hosts or DHCP. */
|
if (!cache_scan_free(name, addr, now, flags)) {
|
insert_error = 1;
|
return NULL;
|
}
|
|
/* Now get a cache entry from the end of the LRU list */
|
while (1) {
|
if (!(new = cache_tail)) /* no entries left - cache is too small, bail */
|
{
|
insert_error = 1;
|
return NULL;
|
}
|
|
/* End of LRU list is still in use: if we didn't scan all the hash
|
chains for expired entries do that now. If we already tried that
|
then it's time to start spilling things. */
|
|
if (new->flags&(F_FORWARD | F_REVERSE)) {
|
/* If free_avail set, we believe that an entry has been freed.
|
Bugs have been known to make this not true, resulting in
|
a tight loop here. If that happens, abandon the
|
insert. Once in this state, all inserts will probably fail. */
|
if (free_avail) {
|
insert_error = 1;
|
return NULL;
|
}
|
|
if (freed_all) {
|
free_avail = 1; /* Must be free space now. */
|
cache_scan_free(cache_get_name(new), &new->addr.addr, now, new->flags);
|
cache_live_freed++;
|
} else {
|
cache_scan_free(NULL, NULL, now, 0);
|
freed_all = 1;
|
}
|
continue;
|
}
|
|
/* Check if we need to and can allocate extra memory for a long name.
|
If that fails, give up now. */
|
if (name && (strlen(name) > SMALLDNAME - 1)) {
|
if (big_free) {
|
big_name = big_free;
|
big_free = big_free->next;
|
} else if (!bignames_left ||
|
!(big_name = (union bigname*) whine_malloc(sizeof(union bigname)))) {
|
insert_error = 1;
|
return NULL;
|
} else
|
bignames_left--;
|
}
|
|
/* Got the rest: finally grab entry. */
|
cache_unlink(new);
|
break;
|
}
|
|
new->flags = flags;
|
if (big_name) {
|
new->name.bname = big_name;
|
new->flags |= F_BIGNAME;
|
}
|
|
if (name)
|
strcpy(cache_get_name(new), name);
|
else
|
*cache_get_name(new) = 0;
|
|
if (addr)
|
new->addr.addr = *addr;
|
else
|
new->addr.cname.cache = NULL;
|
|
new->ttd = now + (time_t) ttl;
|
new->next = new_chain;
|
new_chain = new;
|
|
return new;
|
}
|
|
/* after end of insertion, commit the new entries */
|
void cache_end_insert(void) {
|
if (insert_error) return;
|
|
while (new_chain) {
|
struct crec* tmp = new_chain->next;
|
/* drop CNAMEs which didn't find a target. */
|
if (is_outdated_cname_pointer(new_chain))
|
cache_free(new_chain);
|
else {
|
cache_hash(new_chain);
|
cache_link(new_chain);
|
cache_inserted++;
|
}
|
new_chain = tmp;
|
}
|
new_chain = NULL;
|
}
|
|
struct crec* cache_find_by_name(struct crec* crecp, char* name, time_t now, unsigned short prot) {
|
struct crec* ans;
|
|
if (crecp) /* iterating */
|
ans = crecp->next;
|
else {
|
/* first search, look for relevant entries and push to top of list
|
also free anything which has expired */
|
struct crec *next, **up, **insert = NULL, **chainp = &ans;
|
int ins_flags = 0;
|
|
for (up = hash_bucket(name), crecp = *up; crecp; crecp = next) {
|
next = crecp->hash_next;
|
|
if (!is_expired(now, crecp) && !is_outdated_cname_pointer(crecp)) {
|
if ((crecp->flags & F_FORWARD) && (crecp->flags & prot) &&
|
hostname_isequal(cache_get_name(crecp), name)) {
|
if (crecp->flags & (F_HOSTS | F_DHCP)) {
|
*chainp = crecp;
|
chainp = &crecp->next;
|
} else {
|
cache_unlink(crecp);
|
cache_link(crecp);
|
}
|
|
/* Move all but the first entry up the hash chain
|
this implements round-robin.
|
Make sure that re-ordering doesn't break the hash-chain
|
order invariants.
|
*/
|
if (insert && (crecp->flags & (F_REVERSE | F_IMMORTAL)) == ins_flags) {
|
*up = crecp->hash_next;
|
crecp->hash_next = *insert;
|
*insert = crecp;
|
insert = &crecp->hash_next;
|
} else {
|
if (!insert) {
|
insert = up;
|
ins_flags = crecp->flags & (F_REVERSE | F_IMMORTAL);
|
}
|
up = &crecp->hash_next;
|
}
|
} else
|
/* case : not expired, incorrect entry. */
|
up = &crecp->hash_next;
|
} else {
|
/* expired entry, free it */
|
*up = crecp->hash_next;
|
if (!(crecp->flags & (F_HOSTS | F_DHCP))) {
|
cache_unlink(crecp);
|
cache_free(crecp);
|
}
|
}
|
}
|
|
*chainp = cache_head;
|
}
|
|
if (ans && (ans->flags & F_FORWARD) && (ans->flags & prot) &&
|
hostname_isequal(cache_get_name(ans), name))
|
return ans;
|
|
return NULL;
|
}
|
|
struct crec* cache_find_by_addr(struct crec* crecp, struct all_addr* addr, time_t now,
|
unsigned short prot) {
|
struct crec* ans;
|
#ifdef HAVE_IPV6
|
int addrlen = (prot == F_IPV6) ? IN6ADDRSZ : INADDRSZ;
|
#else
|
int addrlen = INADDRSZ;
|
#endif
|
|
if (crecp) /* iterating */
|
ans = crecp->next;
|
else {
|
/* first search, look for relevant entries and push to top of list
|
also free anything which has expired. All the reverse entries are at the
|
start of the hash chain, so we can give up when we find the first
|
non-REVERSE one. */
|
int i;
|
struct crec **up, **chainp = &ans;
|
|
for (i = 0; i < hash_size; i++)
|
for (crecp = hash_table[i], up = &hash_table[i]; crecp && (crecp->flags & F_REVERSE);
|
crecp = crecp->hash_next)
|
if (!is_expired(now, crecp)) {
|
if ((crecp->flags & prot) && memcmp(&crecp->addr.addr, addr, addrlen) == 0) {
|
if (crecp->flags & (F_HOSTS | F_DHCP)) {
|
*chainp = crecp;
|
chainp = &crecp->next;
|
} else {
|
cache_unlink(crecp);
|
cache_link(crecp);
|
}
|
}
|
up = &crecp->hash_next;
|
} else {
|
*up = crecp->hash_next;
|
if (!(crecp->flags & (F_HOSTS | F_DHCP))) {
|
cache_unlink(crecp);
|
cache_free(crecp);
|
}
|
}
|
|
*chainp = cache_head;
|
}
|
|
if (ans && (ans->flags & F_REVERSE) && (ans->flags & prot) &&
|
memcmp(&ans->addr.addr, addr, addrlen) == 0)
|
return ans;
|
|
return NULL;
|
}
|
|
static void add_hosts_entry(struct crec* cache, struct all_addr* addr, int addrlen,
|
unsigned short flags, int index, int addr_dup) {
|
struct crec* lookup = cache_find_by_name(NULL, cache->name.sname, 0, flags & (F_IPV4 | F_IPV6));
|
int i, nameexists = 0;
|
struct cname* a;
|
|
/* Remove duplicates in hosts files. */
|
if (lookup && (lookup->flags & F_HOSTS)) {
|
nameexists = 1;
|
if (memcmp(&lookup->addr.addr, addr, addrlen) == 0) {
|
free(cache);
|
return;
|
}
|
}
|
|
/* Ensure there is only one address -> name mapping (first one trumps)
|
We do this by steam here, first we see if the address is the same as
|
the last one we saw, which eliminates most in the case of an ad-block
|
file with thousands of entries for the same address.
|
Then we search and bail at the first matching address that came from
|
a HOSTS file. Since the first host entry gets reverse, we know
|
then that it must exist without searching exhaustively for it. */
|
|
if (addr_dup)
|
flags &= ~F_REVERSE;
|
else
|
for (i = 0; i < hash_size; i++) {
|
for (lookup = hash_table[i]; lookup; lookup = lookup->hash_next)
|
if ((lookup->flags & F_HOSTS) && (lookup->flags & flags & (F_IPV4 | F_IPV6)) &&
|
memcmp(&lookup->addr.addr, addr, addrlen) == 0) {
|
flags &= ~F_REVERSE;
|
break;
|
}
|
if (lookup) break;
|
}
|
|
cache->flags = flags;
|
cache->uid = index;
|
memcpy(&cache->addr.addr, addr, addrlen);
|
cache_hash(cache);
|
|
/* don't need to do alias stuff for second and subsequent addresses. */
|
if (!nameexists)
|
for (a = daemon->cnames; a; a = a->next)
|
if (hostname_isequal(cache->name.sname, a->target) &&
|
(lookup = whine_malloc(sizeof(struct crec)))) {
|
lookup->flags = F_FORWARD | F_IMMORTAL | F_CONFIG | F_HOSTS | F_CNAME;
|
lookup->name.namep = a->alias;
|
lookup->addr.cname.cache = cache;
|
lookup->addr.cname.uid = index;
|
cache_hash(lookup);
|
}
|
}
|
|
static int eatspace(FILE* f) {
|
int c, nl = 0;
|
|
while (1) {
|
if ((c = getc(f)) == '#')
|
while (c != '\n' && c != EOF) c = getc(f);
|
|
if (c == EOF) return 1;
|
|
if (!isspace(c)) {
|
ungetc(c, f);
|
return nl;
|
}
|
|
if (c == '\n') nl = 1;
|
}
|
}
|
|
static int gettok(FILE* f, char* token) {
|
int c, count = 0;
|
|
while (1) {
|
if ((c = getc(f)) == EOF) return (count == 0) ? EOF : 1;
|
|
if (isspace(c) || c == '#') {
|
ungetc(c, f);
|
return eatspace(f);
|
}
|
|
if (count < (MAXDNAME - 1)) {
|
token[count++] = c;
|
token[count] = 0;
|
}
|
}
|
}
|
|
static int read_hostsfile(char* filename, int index, int cache_size) {
|
FILE* f = fopen(filename, "r");
|
char *token = daemon->namebuff, *domain_suffix = NULL;
|
int addr_count = 0, name_count = cache_size, lineno = 0;
|
unsigned short flags = 0, saved_flags = 0;
|
struct all_addr addr, saved_addr;
|
int atnl, addrlen = 0, addr_dup;
|
|
if (!f) {
|
my_syslog(LOG_ERR, _("failed to load names from %s: %s"), filename, strerror(errno));
|
return 0;
|
}
|
|
eatspace(f);
|
|
while ((atnl = gettok(f, token)) != EOF) {
|
addr_dup = 0;
|
lineno++;
|
|
#ifdef HAVE_IPV6
|
if (inet_pton(AF_INET, token, &addr) > 0) {
|
flags = F_HOSTS | F_IMMORTAL | F_FORWARD | F_REVERSE | F_IPV4;
|
addrlen = INADDRSZ;
|
domain_suffix = get_domain(addr.addr.addr4);
|
} else if (inet_pton(AF_INET6, token, &addr) > 0) {
|
flags = F_HOSTS | F_IMMORTAL | F_FORWARD | F_REVERSE | F_IPV6;
|
addrlen = IN6ADDRSZ;
|
domain_suffix = daemon->domain_suffix;
|
}
|
#else
|
if ((addr.addr.addr4.s_addr = inet_addr(token)) != (in_addr_t) -1) {
|
flags = F_HOSTS | F_IMMORTAL | F_FORWARD | F_REVERSE | F_IPV4;
|
addrlen = INADDRSZ;
|
domain_suffix = get_domain(addr.addr.addr4);
|
}
|
#endif
|
else {
|
my_syslog(LOG_ERR, _("bad address at %s line %d"), filename, lineno);
|
while (atnl == 0) atnl = gettok(f, token);
|
continue;
|
}
|
|
if (saved_flags == flags && memcmp(&addr, &saved_addr, addrlen) == 0)
|
addr_dup = 1;
|
else {
|
saved_flags = flags;
|
saved_addr = addr;
|
}
|
|
addr_count++;
|
|
/* rehash every 1000 names. */
|
if ((name_count - cache_size) > 1000) {
|
rehash(name_count);
|
cache_size = name_count;
|
}
|
|
while (atnl == 0) {
|
struct crec* cache;
|
int fqdn, nomem;
|
char* canon;
|
|
if ((atnl = gettok(f, token)) == EOF) break;
|
|
fqdn = !!strchr(token, '.');
|
|
if ((canon = canonicalise(token, &nomem))) {
|
/* If set, add a version of the name with a default domain appended */
|
if ((daemon->options & OPT_EXPAND) && domain_suffix && !fqdn &&
|
(cache = whine_malloc(sizeof(struct crec) + strlen(canon) + 2 +
|
strlen(domain_suffix) - SMALLDNAME))) {
|
strcpy(cache->name.sname, canon);
|
strcat(cache->name.sname, ".");
|
strcat(cache->name.sname, domain_suffix);
|
add_hosts_entry(cache, &addr, addrlen, flags, index, addr_dup);
|
addr_dup = 1;
|
name_count++;
|
}
|
if ((cache = whine_malloc(sizeof(struct crec) + strlen(canon) + 1 - SMALLDNAME))) {
|
strcpy(cache->name.sname, canon);
|
add_hosts_entry(cache, &addr, addrlen, flags, index, addr_dup);
|
name_count++;
|
}
|
free(canon);
|
|
} else if (!nomem)
|
my_syslog(LOG_ERR, _("bad name at %s line %d"), filename, lineno);
|
}
|
}
|
|
fclose(f);
|
rehash(name_count);
|
|
my_syslog(LOG_INFO, _("read %s - %d addresses"), filename, addr_count);
|
|
return name_count;
|
}
|
|
void cache_reload(void) {
|
struct crec *cache, **up, *tmp;
|
int i, total_size = daemon->cachesize;
|
struct hostsfile* ah;
|
|
cache_inserted = cache_live_freed = 0;
|
|
for (i = 0; i < hash_size; i++)
|
for (cache = hash_table[i], up = &hash_table[i]; cache; cache = tmp) {
|
tmp = cache->hash_next;
|
if (cache->flags & F_HOSTS) {
|
*up = cache->hash_next;
|
free(cache);
|
} else if (!(cache->flags & F_DHCP)) {
|
*up = cache->hash_next;
|
if (cache->flags & F_BIGNAME) {
|
cache->name.bname->next = big_free;
|
big_free = cache->name.bname;
|
}
|
cache->flags = 0;
|
} else
|
up = &cache->hash_next;
|
}
|
|
if ((daemon->options & OPT_NO_HOSTS) && !daemon->addn_hosts) {
|
if (daemon->cachesize > 0) my_syslog(LOG_INFO, _("cleared cache"));
|
return;
|
}
|
|
if (!(daemon->options & OPT_NO_HOSTS)) total_size = read_hostsfile(HOSTSFILE, 0, total_size);
|
|
for (i = 0, ah = daemon->addn_hosts; ah; ah = ah->next) {
|
if (i <= ah->index) i = ah->index + 1;
|
|
if (ah->flags & AH_DIR)
|
ah->flags |= AH_INACTIVE;
|
else
|
ah->flags &= ~AH_INACTIVE;
|
}
|
|
for (ah = daemon->addn_hosts; ah; ah = ah->next)
|
if (!(ah->flags & AH_INACTIVE)) {
|
struct stat buf;
|
if (stat(ah->fname, &buf) != -1 && S_ISDIR(buf.st_mode)) {
|
DIR* dir_stream;
|
struct dirent* ent;
|
|
/* don't read this as a file */
|
ah->flags |= AH_INACTIVE;
|
|
if (!(dir_stream = opendir(ah->fname)))
|
my_syslog(LOG_ERR, _("cannot access directory %s: %s"), ah->fname,
|
strerror(errno));
|
else {
|
while ((ent = readdir(dir_stream))) {
|
size_t lendir = strlen(ah->fname);
|
size_t lenfile = strlen(ent->d_name);
|
struct hostsfile* ah1;
|
char* path;
|
|
/* ignore emacs backups and dotfiles */
|
if (lenfile == 0 || ent->d_name[lenfile - 1] == '~' ||
|
(ent->d_name[0] == '#' && ent->d_name[lenfile - 1] == '#') ||
|
ent->d_name[0] == '.')
|
continue;
|
|
/* see if we have an existing record.
|
dir is ah->fname
|
file is ent->d_name
|
path to match is ah1->fname */
|
|
for (ah1 = daemon->addn_hosts; ah1; ah1 = ah1->next) {
|
if (lendir < strlen(ah1->fname) &&
|
strstr(ah1->fname, ah->fname) == ah1->fname &&
|
ah1->fname[lendir] == '/' &&
|
strcmp(ah1->fname + lendir + 1, ent->d_name) == 0) {
|
ah1->flags &= ~AH_INACTIVE;
|
break;
|
}
|
}
|
|
/* make new record */
|
if (!ah1) {
|
if (!(ah1 = whine_malloc(sizeof(struct hostsfile)))) continue;
|
|
if (!(path = whine_malloc(lendir + lenfile + 2))) {
|
free(ah1);
|
continue;
|
}
|
|
strcpy(path, ah->fname);
|
strcat(path, "/");
|
strcat(path, ent->d_name);
|
ah1->fname = path;
|
ah1->index = i++;
|
ah1->flags = AH_DIR;
|
ah1->next = daemon->addn_hosts;
|
daemon->addn_hosts = ah1;
|
}
|
|
/* inactivate record if not regular file */
|
if ((ah1->flags & AH_DIR) && stat(ah1->fname, &buf) != -1 &&
|
!S_ISREG(buf.st_mode))
|
ah1->flags |= AH_INACTIVE;
|
}
|
closedir(dir_stream);
|
}
|
}
|
}
|
|
for (ah = daemon->addn_hosts; ah; ah = ah->next)
|
if (!(ah->flags & AH_INACTIVE))
|
total_size = read_hostsfile(ah->fname, ah->index, total_size);
|
}
|
|
char* get_domain(struct in_addr addr) {
|
struct cond_domain* c;
|
|
for (c = daemon->cond_domain; c; c = c->next)
|
if (ntohl(addr.s_addr) >= ntohl(c->start.s_addr) &&
|
ntohl(addr.s_addr) <= ntohl(c->end.s_addr))
|
return c->domain;
|
|
return daemon->domain_suffix;
|
}
|
|
#ifdef HAVE_DHCP
|
void cache_unhash_dhcp(void) {
|
struct crec *cache, **up;
|
int i;
|
|
for (i = 0; i < hash_size; i++)
|
for (cache = hash_table[i], up = &hash_table[i]; cache; cache = cache->hash_next)
|
if (cache->flags & F_DHCP) {
|
*up = cache->hash_next;
|
cache->next = dhcp_spare;
|
dhcp_spare = cache;
|
} else
|
up = &cache->hash_next;
|
}
|
|
void cache_add_dhcp_entry(char* host_name, struct in_addr* host_address, time_t ttd) {
|
struct crec *crec = NULL, *aliasc;
|
unsigned short flags = F_DHCP | F_FORWARD | F_IPV4 | F_REVERSE;
|
int in_hosts = 0;
|
struct cname* a;
|
|
while ((crec = cache_find_by_name(crec, host_name, 0, F_IPV4 | F_CNAME))) {
|
/* check all addresses associated with name */
|
if (crec->flags & F_HOSTS) {
|
if (crec->addr.addr.addr.addr4.s_addr != host_address->s_addr) {
|
strcpy(daemon->namebuff, inet_ntoa(crec->addr.addr.addr.addr4));
|
my_syslog(LOG_WARNING,
|
_("not giving name %s to the DHCP lease of %s because "
|
"the name exists in %s with address %s"),
|
host_name, inet_ntoa(*host_address), record_source(crec->uid),
|
daemon->namebuff);
|
return;
|
} else
|
/* if in hosts, don't need DHCP record */
|
in_hosts = 1;
|
} else if (!(crec->flags & F_DHCP)) {
|
cache_scan_free(host_name, NULL, 0, crec->flags & (F_IPV4 | F_CNAME | F_FORWARD));
|
/* scan_free deletes all addresses associated with name */
|
break;
|
}
|
}
|
|
if (in_hosts) return;
|
|
if ((crec = cache_find_by_addr(NULL, (struct all_addr*) host_address, 0, F_IPV4))) {
|
if (crec->flags & F_NEG)
|
cache_scan_free(NULL, (struct all_addr*) host_address, 0, F_IPV4 | F_REVERSE);
|
else
|
/* avoid multiple reverse mappings */
|
flags &= ~F_REVERSE;
|
}
|
|
if ((crec = dhcp_spare))
|
dhcp_spare = dhcp_spare->next;
|
else /* need new one */
|
crec = whine_malloc(sizeof(struct crec));
|
|
if (crec) /* malloc may fail */
|
{
|
crec->flags = flags;
|
if (ttd == 0)
|
crec->flags |= F_IMMORTAL;
|
else
|
crec->ttd = ttd;
|
crec->addr.addr.addr.addr4 = *host_address;
|
crec->name.namep = host_name;
|
crec->uid = uid++;
|
cache_hash(crec);
|
|
for (a = daemon->cnames; a; a = a->next)
|
if (hostname_isequal(host_name, a->target)) {
|
if ((aliasc = dhcp_spare))
|
dhcp_spare = dhcp_spare->next;
|
else /* need new one */
|
aliasc = whine_malloc(sizeof(struct crec));
|
|
if (aliasc) {
|
aliasc->flags = F_FORWARD | F_CONFIG | F_DHCP | F_CNAME;
|
if (ttd == 0)
|
aliasc->flags |= F_IMMORTAL;
|
else
|
aliasc->ttd = ttd;
|
aliasc->name.namep = a->alias;
|
aliasc->addr.cname.cache = crec;
|
aliasc->addr.cname.uid = crec->uid;
|
cache_hash(aliasc);
|
}
|
}
|
}
|
}
|
#endif
|
|
void dump_cache(time_t now) {
|
struct server *serv, *serv1;
|
|
my_syslog(LOG_INFO, _("time %lu"), (unsigned long) now);
|
my_syslog(LOG_INFO, _("cache size %d, %d/%d cache insertions re-used unexpired cache entries."),
|
daemon->cachesize, cache_live_freed, cache_inserted);
|
my_syslog(LOG_INFO, _("queries forwarded %u, queries answered locally %u"),
|
daemon->queries_forwarded, daemon->local_answer);
|
|
if (!addrbuff && !(addrbuff = whine_malloc(ADDRSTRLEN))) return;
|
|
/* sum counts from different records for same server */
|
for (serv = daemon->servers; serv; serv = serv->next) serv->flags &= ~SERV_COUNTED;
|
|
for (serv = daemon->servers; serv; serv = serv->next)
|
if (!(serv->flags & (SERV_NO_ADDR | SERV_LITERAL_ADDRESS | SERV_COUNTED))) {
|
int port;
|
unsigned int queries = 0, failed_queries = 0;
|
for (serv1 = serv; serv1; serv1 = serv1->next)
|
if (!(serv1->flags & (SERV_NO_ADDR | SERV_LITERAL_ADDRESS | SERV_COUNTED)) &&
|
sockaddr_isequal(&serv->addr, &serv1->addr)) {
|
serv1->flags |= SERV_COUNTED;
|
queries += serv1->queries;
|
failed_queries += serv1->failed_queries;
|
}
|
port = prettyprint_addr(&serv->addr, addrbuff);
|
my_syslog(LOG_INFO, _("server %s#%d: queries sent %u, retried or failed %u"), addrbuff,
|
port, queries, failed_queries);
|
}
|
|
if ((daemon->options & (OPT_DEBUG | OPT_LOG))) {
|
struct crec* cache;
|
int i;
|
my_syslog(LOG_DEBUG,
|
"Host Address Flags "
|
" Expires");
|
|
for (i = 0; i < hash_size; i++)
|
for (cache = hash_table[i]; cache; cache = cache->hash_next) {
|
char *a, *p = daemon->namebuff;
|
p += sprintf(p, "%-40.40s ", cache_get_name(cache));
|
if ((cache->flags & F_NEG) && (cache->flags & F_FORWARD))
|
a = "";
|
else if (cache->flags & F_CNAME) {
|
a = "";
|
if (!is_outdated_cname_pointer(cache))
|
a = cache_get_name(cache->addr.cname.cache);
|
}
|
#ifdef HAVE_IPV6
|
else {
|
a = addrbuff;
|
if (cache->flags & F_IPV4)
|
inet_ntop(AF_INET, &cache->addr.addr, addrbuff, ADDRSTRLEN);
|
else if (cache->flags & F_IPV6)
|
inet_ntop(AF_INET6, &cache->addr.addr, addrbuff, ADDRSTRLEN);
|
}
|
#else
|
else
|
a = inet_ntoa(cache->addr.addr.addr.addr4);
|
#endif
|
p += sprintf(
|
p, "%-30.30s %s%s%s%s%s%s%s%s%s%s ", a, cache->flags & F_IPV4 ? "4" : "",
|
cache->flags & F_IPV6 ? "6" : "", cache->flags & F_CNAME ? "C" : "",
|
cache->flags & F_FORWARD ? "F" : " ", cache->flags & F_REVERSE ? "R" : " ",
|
cache->flags & F_IMMORTAL ? "I" : " ", cache->flags & F_DHCP ? "D" : " ",
|
cache->flags & F_NEG ? "N" : " ", cache->flags & F_NXDOMAIN ? "X" : " ",
|
cache->flags & F_HOSTS ? "H" : " ");
|
#ifdef HAVE_BROKEN_RTC
|
p += sprintf(p, "%lu",
|
cache->flags & F_IMMORTAL ? 0 : (unsigned long) (cache->ttd - now));
|
#else
|
p += sprintf(p, "%s", cache->flags & F_IMMORTAL ? "\n" : ctime(&(cache->ttd)));
|
/* ctime includes trailing \n - eat it */
|
*(p - 1) = 0;
|
#endif
|
my_syslog(LOG_DEBUG, daemon->namebuff);
|
}
|
}
|
}
|
|
char* record_source(int index) {
|
struct hostsfile* ah;
|
|
if (index == 0) return HOSTSFILE;
|
|
for (ah = daemon->addn_hosts; ah; ah = ah->next)
|
if (ah->index == index) return ah->fname;
|
|
return "<unknown>";
|
}
|
|
void querystr(char* str, unsigned short type) {
|
unsigned int i;
|
|
sprintf(str, "query[type=%d]", type);
|
for (i = 0; i < (sizeof(typestr) / sizeof(typestr[0])); i++)
|
if (typestr[i].type == type) sprintf(str, "query[%s]", typestr[i].name);
|
}
|
|
void log_query(unsigned short flags, char* name, struct all_addr* addr, char* arg) {
|
char *source, *dest = addrbuff;
|
char* verb = "is";
|
|
if (!(daemon->options & OPT_LOG)) return;
|
|
if (addr) {
|
#ifdef HAVE_IPV6
|
/* TODO: support scoped addresses. struct all_addr doesn't store scope IDs. */
|
inet_ntop(flags & F_IPV4 ? AF_INET : AF_INET6, addr, addrbuff, ADDRSTRLEN);
|
#else
|
strncpy(addrbuff, inet_ntoa(addr->addr.addr4), ADDRSTRLEN);
|
#endif
|
}
|
|
if (flags & F_REVERSE) {
|
dest = name;
|
name = addrbuff;
|
}
|
|
if (flags & F_NEG) {
|
if (flags & F_NXDOMAIN) {
|
if (flags & F_IPV4)
|
dest = "NXDOMAIN-IPv4";
|
else if (flags & F_IPV6)
|
dest = "NXDOMAIN-IPv6";
|
else
|
dest = "NXDOMAIN";
|
} else {
|
if (flags & F_IPV4)
|
dest = "NODATA-IPv4";
|
else if (flags & F_IPV6)
|
dest = "NODATA-IPv6";
|
else
|
dest = "NODATA";
|
}
|
} else if (flags & F_CNAME) {
|
/* nasty abuse of NXDOMAIN and CNAME flags */
|
if (flags & F_NXDOMAIN)
|
dest = arg;
|
else
|
dest = "<CNAME>";
|
}
|
|
if (flags & F_CONFIG)
|
source = "config";
|
else if (flags & F_DHCP)
|
source = "DHCP";
|
else if (flags & F_HOSTS)
|
source = arg;
|
else if (flags & F_UPSTREAM)
|
source = "reply";
|
else if (flags & F_SERVER) {
|
source = "forwarded";
|
verb = "to";
|
} else if (flags & F_QUERY) {
|
source = arg;
|
verb = "from";
|
} else
|
source = "cached";
|
|
if (strlen(name) == 0) name = ".";
|
|
my_syslog(LOG_DEBUG, "%s %s %s %s", source, name, verb, dest);
|
}
|
