deleted file mode 100644

@@ -1,4731 +0,0 @@

-/*

- * resolver related functions

- *

- * Copyright (C) 2006 iptelorg GmbH

- *

- * This file is part of Kamailio, a free SIP server.

- *

- * Kamailio 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; either version 2 of the License, or

- * (at your option) any later version

- *

- * Kamailio 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, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- */

-

-/*!

- * \file

- * \brief Kamailio core :: DNS cache handling

- * \ingroup core

- * Module: \ref core

- */

-

-

-#ifdef USE_DNS_CACHE

-

-#ifdef DNS_SRV_LB

-#include <stdlib.h> /* FIXME: rand() */

-#endif

-#include <string.h>

-

-#include "globals.h"

-#include "cfg_core.h"

-#include "dns_cache.h"

-#include "dns_wrappers.h"

-#include "compiler_opt.h"

-#include "mem/shm_mem.h"

-#include "hashes.h"

-#include "clist.h"

-#include "locking.h"

-#include "atomic_ops.h"

-#include "ut.h"

-#include "timer.h"

-#include "timer_ticks.h"

-#include "error.h"

-#include "rpc.h"

-#include "rand/fastrand.h"

-#ifdef USE_DNS_CACHE_STATS

-#include "pt.h"

-#endif

-

-

-

-#define DNS_CACHE_DEBUG /* extra sanity checks and debugging */

-

-

-#ifndef MAX

-	#define MAX(a,b) ( ((a)>(b))?(a):(b))

-#endif

-

-#define MAX_DNS_RECORDS 255  /* maximum dns records number  received in a

-							   dns answer*/

-

-#define DNS_HASH_SIZE	1024 /* must be <= 65535 */

-#define DEFAULT_DNS_TIMER_INTERVAL 120  /* 2 min. */

-#define DNS_HE_MAX_ADDR 10  /* maxium addresses returne in a hostent struct */

-#define MAX_CNAME_CHAIN  10

-#define SPACE_FORMAT "    " /* format of view output */

-#define DNS_SRV_ZERO_W_CHANCE	1000 /* one in a 1000*weight_sum chance for

-										selecting a 0-weight record */

-

-int dns_cache_init=1;	/* if 0, the DNS cache is not initialized at startup */

-static gen_lock_t* dns_hash_lock=0;

-static volatile unsigned int *dns_cache_mem_used=0; /* current mem. use */

-unsigned int dns_timer_interval=DEFAULT_DNS_TIMER_INTERVAL; /* in s */

-int dns_flags=0; /* default flags used for the  dns_*resolvehost

-                    (compatibility wrappers) */

-

-#ifdef USE_DNS_CACHE_STATS

-struct t_dns_cache_stats* dns_cache_stats=0;

-#endif

-

-#define LOCK_DNS_HASH()		lock_get(dns_hash_lock)

-#define UNLOCK_DNS_HASH()	lock_release(dns_hash_lock)

-

-#define FIX_TTL(t) \

-	(((t)<cfg_get(core, core_cfg, dns_cache_min_ttl))? \

-		cfg_get(core, core_cfg, dns_cache_min_ttl): \

-		(((t)>cfg_get(core, core_cfg, dns_cache_max_ttl))? \

-			cfg_get(core, core_cfg, dns_cache_max_ttl): \

-			(t)))

-

-

-struct dns_hash_head{

-	struct dns_hash_entry* next;

-	struct dns_hash_entry* prev;

-};

-

-#ifdef DNS_LU_LST

-struct dns_lu_lst* dns_last_used_lst=0;

-#endif

-

-static struct dns_hash_head* dns_hash=0;

-

-

-static struct timer_ln* dns_timer_h=0;

-

-#ifdef DNS_WATCHDOG_SUPPORT

-static atomic_t *dns_servers_up = NULL;

-#endif

-

-

-

