generic-library/bionic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
bionic/libc/netbsd/resolv/res_cache.c
The Android Open Source Project a27d2baa0c Initial Contribution
2008-10-21 07:00:00 -07:00

534 lines
15 KiB
C
Raw Blame History

/*
* Copyright (C) 2008 The Android Open Source Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "resolv_cache.h"
#include <stdlib.h>
#include <time.h>
#include "pthread.h"
/* this code implements a small DNS resolver cache for all gethostbyname* functions
*
* the cache is shared between all threads of the current process, but the result of
* a succesful lookup is always copied to a thread-local variable to honor the persistence
* rules of the gethostbyname*() APIs.
*/
/* the name of an environment variable that will be checked the first time this code is called
* if its value is "0", then the resolver cache is disabled.
*/
#define CONFIG_ENV "BIONIC_DNSCACHE"
/* entries older than CONFIG_SECONDS seconds are always discarded. otherwise we could keep
* stale addresses in the cache and be oblivious to DNS server changes
*/
#define CONFIG_SECONDS (60*10) /* 10 minutes */
/* maximum number of entries kept in the cache. be frugal, this is the C library
* this MUST BE A POWER OF 2
*/
#define CONFIG_MAX_ENTRIES 128
/****************************************************************************/
/****************************************************************************/
/***** *****/
/***** *****/
/***** *****/
/****************************************************************************/
/****************************************************************************/
#define DEBUG 0
#if DEBUG
#include <fcntl.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
static void
xlog( const char* fmt, ... )
{
static int fd = -2;
int ret;
if (fd == -2) {
do {
fd = open( "/data/dns.log", O_CREAT | O_APPEND | O_WRONLY, 0666 );
} while (fd < 0 && errno == EINTR);
}
if (fd >= 0) {
char temp[128];
va_list args;
va_start(args, fmt);
vsnprintf( temp, sizeof(temp), fmt, args);
va_end(args);
do {
ret = write( fd, temp, strlen(temp) );
} while (ret == -1 && errno == EINTR);
}
}
#define XLOG(...) xlog(__VA_ARGS__)
#else
#define XLOG(...) ((void)0)
#endif
static time_t
_time_now( void )
{
struct timeval tv;
gettimeofday( &tv, NULL );
return tv.tv_sec;
}
/****************************************************************************/
/****************************************************************************/
/***** *****/
/***** *****/
/***** *****/
/****************************************************************************/
/****************************************************************************/
/* used to define the content of _RESOLV_HOSTENT_NONE
*/
const struct hostent _resolv_hostent_none_cst = {
NULL,
NULL,
AF_INET,
4,
NULL
};
struct hostent*
_resolv_hostent_copy( struct hostent* hp )
{
struct hostent* dst;
int nn, len;
char* p;
int num_aliases = 0, num_addresses = 0;
if (hp == NULL)
return NULL;
if (hp == _RESOLV_HOSTENT_NONE)
return hp;
len = sizeof(*hp);
len += strlen(hp->h_name) + 1;
if (hp->h_aliases != NULL) {
for (nn = 0; hp->h_aliases[nn] != NULL; nn++)
len += sizeof(char*) + strlen(hp->h_aliases[nn]) + 1;
num_aliases = nn;
}
len += sizeof(char*);
for (nn = 0; hp->h_addr_list[nn] != NULL; nn++) {
len += sizeof(char*) + hp->h_length;
}
num_addresses = nn;
len += sizeof(char*);
dst = malloc( len );
if (dst == NULL)
return NULL;
dst->h_aliases = (char**)(dst + 1);
dst->h_addr_list = dst->h_aliases + num_aliases + 1;
dst->h_length = hp->h_length;
dst->h_addrtype = hp->h_addrtype;
p = (char*)(dst->h_addr_list + num_addresses + 1);
/* write the addresses first, to help with alignment issues */
for (nn = 0; nn < num_addresses; nn++) {
dst->h_addr_list[nn] = p;
len = hp->h_length;
memcpy( p, hp->h_addr_list[nn], len );
p += len;
}
dst->h_addr_list[nn] = NULL;
for (nn = 0; nn < num_aliases; nn++) {
dst->h_aliases[nn] = p;
len = strlen(hp->h_aliases[nn]) + 1;
memcpy( p, hp->h_aliases[nn], len );
p += len;
}
dst->h_aliases[nn] = NULL;
dst->h_name = p;
len = strlen(hp->h_name) + 1;
memcpy(p, hp->h_name, len);
p += len;
return dst;
}
void
_resolv_hostent_free( struct hostent* hp )
{
if (hp && hp != _RESOLV_HOSTENT_NONE)
free(hp);
}
/****************************************************************************/
/****************************************************************************/
/***** *****/
/***** *****/
/***** *****/
/****************************************************************************/
/****************************************************************************/
typedef struct Entry {
unsigned int hash;
const char* name;
short af;
short index;
struct Entry* mru_prev;
struct Entry* mru_next;
time_t when;
struct hostent* hp;
} Entry;
static void
entry_free( Entry* e )
{
/* everything is allocated in a single memory block */
if (e) {
_resolv_hostent_free(e->hp);
free(e);
}
}
static void
entry_init_key( Entry* e, const char* name, int af )
{
unsigned h = 0;
const char* p = name;
/* compute hash */
p = name;
while (*p) {
h = h*33 + *p++;
}
h += af*17;
e->hash = h;
e->name = name;
e->af = (short) af;
}
static __inline__ void
entry_mru_remove( Entry* e )
{
e->mru_prev->mru_next = e->mru_next;
e->mru_next->mru_prev = e->mru_prev;
}
static __inline__ void
entry_mru_add( Entry* e, Entry* list )
{
Entry* first = list->mru_next;
e->mru_next = first;
e->mru_prev = list;
list->mru_next = e;
first->mru_prev = e;
}
static Entry*
entry_alloc( const char* name, int af, int index, struct hostent* hp )
{
Entry* e;
int num_aliases = 0;
int num_addresses = 0;
char** aliases;
char** addresses;
/* compute the length of the memory block that will contain everything */
int len = sizeof(*e) + strlen(name)+1;
e = malloc(len);
if (e == NULL)
return e;
entry_init_key(e, name, af);
e->mru_next = e->mru_prev = e;
e->index = (short) index;
e->when = _time_now();
e->hp = _resolv_hostent_copy(hp);
if (e->hp == NULL) {
free(e);
return NULL;
}
e->name = (char*)(e+1);
len = strlen(name)+1;
memcpy( (char*)e->name, name, len );
return e;
}
static __inline__ int
entry_equals( const Entry* e1, const Entry* e2 )
{
return e1->hash == e2->hash && e1->af == e2->af && !strcmp( e1->name, e2->name );
}
/****************************************************************************/
/****************************************************************************/
/***** *****/
/***** *****/
/***** *****/
/****************************************************************************/
/****************************************************************************/
#define MAX_HASH_ENTRIES (2*CONFIG_MAX_ENTRIES)
typedef struct resolv_cache {
int num_entries;
Entry mru_list;
pthread_mutex_t lock;
int disabled;
Entry* entries[ MAX_HASH_ENTRIES ]; /* hash-table of pointers to entries */
} Cache;
void
_resolv_cache_destroy( struct resolv_cache* cache )
{
if (cache != NULL) {
int nn;
for (nn = 0; nn < MAX_HASH_ENTRIES; nn++) {
entry_free(cache->entries[nn]);
}
pthread_mutex_destroy(&cache->lock);
free(cache);
}
}
struct resolv_cache*
_resolv_cache_create( void )
{
struct resolv_cache* cache;
cache = calloc(sizeof(*cache), 1);
if (cache) {
const char* env = getenv(CONFIG_ENV);
if (env && atoi(env) == 0)
cache->disabled = 1;
pthread_mutex_init( &cache->lock, NULL );
cache->mru_list.mru_prev = cache->mru_list.mru_next = &cache->mru_list;
XLOG("%s: cache=%p %s\n", __FUNCTION__, cache, cache->disabled ? "disabled" : "enabled" );
}
return cache;
}
static int
_resolv_cache_find_index( Cache* cache,
const char* name,
int af )
{
Entry key;
int nn, step, tries;
entry_init_key( &key, name, af );
tries = MAX_HASH_ENTRIES;
nn = key.hash % MAX_HASH_ENTRIES;
step = 5;
while (tries > 0) {
Entry* key2 = cache->entries[nn];
if (key2 == NULL) {
return -(nn + 1);
}
if (entry_equals( &key, key2 ) ) {
return nn;
}
nn = (nn + step) % MAX_HASH_ENTRIES;
tries -= 1;
}
return -(MAX_HASH_ENTRIES+1);
}
static void
_resolv_cache_remove( struct resolv_cache* cache,
Entry* e )
{
XLOG("%s: name='%s' af=%d\n", __FUNCTION__, e->name, e->af);
cache->entries[ e->index ] = NULL; /* remove from hash table */
entry_mru_remove( e );
entry_free( e );
cache->num_entries -= 1;
}
struct hostent*
_resolv_cache_lookup( struct resolv_cache* cache,
const char* name,
int af )
{
int index;
struct hostent* result = NULL;
if (cache->disabled)
return NULL;
pthread_mutex_lock( &cache->lock );
XLOG( "%s: cache=%p name='%s' af=%d ", __FUNCTION__, cache, name, af );
index = _resolv_cache_find_index( cache, name, af );
if (index >= 0) {
Entry* e = cache->entries[index];
time_t now = _time_now();
struct hostent** pht;
/* ignore stale entries, they will be discarded in _resolv_cache_add */
if ( (unsigned)(now - e->when) >= CONFIG_SECONDS ) {
XLOG( " OLD\n" );
goto Exit;
}
/* bump up this entry to the top of the MRU list */
if (e != cache->mru_list.mru_next) {
entry_mru_remove( e );
entry_mru_add( e, &cache->mru_list );
}
/* now copy the result into a thread-local variable */
pht = __get_res_cache_hostent_p();
if (pht == NULL) {
XLOG( " NOTLS\n" ); /* shouldn't happen */
goto Exit;
}
if (pht[0]) {
_resolv_hostent_free( pht[0] ); /* clear previous value */
pht[0] = NULL;
}
result = _resolv_hostent_copy( e->hp );
if (result == NULL) {
XLOG( " NOMEM\n" ); /* bummer */
goto Exit;
}
XLOG( " OK\n" );
pht[0] = result;
goto Exit;
}
XLOG( " KO\n" );
Exit:
pthread_mutex_unlock( &cache->lock );
return result;
}
void
_resolv_cache_add( struct resolv_cache* cache,
const char* name,
int af,
struct hostent* hp )
{
Entry* e;
int index;
if (cache->disabled)
return;
pthread_mutex_lock( &cache->lock );
XLOG( "%s: cache=%p name='%s' af=%d\n", __FUNCTION__, cache, name, af);
/* get rid of the oldest entry if needed */
if (cache->num_entries >= CONFIG_MAX_ENTRIES) {
Entry* oldest = cache->mru_list.mru_prev;
_resolv_cache_remove( cache, oldest );
}
index = _resolv_cache_find_index( cache, name, af );
if (index >= 0) {
/* discard stale entry */
_resolv_cache_remove( cache, cache->entries[index] );
} else {
index = -(index+1);
if (index >= MAX_HASH_ENTRIES)
goto Exit; /* should not happen */
}
e = entry_alloc( name, af, index, hp );
if (e != NULL) {
entry_mru_add( e, &cache->mru_list );
cache->entries[index] = e;
cache->num_entries += 1;
}
Exit:
pthread_mutex_unlock( &cache->lock );
}
/****************************************************************************/
/****************************************************************************/
/***** *****/
/***** *****/
/***** *****/
/****************************************************************************/
/****************************************************************************/
static struct resolv_cache* _res_cache;
static pthread_once_t _res_cache_once;
static void
_res_cache_init( void )
{
_res_cache = _resolv_cache_create();
}
struct resolv_cache*
__get_res_cache( void )
{
pthread_once( &_res_cache_once, _res_cache_init );
return _res_cache;
}
Reference in New Issue View Git Blame Copy Permalink