@@ -66,7 +66,7 @@ MAIN_NAME=ser

 VERSION = 0

 PATCHLEVEL = 10

 SUBLEVEL =   99

-EXTRAVERSION = -dev42

+EXTRAVERSION = -dev43-dns_cache

 SER_VER = $(shell expr $(VERSION) \* 1000000 + $(PATCHLEVEL) \* 1000 + \

 			$(SUBLEVEL) )

@@ -339,6 +339,14 @@ endif

 #		compiles in checks and use for maddr parameter in uri.

 #		Required to support Windows Messenger 5.x over TCP connection

 #		which (mis)uses this parameter.

+# -DUSE_DNS_CACHE

+#		use an internal dns cache instead of making dns requests each time

+# -DUSE_DNS_FAILOVER

+#		if the destination resolves to multiple ips, on send error fall back

+#		to the others

+# -DUSE_DST_BLACKLIST

+#		blacklist bad destination (timeout, failed to connect, error sending

+#        a.s.o)

 # Sometimes is needes correct non-quoted $OS. HACK: gcc translates known OS to number ('linux'), so there is added underscore

@@ -356,6 +364,9 @@ DEFS+= $(extra_defs) \

 	 -DDISABLE_NAGLE \

 	 -DHAVE_RESOLV_RES \

 	 -DDBG_QM_MALLOC \

+	 -DUSE_DNS_CACHE \

+	 -DUSE_DNS_FAILOVER \

+	 -DUSE_DST_BLACKLIST \

 	 #-DF_MALLOC \

 	 #-DDBG_F_MALLOC \

 	 #-DNO_DEBUG \

@@ -1092,7 +1103,6 @@ $(error 			Unsupported compiler ($(CC):$(CC_NAME)), try gcc)

 endif		#CC_NAME, gcc

 endif	#ARCH, ppc 

-CFLAGS+= $(CC_EXTRA_OPTS)

 # setting LDFLAGS

@@ -1122,6 +1132,7 @@ endif

 else	#mode,release

 ifeq	($(CC_NAME), gcc)

 		CFLAGS=-g -Wcast-align $(PROFILE)

+		DEFS+=-DCC_GCC_LIKE_ASM

 ifeq		($(ARCH), sparc64)

 			DEFS+=SPARC64_MODE

 			CFLAGS+= -mcpu=ultrasparc -m64

@@ -1138,6 +1149,7 @@ else

 endif

 endif

 ifeq	($(CC_NAME), icc)

+		DEFS+=-DCC_GCC_LIKE_ASM

 		CFLAGS=-g  $(PROFILE)

 		LDFLAGS+=-g -Wl,-E $(PROFILE)

 		MOD_LDFLAGS=-shared $(LDFLAGS)

@@ -1150,6 +1162,7 @@ endif

 endif #mode=release

+CFLAGS+= $(CC_EXTRA_OPTS)

 #*FLAGS used for compiling the modules

 ifeq	($(CC_NAME), gcc)

@@ -24,7 +24,8 @@ modules:

                 hashing after an uri (to, from or request uri)

               - improved uri hashing (password is ignored, port is used only

                 if != 5060 or 5061)

- - tm        - migrated to the new timers (tm timers completely rewritten)

+ - tm        - dns failover and dst blacklist support

+             - migrated to the new timers (tm timers completely rewritten)

              - improved speed and less memory usage

              - much more precise reptransmissions timing

              - params: - retr_timer1p1, retr_timer1p2, retr_timer1p3 removed

@@ -49,6 +50,11 @@ modules:

               Vias a.s.o) and not on the original message

 core:

+ - dns cache and dns failover support added (see doc/dns.txt)

+ - destination blacklist added -- destinations to which forwarding fails

+   (send error, tm timeout a.s.o) are temporarily added to a blacklist which 

+    is consulted before each send => faster send error detection

+    in the near future (see doc/dst_blacklist.txt)

  - default log level switched to 0 (only messages < L_WARN will be printed

    by default)

  - separate memdbg log level which controls the memory/malloc related

@@ -113,7 +119,7 @@ core:

  - tcp: - improved  performance (io event handling), using OS specific

            optimizations

         - 1024 connections limit removed (see tcp_max_connections)

--  resolver: - timeouts, retries a.s.o can no be set from ser.cfg

+-  resolver: - timeouts, retries a.s.o can now be set from ser.cfg

              (see below dns_* and man resolv.conf(6)).

              The maximum time a dns request can take (before failing) is:

               (dns_retr_time*dns_retr_no)*(search_list_domains)