-static const char* dns_str_errors[]={

-	"no error",

-	"no more records", /* not an error, but and end condition */

-	"unknown error",

-	"internal error",

-	"bad SRV entry",

-	"unresolvable SRV request",

-	"bad A or AAAA entry",

-	"unresolvable A or AAAA request",

-	"invalid ip in A or AAAA record",

-	"blacklisted ip",

-	"name too long ", /* try again with a shorter name */

-	"ip AF mismatch", /* address family mismatch */

-	"unresolvable NAPTR request",

-	"bug - critical error"

-};

-

-

-

-/* param: err (negative error number) */

-const char* dns_strerror(int err)

-{

-	err=-err;

-	if ((err>=0) && (err<sizeof(dns_str_errors)/sizeof(char*)))

-		return dns_str_errors[err];

-	return "bug -- bad error number";

-}

-

-

-

-/* "internal" only, don't use unless you really know waht you're doing */

-inline static void dns_destroy_entry(struct dns_hash_entry* e)

-{

-#ifdef DNS_CACHE_DEBUG

-	memset(e, 0, e->total_size);

-#endif

-	shm_free(e); /* nice having it in one block isn't it? :-) */

-}

-

-

-/* "internal" only, same as above, asumes shm_lock() held (tm optimization) */

-inline static void dns_destroy_entry_shm_unsafe(struct dns_hash_entry* e)

-{

-#ifdef DNS_CACHE_DEBUG

-	memset(e, 0, e->total_size);

-#endif

-	shm_free_unsafe(e); /* nice having it in one block isn't it? :-) */

-}

-

-

-

-/* dec. the internal refcnt and if 0 deletes the entry */

-void dns_hash_put(struct dns_hash_entry* e)

-{

-	if(e && atomic_dec_and_test(&e->refcnt)){

-		/* atomic_sub_long(dns_cache_total_used, e->total_size); */

-		dns_destroy_entry(e);

-	}

-}

-

-

-

-/* same as above but uses dns_destroy_unsafe (assumes shm_lock held -- tm

- *  optimization) */

-void dns_hash_put_shm_unsafe(struct dns_hash_entry* e)

-{

-	if(e && atomic_dec_and_test(&e->refcnt)){

-		/* atomic_sub_long(dns_cache_total_used, e->total_size); */

-		dns_destroy_entry_shm_unsafe(e);

-	}

-}

-

-

-inline static int dns_cache_clean(unsigned int no, int expired_only);

-inline static int dns_cache_free_mem(unsigned int target, int expired_only);

-

-static ticks_t dns_timer(ticks_t ticks, struct timer_ln* tl, void* data)

-{

-#ifdef DNS_WATCHDOG_SUPPORT

-	/* do not clean the hash table if the servers are down */

-	if (atomic_get(dns_servers_up) == 0)

-		return (ticks_t)(-1);

-#endif

-	if (*dns_cache_mem_used>12*(cfg_get(core, core_cfg, dns_cache_max_mem)/16)){ /* ~ 75% used */

-		dns_cache_free_mem(cfg_get(core, core_cfg, dns_cache_max_mem)/2, 1);

-	}else{

-		dns_cache_clean(-1, 1); /* all the table, only expired entries */

-		/* TODO: better strategy? */

-	}

-	return (ticks_t)(-1);

-}

-

-

-

-void destroy_dns_cache()

-{

-	if (dns_timer_h){

-		timer_del(dns_timer_h);

-		timer_free(dns_timer_h);

-		dns_timer_h=0;

-	}

-#ifdef DNS_WATCHDOG_SUPPORT

-	if (dns_servers_up){

-		shm_free(dns_servers_up);

-		dns_servers_up=0;

-	}

-#endif

-	if (dns_hash_lock){

-		lock_destroy(dns_hash_lock);

-		lock_dealloc(dns_hash_lock);

-		dns_hash_lock=0;

-	}

-	if (dns_hash){

-		shm_free(dns_hash);

-		dns_hash=0;

-	}

-#ifdef DNS_LU_LST

-	if (dns_last_used_lst){

-		shm_free(dns_last_used_lst);

-		dns_last_used_lst=0;

-	}

-#endif

-#ifdef USE_DNS_CACHE_STATS

-	if (dns_cache_stats)

-		shm_free(dns_cache_stats);

-#endif

-	if (dns_cache_mem_used){

-		shm_free((void*)dns_cache_mem_used);

-		dns_cache_mem_used=0;

-	}

-}

-

-/* set the value of dns_flags */

-void fix_dns_flags(str *gname, str *name)

-{

-	/* restore the original value of dns_cache_flags first

-	 * (DNS_IPV4_ONLY may have been set only because dns_try_ipv6

-	 * was disabled, and the flag must be cleared when

-	 * dns_try_ipv6 is enabled) (Miklos)

-	 */

-	dns_flags = cfg_get(core, core_cfg, dns_cache_flags) & 7;

-

-	if (cfg_get(core, core_cfg, dns_try_ipv6)==0){

-		dns_flags|=DNS_IPV4_ONLY;

-	}

-	if (dns_flags & DNS_IPV4_ONLY){

-		dns_flags&=~(DNS_IPV6_ONLY|DNS_IPV6_FIRST);

-	}

-	if (cfg_get(core, core_cfg, dns_srv_lb)){

-#ifdef DNS_SRV_LB

-		dns_flags|=DNS_SRV_RR_LB;

-#else

-		LM_WARN("SRV loadbalaning is set, but"

-					" support for it is not compiled -- ignoring\n");

-#endif

-	}

-	if (cfg_get(core, core_cfg, dns_try_naptr)) {

-#ifndef USE_NAPTR

-	LM_WARN("NAPTR support is enabled, but"

-				" support for it is not compiled -- ignoring\n");

-#endif

-		dns_flags|=DNS_TRY_NAPTR;

-	}

-}

-

-/* fixup function for use_dns_failover

- * verifies that use_dns_cache is set to 1

- */

-int use_dns_failover_fixup(void *handle, str *gname, str *name, void **val)

-{

-	if ((int)(long)(*val) && !cfg_get(core, handle, use_dns_cache)) {

-		LM_ERR("DNS cache is turned off, failover cannot be enabled. "

-			"(set use_dns_cache to 1)\n");

-		return -1;

-	}

-	return 0;

-}

-

-/* fixup function for use_dns_cache

- * verifies that dns_cache_init is set to 1

- */

-int use_dns_cache_fixup(void *handle, str *gname, str *name, void **val)

-{

-	if ((int)(long)(*val) && !dns_cache_init) {

-		LM_ERR("DNS cache is turned off by dns_cache_init=0, "

-			"it cannot be enabled runtime.\n");

-		return -1;

-	}

-	if (((int)(long)(*val)==0) && cfg_get(core, handle, use_dns_failover)) {

-		LM_ERR("DNS failover depends on use_dns_cache, set use_dns_failover "

-			"to 0 before disabling the DNS cache\n");

-		return -1;

-	}

-	return 0;

-}

-

-/* KByte to Byte conversion */

-int dns_cache_max_mem_fixup(void *handle, str *gname, str *name, void **val)

-{

-	unsigned int    u;

-

-	u = ((unsigned int)(long)(*val))<<10;

-	(*val) = (void *)(long)u;

-	return 0;

-}

-

-int init_dns_cache()