@@ -130,6 +136,21 @@ core:

    are available (see tm docs)

 - avps directly accessible from script with %avp_name (variable style)

 new config variables:

+   use_dns_cache = on | off  (default on)  

+   use_dns_failover = on | off (default off)

+   dns_cache_flags = number (default 0)

+   dns_cache_negative_ttl = number in seconds (default 60)

+   dns_cache_min_ttl = time in seconds (default 0)

+   dns_cache_max_ttl = time in seconds (default MAXINT)

+   dns_cache_mem = maximum memory used for the dns cache in Kb (default 500 K)

+   dns_cache_gc_interval = interval in seconds after which the dns cache is

+      garbage collected (default: 120 s)

+   use_dst_blacklist = on | off (default off)

+   dst_blacklist_expire = time in s (default 60)

+   dst_blacklist_mem = maximum memory used for the blacklist in Kb (default 250

+      K)

+   dst_blacklist_gc_interval = interval in seconds after which the destination 

+      blacklist is garbage collected (default 60)

    tos = number  - ip type of service (TOS) value

    dns_try_ipv6 = yes/no - if yes and a dns lookup fails, it will retry it

       for ipv6 (AAAA record). Default: yes

@@ -138,7 +159,7 @@ new config variables:

       (usually 5s).

    dns_retr_no = no. - number of dns retransmissions before giving up.

       Default: see above (usually 4)

-   dns_server_no = no. - how many dns servers from the ones defined in 

+   dns_servers_no = no. - how many dns servers from the ones defined in 

       /etc/resolv.conf will be used. Default: all of them.

    dns_use_search_list= yes/no - if no, the search list in /etc/resolv.conf

       will be ignored (=> fewer lookups => gives up faster). Default: yes.

@@ -41,6 +41,7 @@

  *  2005-12-12  return & drop/exit differentiation (andrei)

  *  2005-12-19  select framework (mma)

  *  2006-04-12  updated *_send() calls to use a struct dest_info (andrei)

+ *  2006-07-27  dns cache and dns based send address failover support (andrei)

  */

@@ -107,6 +108,7 @@ int do_action(struct action* a, struct sip_msg* msg)

 	unsigned short port;

 	unsigned short flags;

 	int_str name, value;

+	str* dst_host;

 	/* reset the value of error to E_UNSPEC so avoid unknowledgable

 	   functions to return with error (status<0) and not setting it

@@ -208,32 +210,24 @@ int do_action(struct action* a, struct sip_msg* msg)

 #endif

 				}

-#ifdef HONOR_MADDR

-				if (u->maddr_val.s && u->maddr_val.len) {

-					if (sip_hostport2su(&dst.to, &u->maddr_val, port, dst.proto)<0){

-						LOG(L_ERR, "ERROR:  bad maddr param in uri,"

-								" dropping packet\n");

-						ret=E_BAD_ADDRESS;

-						goto error_fwd_uri;

-					}

-				} else

+#ifdef HONOR_MADDR				

+				if (u->maddr_val.s && u->maddr_val.len)

+					dst_host=&u->maddr_val;

+				else

 #endif

-				if (sip_hostport2su(&dst.to, &u->host, port, dst.proto)<0){

-					LOG(L_ERR, "ERROR:  bad host name in uri,"

-							" dropping packet\n");

-					ret=E_BAD_ADDRESS;

-					goto error_fwd_uri;

-				}

+					dst_host=&u->host;

 #ifdef USE_COMP

 				dst.comp=u->comp;

 #endif

-				ret=forward_request(msg, &dst);

-				if (ret>=0) ret=1;

+				ret=forward_request(msg, dst_host, port, &dst);

+				if (ret>=0){

+					ret=1;

+				}

 			}else if ((a->val[0].type==PROXY_ST) && (a->val[1].type==NUMBER_ST)){

 				if (dst.proto==PROTO_NONE)

 					dst.proto=msg->rcv.proto;

 				proxy2su(&dst.to,  (struct proxy_l*)a->val[0].u.data);

-				ret=forward_request(msg, &dst);

+				ret=forward_request(msg, 0, 0, &dst);

 				if (ret>=0){

 					ret=1;

 					proxy_mark((struct proxy_l*)a->val[0].u.data, ret);

@@ -60,6 +60,8 @@

  *              to_{ip,port} (andrei)

  *  2005-12-12  separated drop, exit, break, return, added RETCODE (andrei)

  *  2005-12-19  select framework (mma)

+ * 2006-09-11  added dns cache (use, flags, ttls, mem ,gc) & dst blacklist

+ *              options (andrei)

  */