-{

-	int r;

-	int ret;

-

-	if (dns_cache_init==0) {

-		/* the DNS cache is turned off */

-		default_core_cfg.use_dns_cache=0;

-		default_core_cfg.use_dns_failover=0;

-		return 0;

-	}

-

-	ret=0;

-	/* sanity check */

-	if (E_DNS_CRITICAL>=sizeof(dns_str_errors)/sizeof(char*)){

-		LM_CRIT("bad dns error table\n");

-		ret=E_BUG;

-		goto error;

-	}

-	dns_cache_mem_used=shm_malloc(sizeof(*dns_cache_mem_used));

-	if (dns_cache_mem_used==0){

-		ret=E_OUT_OF_MEM;

-		goto error;

-	}

-#ifdef DNS_LU_LST

-	dns_last_used_lst=shm_malloc(sizeof(*dns_last_used_lst));

-	if (dns_last_used_lst==0){

-		ret=E_OUT_OF_MEM;

-		goto error;

-	}

-	clist_init(dns_last_used_lst, next, prev);

-#endif

-	dns_hash=shm_malloc(sizeof(struct dns_hash_head)*DNS_HASH_SIZE);

-	if (dns_hash==0){

-		ret=E_OUT_OF_MEM;

-		goto error;

-	}

-	for (r=0; r<DNS_HASH_SIZE; r++)

-		clist_init(&dns_hash[r], next, prev);

-

-	dns_hash_lock=lock_alloc();

-	if (dns_hash_lock==0){

-		ret=E_OUT_OF_MEM;

-		goto error;

-	}

-	if (lock_init(dns_hash_lock)==0){

-		lock_dealloc(dns_hash_lock);

-		dns_hash_lock=0;

-		ret=-1;

-		goto error;

-	}

-

-#ifdef DNS_WATCHDOG_SUPPORT

-	dns_servers_up=shm_malloc(sizeof(atomic_t));

-	if (dns_servers_up==0){

-		ret=E_OUT_OF_MEM;

-		goto error;

-	}

-	atomic_set(dns_servers_up, 1);

-#endif

-

-	/* fix options */

-	default_core_cfg.dns_cache_max_mem<<=10; /* Kb */ /* TODO: test with 0 */

-	if (default_core_cfg.use_dns_cache==0)

-		default_core_cfg.use_dns_failover=0; /* cannot work w/o dns_cache support */

-	/* fix flags */

-	fix_dns_flags(NULL, NULL);

-

-	dns_timer_h=timer_alloc();

-	if (dns_timer_h==0){

-		ret=E_OUT_OF_MEM;

-		goto error;

-	}

-	if (dns_timer_interval){

-		timer_init(dns_timer_h, dns_timer, 0, 0); /* "slow" timer */

-		if (timer_add(dns_timer_h, S_TO_TICKS(dns_timer_interval))<0){

-			LM_CRIT("failed to add the timer\n");

-			timer_free(dns_timer_h);

-			dns_timer_h=0;

-			goto error;

-		}

-	}

-

-	return 0;

-error:

-	destroy_dns_cache();

-	return ret;

-}

-

-#ifdef USE_DNS_CACHE_STATS

-int init_dns_cache_stats(int iproc_num)

-{

-	/* do not initialize the stats array if the DNS cache will not be used */

-	if (dns_cache_init==0) return 0;

-

-	/* if it is already initialized */

-	if (dns_cache_stats)

-		shm_free(dns_cache_stats);

-

-	dns_cache_stats=shm_malloc(sizeof(*dns_cache_stats) * iproc_num);

-	if (dns_cache_stats==0){

-		return E_OUT_OF_MEM;

-	}

-	memset(dns_cache_stats, 0, sizeof(*dns_cache_stats) * iproc_num);

-

-	return 0;

-}

-#endif

-

-/* hash function, type is not used (obsolete)

- * params: char* s, int len, int type

- * returns the hash value

- */

-#define dns_hash_no(s, len, type) \

-	(get_hash1_case_raw((s),(len)) % DNS_HASH_SIZE)

-

-

-

-#ifdef DNS_CACHE_DEBUG

-#define DEBUG_LU_LST

-#ifdef DEBUG_LU_LST

-

-#include <stdlib.h> /* abort() */

-#define check_lu_lst(l) ((((l)->next==(l)) || ((l)->prev==(l))) && \

-							((l)!=dns_last_used_lst))

-

-#define dbg_lu_lst(txt, l) \

-		LM_CRIT("%s: crt(%p, %p, %p)," \

-					" prev(%p, %p, %p), next(%p, %p, %p)\n", txt, \

-					(l), (l)->next, (l)->prev, \

-					(l)->prev, (l)->prev->next, (l)->prev->prev, \

-					(l)->next, (l)->next->next, (l)->next->prev \

-				)

-

-#define debug_lu_lst( txt, l) \

-	do{ \

-		if ((l) && check_lu_lst((l))){  \

-			dbg_lu_lst(txt  " crt:", (l)); \

-			abort(); \

-		} \

-		if (((l)->next) && check_lu_lst((l)->next)){ \

-			dbg_lu_lst(txt  " next:",  (l)); \

-			abort(); \

-		} \

-		if (((l)->prev) && check_lu_lst((l)->prev)){ \

-			dbg_lu_lst(txt  " prev:", (l)); \

-			abort(); \

-		} \

-	}while(0)

-

-#endif

-#endif /* DNS_CACHE_DEBUG */

-

-

-/* must be called with the DNS_LOCK hold

- * remove and entry from the hash, dec. its refcnt and if not referenced

- * anymore deletes it */

-inline static void _dns_hash_remove(struct dns_hash_entry* e)

-{

-	clist_rm(e, next, prev);

-#ifdef DNS_CACHE_DEBUG

-	e->next=e->prev=0;

-#endif

-#ifdef DNS_LU_LST

-#ifdef DEBUG_LU_LST

-	debug_lu_lst("_dns_hash_remove: pre rm:", &e->last_used_lst);

-#endif

-	clist_rm(&e->last_used_lst, next, prev);

-#ifdef DEBUG_LU_LST

-	debug_lu_lst("_dns_hash_remove: post rm:", &e->last_used_lst);

-#endif

-#ifdef DNS_CACHE_DEBUG

-	e->last_used_lst.next=e->last_used_lst.prev=0;

-#endif

-#endif

-	*dns_cache_mem_used-=e->total_size;

-	dns_hash_put(e);

-}

-

-

-

-/* non locking  version (the dns hash must _be_ locked externally)

- * returns 0 when not found, or the entry on success (an entry with a

- * similar name but with a CNAME type will always match).

- * it doesn't increase the internal refcnt

- * returns the entry when found, 0 when not found and sets *err to !=0

- *  on error (e.g. recursive cnames)

- * WARNING: - internal use only

- *          - always check if the returned entry type is CNAME */

-inline static struct dns_hash_entry* _dns_hash_find(str* name, int type,

-														int* h, int* err)

-{

-	struct dns_hash_entry* e;

-	struct dns_hash_entry* tmp;

-	struct dns_hash_entry* ret;

-	ticks_t now;

-	int cname_chain;

-	str cname;

-#ifdef DNS_WATCHDOG_SUPPORT

-	int servers_up;

-

-	servers_up = atomic_get(dns_servers_up);

-#endif

-

-	cname_chain=0;

-	ret=0;

-	now=get_ticks_raw();

-	*err=0;

-again:

-	*h=dns_hash_no(name->s, name->len, type);

-#ifdef DNS_CACHE_DEBUG

-	LM_DBG("(%.*s(%d), %d), h=%d\n", name->len, name->s, name->len, type, *h);

-#endif

-	clist_foreach_safe(&dns_hash[*h], e, tmp, next){

-		if (

-#ifdef DNS_WATCHDOG_SUPPORT

-			/* remove expired elements only when the dns servers are up */

-			servers_up &&

-#endif

-			/* automatically remove expired elements */

-			((e->ent_flags & DNS_FLAG_PERMANENT) == 0) &&

-			((s_ticks_t)(now-e->expire)>=0)

-		) {

-				_dns_hash_remove(e);

-		}else if ((e->type==type) && (e->name_len==name->len) &&

-			(strncasecmp(e->name, name->s, e->name_len)==0)){

-			e->last_used=now;

-#ifdef DNS_LU_LST

-			/* add it at the end */

-#ifdef DEBUG_LU_LST

-			debug_lu_lst("_dns_hash_find: pre rm:", &e->last_used_lst);

-#endif

-			clist_rm(&e->last_used_lst, next, prev);

-			clist_append(dns_last_used_lst, &e->last_used_lst, next, prev);

-#ifdef DEBUG_LU_LST

-			debug_lu_lst("_dns_hash_find: post append:", &e->last_used_lst);

-#endif

-#endif

-			return e;

-		}else if ((e->type==T_CNAME) &&

-					!((e->rr_lst==0) || (e->ent_flags & DNS_FLAG_BAD_NAME)) &&

-					(e->name_len==name->len) &&

-					(strncasecmp(e->name, name->s, e->name_len)==0)){

-			/*if CNAME matches and CNAME is entry is not a neg. cache entry

-			  (could be produced by a specific CNAME lookup)*/

-			e->last_used=now;

-#ifdef DNS_LU_LST

-			/* add it at the end */

-#ifdef DEBUG_LU_LST

-			debug_lu_lst("_dns_hash_find: cname: pre rm:", &e->last_used_lst);

-#endif

-			clist_rm(&e->last_used_lst, next, prev);

-			clist_append(dns_last_used_lst, &e->last_used_lst, next, prev);

-#ifdef DEBUG_LU_LST

-			debug_lu_lst("_dns_hash_find: cname: post append:",

-							&e->last_used_lst);

-#endif

-#endif

-			ret=e; /* if this is an unfinished cname chain, we try to

-					  return the last cname */

-			/* this is a cname => retry using its value */

-			if (cname_chain> MAX_CNAME_CHAIN){

-				LM_ERR("cname chain too long or recursive (\"%.*s\")\n",

-						name->len, name->s);

-				ret=0; /* error*/

-				*err=-1;

-				break;

-			}

-			cname_chain++;

-			cname.s=((struct cname_rdata*)e->rr_lst->rdata)->name;

-			cname.len= ((struct cname_rdata*)e->rr_lst->rdata)->name_len;

-			name=&cname;

-			goto again;

-		}

-	}

-	return ret;

-}