@@ -228,6 +230,22 @@ DNS_RETR_TIME	dns_retr_time

 DNS_RETR_NO		dns_retr_no

 DNS_SERVERS_NO	dns_servers_no

 DNS_USE_SEARCH	dns_use_search_list

+/* dns cache */

+DNS_USE_CACHE	use_dns_cache

+DNS_USE_FAILOVER	use_dns_failover

+DNS_CACHE_FLAGS		dns_cache_flags

+DNS_CACHE_NEG_TTL	dns_cache_negative_ttl

+DNS_CACHE_MIN_TTL	dns_cache_min_ttl

+DNS_CACHE_MAX_TTL	dns_cache_max_ttl

+DNS_CACHE_MEM		dns_cache_mem

+DNS_CACHE_GC_INT	dns_cache_gc_interval

+/* blacklist */

+USE_DST_BLST		use_dst_blacklist

+DST_BLST_MEM		dst_blacklist_mem

+DST_BLST_TTL		dst_blacklist_expire|dst_blacklist_ttl

+DST_BLST_GC_INT		dst_blacklist_gc_interval

+

+

 PORT	port

 STAT	statistics

 MAXBUFFER maxbuffer

@@ -422,6 +440,30 @@ EAT_ABLE	[\ \t\b\r]

 								return DNS_SERVERS_NO; }

 <INITIAL>{DNS_USE_SEARCH}	{ count(); yylval.strval=yytext;

 								return DNS_USE_SEARCH; }

+<INITIAL>{DNS_USE_CACHE}	{ count(); yylval.strval=yytext;

+								return DNS_USE_CACHE; }

+<INITIAL>{DNS_USE_FAILOVER}	{ count(); yylval.strval=yytext;

+								return DNS_USE_FAILOVER; }

+<INITIAL>{DNS_CACHE_FLAGS}	{ count(); yylval.strval=yytext;

+								return DNS_CACHE_FLAGS; }

+<INITIAL>{DNS_CACHE_NEG_TTL}	{ count(); yylval.strval=yytext;

+								return DNS_CACHE_NEG_TTL; }

+<INITIAL>{DNS_CACHE_MIN_TTL}	{ count(); yylval.strval=yytext;

+								return DNS_CACHE_MIN_TTL; }

+<INITIAL>{DNS_CACHE_MAX_TTL}	{ count(); yylval.strval=yytext;

+								return DNS_CACHE_MAX_TTL; }

+<INITIAL>{DNS_CACHE_MEM}	{ count(); yylval.strval=yytext;

+								return DNS_CACHE_MEM; }

+<INITIAL>{DNS_CACHE_GC_INT}	{ count(); yylval.strval=yytext;

+								return DNS_CACHE_GC_INT; }

+<INITIAL>{USE_DST_BLST}	{ count(); yylval.strval=yytext;

+								return USE_DST_BLST; }

+<INITIAL>{DST_BLST_MEM}	{ count(); yylval.strval=yytext;

+								return DST_BLST_MEM; }

+<INITIAL>{DST_BLST_TTL}	{ count(); yylval.strval=yytext;

+								return DST_BLST_TTL; }

+<INITIAL>{DST_BLST_GC_INT}	{ count(); yylval.strval=yytext;

+								return DST_BLST_GC_INT; }

 <INITIAL>{PORT}	{ count(); yylval.strval=yytext; return PORT; }

 <INITIAL>{STAT}	{ count(); yylval.strval=yytext; return STAT; }

 <INITIAL>{MAXBUFFER}	{ count(); yylval.strval=yytext; return MAXBUFFER; }

@@ -72,6 +72,8 @@

  * 2006-02-02  named flags support (andrei)

  * 2006-02-06  named routes support (andrei)

  * 2006-05-30  avp flags (tma)

+ * 2006-09-11  added dns cache (use, flags, ttls, mem ,gc) & dst blacklist

+ *              options (andrei)

  */

 %{

@@ -117,6 +119,26 @@

 		if (rt!=ONSEND_ROUTE) yyerror( s " allowed only in onsend_routes");\

 	}while(0)

+

+#ifdef USE_DNS_CACHE

+	#define IF_DNS_CACHE(x) x

+#else

+	#define IF_DNS_CACHE(x) warn("dns cache support not compiled in")

+#endif

+

+#ifdef USE_DNS_FAILOVER

+	#define IF_DNS_FAILOVER(x) x

+#else

+	#define IF_DNS_FAILOVER(x) warn("dns failover support not compiled in")

+#endif

+

+#ifdef USE_DST_BLACKLIST

+	#define IF_DST_BLACKLIST(x) x

+#else

+	#define IF_DST_BLACKLIST(x) warn("dst blacklist support not compiled in")

+#endif

+

+

 extern int yylex();

 static void yyerror(char* s);

 static char* tmp;

@@ -234,6 +256,20 @@ static struct socket_id* mk_listen_id(char*, int, int);

 %token DNS_RETR_NO

 %token DNS_SERVERS_NO

 %token DNS_USE_SEARCH

+%token DNS_USE_CACHE

+%token DNS_USE_FAILOVER

+%token DNS_CACHE_FLAGS

+%token DNS_CACHE_NEG_TTL

+%token DNS_CACHE_MIN_TTL

+%token DNS_CACHE_MAX_TTL

+%token DNS_CACHE_MEM

+%token DNS_CACHE_GC_INT

+/*blacklist*/

+%token USE_DST_BLST

+%token DST_BLST_MEM

+%token DST_BLST_TTL

+%token DST_BLST_GC_INT

+

 %token PORT

 %token STAT

 %token CHILDREN

@@ -512,6 +548,30 @@ assign_stm:

 	| DNS_SERVERS_NO error { yyerror("number expected"); }

 	| DNS_USE_SEARCH EQUAL NUMBER   { dns_search_list=$3; }

 	| DNS_USE_SEARCH error { yyerror("boolean value expected"); }

+	| DNS_USE_CACHE EQUAL NUMBER   { IF_DNS_CACHE(use_dns_cache=$3); }

+	| DNS_USE_CACHE error { yyerror("boolean value expected"); }

+	| DNS_USE_FAILOVER EQUAL NUMBER   { IF_DNS_FAILOVER(use_dns_failover=$3);}

+	| DNS_USE_FAILOVER error { yyerror("boolean value expected"); }

+	| DNS_CACHE_FLAGS EQUAL NUMBER   { IF_DNS_CACHE(dns_flags=$3); }

+	| DNS_CACHE_FLAGS error { yyerror("boolean value expected"); }

+	| DNS_CACHE_NEG_TTL EQUAL NUMBER   { IF_DNS_CACHE(dns_neg_cache_ttl=$3); }

+	| DNS_CACHE_NEG_TTL error { yyerror("boolean value expected"); }

+	| DNS_CACHE_MAX_TTL EQUAL NUMBER   { IF_DNS_CACHE(dns_cache_max_ttl=$3); }

+	| DNS_CACHE_MAX_TTL error { yyerror("boolean value expected"); }

+	| DNS_CACHE_MIN_TTL EQUAL NUMBER   { IF_DNS_CACHE(dns_cache_min_ttl=$3); }

+	| DNS_CACHE_MIN_TTL error { yyerror("boolean value expected"); }

+	| DNS_CACHE_MEM EQUAL NUMBER   { IF_DNS_CACHE(dns_cache_max_mem=$3); }

+	| DNS_CACHE_MEM error { yyerror("boolean value expected"); }

+	| DNS_CACHE_GC_INT EQUAL NUMBER   { IF_DNS_CACHE(dns_timer_interval=$3); }

+	| DNS_CACHE_GC_INT error { yyerror("boolean value expected"); }

+	| USE_DST_BLST EQUAL NUMBER   { IF_DST_BLACKLIST(use_dst_blacklist=$3); }

+	| USE_DST_BLST error { yyerror("boolean value expected"); }

+	| DST_BLST_MEM EQUAL NUMBER   { IF_DST_BLACKLIST(blst_max_mem=$3); }

+	| DST_BLST_MEM error { yyerror("boolean value expected"); }

+	| DST_BLST_TTL EQUAL NUMBER   { IF_DST_BLACKLIST(blst_timeout=$3); }

+	| DST_BLST_TTL error { yyerror("boolean value expected"); }

+	| DST_BLST_GC_INT EQUAL NUMBER { IF_DST_BLACKLIST(blst_timer_interval=$3);}