-

-

-

-/* frees cache entries, if expired_only=0 only expired entries will be

- * removed, else all of them

- * it will process maximum no entries (to process all of them use -1)

- * returns the number of deleted entries

- * This should be called from a timer process*/

-inline static int dns_cache_clean(unsigned int no, int expired_only)

-{

-	struct dns_hash_entry* e;

-	ticks_t now;

-	unsigned int n;

-	unsigned int deleted;

-#ifdef DNS_LU_LST

-	struct dns_lu_lst* l;

-	struct dns_lu_lst* tmp;

-#else

-	struct dns_hash_entry* t;

-	unsigned int h;

-	static unsigned int start=0;

-#endif

-

-	n=0;

-	deleted=0;

-	now=get_ticks_raw();

-	LOCK_DNS_HASH();

-#ifdef DNS_LU_LST

-	clist_foreach_safe(dns_last_used_lst, l, tmp, next){

-		e=(struct dns_hash_entry*)(((char*)l)-

-				(char*)&((struct dns_hash_entry*)(0))->last_used_lst);

-		if (((e->ent_flags & DNS_FLAG_PERMANENT) == 0)

-			&& (!expired_only || ((s_ticks_t)(now-e->expire)>=0))

-		) {

-				_dns_hash_remove(e);

-				deleted++;

-		}

-		n++;

-		if (n>=no) break;

-	}

-#else

-	for(h=start; h!=(start+DNS_HASH_SIZE); h++){

-		clist_foreach_safe(&dns_hash[h%DNS_HASH_SIZE], e, t, next){

-			if (((e->ent_flags & DNS_FLAG_PERMANENT) == 0)

-				&& ((s_ticks_t)(now-e->expire)>=0)

-			) {

-				_dns_hash_remove(e);

-				deleted++;

-			}

-			n++;

-			if (n>=no) goto skip;

-		}

-	}

-	/* not fair, but faster then random() */

-	if (!expired_only){

-		for(h=start; h!=(start+DNS_HASH_SIZE); h++){

-			clist_foreach_safe(&dns_hash[h%DNS_HASH_SIZE], e, t, next){

-				if ((e->ent_flags & DNS_FLAG_PERMANENT) == 0) {

-					_dns_hash_remove(e);

-					deleted++;

-				}

-				n++;

-				if (n>=no) goto skip;

-			}

-		}

-	}

-skip:

-	start=h;

-#endif

-	UNLOCK_DNS_HASH();

-	return deleted;

-}

-

-

-

-/* frees cache entries, if expired_only=0 only expired entries will be

- * removed, else all of them

- * it will stop when the dns cache used memory reaches target (to process all

- * of them use 0)

- * returns the number of deleted entries */

-inline static int dns_cache_free_mem(unsigned int target, int expired_only)

-{

-	struct dns_hash_entry* e;

-	ticks_t now;

-	unsigned int deleted;

-#ifdef DNS_LU_LST

-	struct dns_lu_lst* l;

-	struct dns_lu_lst* tmp;

-#else

-	struct dns_hash_entry* t;

-	unsigned int h;

-	static unsigned int start=0;

-#endif

-

-	deleted=0;

-	now=get_ticks_raw();

-	LOCK_DNS_HASH();

-#ifdef DNS_LU_LST

-	clist_foreach_safe(dns_last_used_lst, l, tmp, next){

-		if (*dns_cache_mem_used<=target) break;

-		e=(struct dns_hash_entry*)(((char*)l)-

-				(char*)&((struct dns_hash_entry*)(0))->last_used_lst);

-		if (((e->ent_flags & DNS_FLAG_PERMANENT) == 0)

-			&& (!expired_only || ((s_ticks_t)(now-e->expire)>=0))

-		) {

-				_dns_hash_remove(e);

-				deleted++;

-		}

-	}

-#else

-	for(h=start; h!=(start+DNS_HASH_SIZE); h++){

-		clist_foreach_safe(&dns_hash[h%DNS_HASH_SIZE], e, t, next){

-			if (*dns_cache_mem_used<=target)

-				goto skip;

-			if (((e->ent_flags & DNS_FLAG_PERMANENT) == 0)

-				&& ((s_ticks_t)(now-e->expire)>=0)

-			) {

-				_dns_hash_remove(e);

-				deleted++;

-			}

-		}

-	}

-	/* not fair, but faster then random() */

-	if (!expired_only){

-		for(h=start; h!=(start+DNS_HASH_SIZE); h++){

-			clist_foreach_safe(&dns_hash[h%DNS_HASH_SIZE], e, t, next){

-				if (*dns_cache_mem_used<=target)

-					goto skip;

-				if (((e->ent_flags & DNS_FLAG_PERMANENT) == 0)

-					&& ((s_ticks_t)(now-e->expire)>=0)

-				) {

-					_dns_hash_remove(e);

-					deleted++;

-				}

-			}

-		}

-	}

-skip:

-	start=h;

-#endif

-	UNLOCK_DNS_HASH();

-	return deleted;

-}

-

-

-

-/* locking  version (the dns hash must _not_be locked externally)

- * returns 0 when not found, the searched entry on success (with CNAMEs

- *  followed) or the last CNAME entry from an unfinished CNAME chain,

- *  if the search matches a CNAME. On error sets *err (e.g. recursive CNAMEs).

- * it increases the internal refcnt => when finished dns_hash_put() must

- *  be called on the returned entry

- *  WARNING: - the return might be a CNAME even if type!=CNAME, see above */

-inline static struct dns_hash_entry* dns_hash_get(str* name, int type, int* h,

-													int* err)

-{

-	struct dns_hash_entry* e;

-

-	LOCK_DNS_HASH();

-	e=_dns_hash_find(name, type, h, err);

-	if (e){

-		atomic_inc(&e->refcnt);

-	}

-	UNLOCK_DNS_HASH();

-	return e;

-}

-

-

-

-/* adds a fully created and init. entry (see dns_cache_mk_entry()) to the hash

- * table

- * returns 0 on success, -1 on error */

-inline static int dns_cache_add(struct dns_hash_entry* e)