+	| DST_BLST_GC_INT error { yyerror("boolean value expected"); }

 	| PORT EQUAL NUMBER   { port_no=$3; }

 	| STAT EQUAL STRING {

 		#ifdef STATS

@@ -1828,7 +1888,7 @@ static void warn(char* s)

 {

 	LOG(L_WARN, "cfg. warning: (%d,%d-%d): %s\n", line, startcolumn,

 			column, s);

-	cfg_errors++;

+	cfg_warnings++;

 }

 static void yyerror(char* s)

@@ -46,6 +46,10 @@

 /* adds an entire sublist { s,e } (including s & e )

  * after head

+ * WARNING: clist_insert_sublist(head, n, n->prev) won't work,

+ *          same for clist_insert_sublist(head, n->next, n)

+ *  (macro!), use  e=n->prev; clist_insert_sublist(head, n, e, ...)

+ *  instead!

  */

 #define clist_insert_sublist(head, s, e, next, prev) \

 	do{ \

@@ -59,6 +63,9 @@

 /* appends an entire sublist { s,e } (including s & e )

  * at the end of the list

+ * WARNING: clist_append_sublist(head, n, n->prev, ...) won't work,

+ *  (macro!), use  e=n->prev; clist_append_sublist(head, n, e, ...)

+ *  instead!

  */

 #define clist_append_sublist(head, s, e, next, prev) \

 	do{ \

@@ -70,9 +77,13 @@

+

 /* remove sublist { s,e } (including s & e )

  * always, if start is the beginning of the list use

- * clist_rm_sublist(head->next, e, next, prev ) */

+ * clist_rm_sublist(head->next, e, next, prev )

+ * WARNING: clist_rm_sublist(n, n->prev, ...) won't work,

+ *  (macro!), use  e=n->prev; clist_rm_sublist(n, e, ...)

+ *  instead! */

 #define clist_rm_sublist(s, e, next, prev) \

 	do{\

 		(s)->prev->next=(e)->next;  \

@@ -39,6 +39,40 @@

 #include "tcp_info.h"

 #include "core_cmd.h"

+#ifdef USE_DNS_CACHE

+void dns_cache_debug(rpc_t* rpc, void* ctx);

+void dns_cache_debug_all(rpc_t* rpc, void* ctx);

+void dns_cache_mem_info(rpc_t* rpc, void* ctx);

+

+static const char* dns_cache_mem_info_doc[] = {

+	"dns cache memory info.",    /* Documentation string */

+	0                      /* Method signature(s) */

+};

+static const char* dns_cache_debug_doc[] = {

+	"dns debug  info.",    /* Documentation string */

+	0                      /* Method signature(s) */

+};

+

+static const char* dns_cache_debug_all_doc[] = {

+	"complete dns debug  dump",    /* Documentation string */

+	0                              /* Method signature(s) */

+};

+#endif

+#ifdef USE_DST_BLACKLIST

+void dst_blst_debug(rpc_t* rpc, void* ctx);

+void dst_blst_mem_info(rpc_t* rpc, void* ctx);

+

+static const char* dst_blst_mem_info_doc[] = {

+	"dst blacklist memory usage info.",  /* Documentation string */

+	0                                    /* Method signature(s) */

+};

+static const char* dst_blst_debug_doc[] = {

+	"dst blacklist  debug  info.",  /* Documentation string */

+	0                               /* Method signature(s) */

+};

+#endif

+

+

 #define MAX_CTIME_LEN 128

@@ -312,6 +346,15 @@ rpc_export_t core_rpc_methods[] = {

 	{"core.kill",              core_kill,              core_kill_doc,              0        },

 	{"core.shmmem",            core_shmmem,            core_shmmem_doc,            0	},

 	{"core.tcp_info",          core_tcpinfo,           core_tcpinfo_doc,          0	},

+#ifdef USE_DNS_CACHE

+	{"dns.mem_info",          dns_cache_mem_info,     dns_cache_mem_info_doc,     0	},

+	{"dns.debug",          dns_cache_debug,           dns_cache_debug_doc,        0	},

+	{"dns.debug_all",      dns_cache_debug_all,       dns_cache_debug_all_doc,        0	},

+#endif

+#ifdef USE_DST_BLACKLIST

+	{"dst_blacklist.mem_info",  dst_blst_mem_info,     dst_blst_mem_info_doc,     0	},

+	{"dst_blacklist.debug",    dst_blst_debug,         dst_blst_debug_doc,        0	},

+#endif

 	{0, 0, 0, 0}

 };

new file mode 100644

@@ -0,0 +1,2436 @@

+/*

+ * $Id$

+ *

+ * resolver related functions

+ *

+ * Copyright (C) 2006 iptelorg GmbH

+ *

+ * This file is part of ser, a free SIP server.

+ *

+ * ser 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

+ *

+ * For a license to use the ser software under conditions

+ * other than those described here, or to purchase support for this

+ * software, please contact iptel.org by e-mail at the following addresses:

+ *    info@iptel.org

+ *

+ * ser 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ */

+/* History:

+ * --------

+ *  2006-07-13  created by andrei

+ */

+

+#ifdef USE_DNS_CACHE

+

+#include "globals.h"

+#include "dns_cache.h"

+#include "dns_wrappers.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"

+

+

+

+#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_NEG_CACHE_TTL 60 /* 1 min. */

+#define DEFAULT_DNS_CACHE_MIN_TTL 0 /* (disabled) */

+#define DEFAULT_DNS_CACHE_MAX_TTL ((unsigned int)(-1)) /* (maxint) */

+#define DEFAULT_DNS_MAX_MEM 500 /* 500 Kb */

+#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 

+

+

+static gen_lock_t* dns_hash_lock=0;

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

+unsigned int dns_cache_max_mem=DEFAULT_DNS_MAX_MEM; /* maximum memory used for

+													 the cached entries */

+unsigned int dns_neg_cache_ttl=DEFAULT_DNS_NEG_CACHE_TTL; /* neg. cache ttl */

+unsigned int dns_cache_max_ttl=DEFAULT_DNS_CACHE_MAX_TTL; /* maximum ttl */

+unsigned int dns_cache_min_ttl=DEFAULT_DNS_CACHE_MIN_TTL; /* minimum ttl */

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

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

+                    (compatibility wrappers) */

+

+#define LOCK_DNS_HASH()		lock_get(dns_hash_lock)

+#define UNLOCK_DNS_HASH()	lock_release(dns_hash_lock)

+

+#define FIX_TTL(t)  (((t)<dns_cache_min_ttl)?dns_cache_min_ttl: \

+						(((t)>dns_cache_max_ttl)?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;

+

+

+

+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",

+	"unresovlable 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 */

+	"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)

+{

+	if (*dns_cache_mem_used>12*(dns_cache_max_mem/16)){ /* ~ 75% used */

+		dns_cache_free_mem(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;

+	}

+	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

+	if (dns_cache_mem_used){

+		shm_free((void*)dns_cache_mem_used);

+		dns_cache_mem_used=0;

+	}

+}

+

+

+

+int init_dns_cache()

+{

+	int r;

+	int ret;

+	

+	ret=0;

+	/* sanity check */

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

+		LOG(L_CRIT, "BUG: dns_cache_init: 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;

+	}

+	

+	/* fix options */

+	dns_cache_max_mem<<=10; /* Kb */ /* TODO: test with 0 */

+	/* fix flags */

+	if (dns_try_ipv6==0){

+		dns_flags|=DNS_IPV4_ONLY;

+	}

+	if (dns_flags & DNS_IPV4_ONLY){

+		dns_flags&=~(DNS_IPV6_ONLY|DNS_IPV6_FIRST);

+	}

+			;

+	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){

+			LOG(L_CRIT, "BUG: dns_cache_init: 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;

+}

+

+

+/* hash function, based on get_hash1_raw, but case insensitive

+ * type is not used (obsolete)

+ * returns the hash value

+ */

+inline static unsigned int dns_hash_no(char* s, int len, int type)

+{

+	char* p;

+	char* end;

+	

+	register unsigned v;

+	register unsigned h;

+	

+	h=0;

+	

+	hash_update_str(s, s+len, p, v, h);

+	end=s+len;

+	for (p=s; p<=(end-4); p+=4){

+		v=((p[0]<<24)+(p[1]<<16)+(p[2]<<8)+p[3])|0x20202020;

+		h+=v^(v>>3);

+	}

+	v=0;

+	for (;p<end; p++){ v<<=8; v+=*p|0x20;}

+	h+=v^(v>>3);

+	return hash_finish(h) % 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) \

+		LOG(L_CRIT, "BUG: %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 (check_lu_lst((l))){  \

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

+			abort(); \

+		} \

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

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

+			abort(); \

+		} \

+		if (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 */

+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;

+	

+	cname_chain=0;

+	ret=0;

+	now=get_ticks_raw();

+	*err=0;

+again:

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

+	DBG("dns_hash_find(%.*s(%d), %d), h=%d\n", name->len, name->s,

+												name->len, type, *h);

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

+		/* automatically remove expired elements */

+		if ((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