-{

-	int h;

-

-	/* check space */

-	/* atomic_add_long(dns_cache_total_used, e->size); */

-	if ((*dns_cache_mem_used+e->total_size)>=cfg_get(core, core_cfg, dns_cache_max_mem)){

-#ifdef USE_DNS_CACHE_STATS

-		dns_cache_stats[process_no].dc_lru_cnt++;

-#endif

-		LM_WARN("cache full, trying to free...\n");

-		/* free ~ 12% of the cache */

-		dns_cache_free_mem(*dns_cache_mem_used/16*14,

-					!cfg_get(core, core_cfg, dns_cache_del_nonexp));

-		if ((*dns_cache_mem_used+e->total_size)>=cfg_get(core, core_cfg, dns_cache_max_mem)){

-			LM_ERR("max. cache mem size exceeded\n");

-			return -1;

-		}

-	}

-	atomic_inc(&e->refcnt);

-	h=dns_hash_no(e->name, e->name_len, e->type);

-#ifdef DNS_CACHE_DEBUG

-	LM_DBG("adding %.*s(%d) %d (flags=%0x) at %d\n",

-			e->name_len, e->name, e->name_len, e->type, e->ent_flags, h);

-#endif

-	LOCK_DNS_HASH();

-		*dns_cache_mem_used+=e->total_size; /* no need for atomic ops, written

-										 only from within a lock */

-		clist_append(&dns_hash[h], e, next, prev);

-#ifdef DNS_LU_LST

-		clist_append(dns_last_used_lst, &e->last_used_lst, next, prev);

-#endif

-	UNLOCK_DNS_HASH();

-	return 0;

-}

-

-

-

-/* same as above, but it must be called with the dns hash lock held

- * returns 0 on success, -1 on error */

-inline static int dns_cache_add_unsafe(struct dns_hash_entry* e)

-{

-	int h;

-

-	/* check space */

-	/* atomic_add_long(dns_cache_total_used, e->size); */

-	if ((*dns_cache_mem_used+e->total_size)>=cfg_get(core, core_cfg, dns_cache_max_mem)){

-#ifdef USE_DNS_CACHE_STATS

-		dns_cache_stats[process_no].dc_lru_cnt++;

-#endif

-		LM_WARN("cache full, trying to free...\n");

-		/* free ~ 12% of the cache */

-		UNLOCK_DNS_HASH();

-		dns_cache_free_mem(*dns_cache_mem_used/16*14,

-					!cfg_get(core, core_cfg, dns_cache_del_nonexp));

-		LOCK_DNS_HASH();

-		if ((*dns_cache_mem_used+e->total_size)>=cfg_get(core, core_cfg, dns_cache_max_mem)){

-			LM_ERR("max. cache mem size exceeded\n");

-			return -1;

-		}

-	}

-	atomic_inc(&e->refcnt);

-	h=dns_hash_no(e->name, e->name_len, e->type);

-#ifdef DNS_CACHE_DEBUG

-	LM_DBG("adding %.*s(%d) %d (flags=%0x) at %d\n",

-			e->name_len, e->name, e->name_len, e->type, e->ent_flags, h);

-#endif

-	*dns_cache_mem_used+=e->total_size; /* no need for atomic ops, written

-										 only from within a lock */

-	clist_append(&dns_hash[h], e, next, prev);

-#ifdef DNS_LU_LST

-	clist_append(dns_last_used_lst, &e->last_used_lst, next, prev);

-#endif

-	return 0;

-}

-

-

-

-/* creates a "negative" entry which will be valid for ttl seconds */

-inline static struct dns_hash_entry* dns_cache_mk_bad_entry(str* name,

-															int type,

-															int ttl,

-															int flags)

-{

-	struct dns_hash_entry* e;

-	int size;

-	ticks_t now;

-

-#ifdef DNS_CACHE_DEBUG

-	LM_DBG("(%.*s, %d, %d, %d)\n", name->len, name->s, type, ttl, flags);

-#endif

-	size=sizeof(struct dns_hash_entry)+name->len-1+1;

-	e=shm_malloc(size);

-	if (e==0){

-		LM_ERR("out of memory\n");

-		return 0;

-	}

-	memset(e, 0, size); /* init with 0*/

-	e->total_size=size;

-	e->name_len=name->len;

-	e->type=type;

-	now=get_ticks_raw();

-	e->last_used=now;

-	e->expire=now+S_TO_TICKS(ttl);

-	memcpy(e->name, name->s, name->len);