DNS resolver and cache parameters use the configuration framework
authorMiklos Tirpak <miklos@iptel.org>
Mon, 11 Feb 2008 09:58:29 +0000 (09:58 +0000)
committerMiklos Tirpak <miklos@iptel.org>
Mon, 11 Feb 2008 09:58:29 +0000 (09:58 +0000)
that makes the config variables changeable on-the-fly.

- The resolver is reinitialized by each child process separately
when dns_retr_time, dns_retr_no, dns_servers_no, or dns_use_search_list
is changed.

- dns_reinit is introduced: the resolver is reinitialized when the
variable is set to 1, and the variable is reseted to 0 again.
It can be set via RPC for example, when /etc/resolv.conf changes,
but none of the SER config parameters are affected.

- A callback function is called by each child process after the resolver
has been reinitialized, if DNS_WATCHDOG_SUPPORT is enabled.

- socket_types is changed to be a global variable, and set by
fix_all_socket_lists(), because we have to remember for
the socket types, and do not allow dns_try_ipv6 to be enabled if there
is no ipv6 interface.

- minor bug is corrected: the expiration check is removed from
dns_cache_clean() function, when non-expired entries are deleted.

18 files changed:
cfg.y
cfg_core.c
cfg_core.h
dns_cache.c
dns_cache.h
forward.c
globals.h
main.c
modules/tm/t_fwd.c
modules/tm/t_msgbuilder.c
modules/tm/t_reply.c
modules/tm/timer.c
modules/tm/uac.c
modules/tm/ut.h
resolve.c
resolve.h
socket_info.c
socket_info.h

diff --git a/cfg.y b/cfg.y
index 25d7299..79ee1de 100644 (file)
--- a/cfg.y
+++ b/cfg.y
@@ -608,45 +608,45 @@ assign_stm:
        | DNS EQUAL error { yyerror("boolean value expected"); }
        | REV_DNS EQUAL NUMBER { received_dns|= ($3)?DO_REV_DNS:0; }
        | REV_DNS EQUAL error { yyerror("boolean value expected"); }
-       | DNS_TRY_IPV6 EQUAL NUMBER   { dns_try_ipv6=$3; }
+       | DNS_TRY_IPV6 EQUAL NUMBER   { default_core_cfg.dns_try_ipv6=$3; }
        | DNS_TRY_IPV6 error { yyerror("boolean value expected"); }
-       | DNS_TRY_NAPTR EQUAL NUMBER   { IF_NAPTR(dns_try_naptr=$3); }
+       | DNS_TRY_NAPTR EQUAL NUMBER   { IF_NAPTR(default_core_cfg.dns_try_naptr=$3); }
        | DNS_TRY_NAPTR error { yyerror("boolean value expected"); }
-       | DNS_SRV_LB EQUAL NUMBER   { IF_DNS_FAILOVER(dns_srv_lb=$3); }
+       | DNS_SRV_LB EQUAL NUMBER   { IF_DNS_FAILOVER(default_core_cfg.dns_srv_lb=$3); }
        | DNS_SRV_LB error { yyerror("boolean value expected"); }
-       | DNS_UDP_PREF EQUAL NUMBER   { IF_NAPTR(dns_udp_pref=$3); }
+       | DNS_UDP_PREF EQUAL NUMBER   { IF_NAPTR(default_core_cfg.dns_udp_pref=$3); }
        | DNS_UDP_PREF error { yyerror("number expected"); }
-       | DNS_TCP_PREF EQUAL NUMBER   { IF_NAPTR(dns_tcp_pref=$3); }
+       | DNS_TCP_PREF EQUAL NUMBER   { IF_NAPTR(default_core_cfg.dns_tcp_pref=$3); }
        | DNS_TCP_PREF error { yyerror("number expected"); }
-       | DNS_TLS_PREF EQUAL NUMBER   { IF_NAPTR(dns_tls_pref=$3); }
+       | DNS_TLS_PREF EQUAL NUMBER   { IF_NAPTR(default_core_cfg.dns_tls_pref=$3); }
        | DNS_TLS_PREF error { yyerror("number expected"); }
-       | DNS_RETR_TIME EQUAL NUMBER   { dns_retr_time=$3; }
+       | DNS_RETR_TIME EQUAL NUMBER   { default_core_cfg.dns_retr_time=$3; }
        | DNS_RETR_TIME error { yyerror("number expected"); }
-       | DNS_RETR_NO EQUAL NUMBER   { dns_retr_no=$3; }
+       | DNS_RETR_NO EQUAL NUMBER   { default_core_cfg.dns_retr_no=$3; }
        | DNS_RETR_NO error { yyerror("number expected"); }
-       | DNS_SERVERS_NO EQUAL NUMBER   { dns_servers_no=$3; }
+       | DNS_SERVERS_NO EQUAL NUMBER   { default_core_cfg.dns_servers_no=$3; }
        | DNS_SERVERS_NO error { yyerror("number expected"); }
-       | DNS_USE_SEARCH EQUAL NUMBER   { dns_search_list=$3; }
+       | DNS_USE_SEARCH EQUAL NUMBER   { default_core_cfg.dns_search_list=$3; }
        | DNS_USE_SEARCH error { yyerror("boolean value expected"); }
-       | DNS_SEARCH_FMATCH EQUAL NUMBER   { dns_search_fmatch=$3; }
+       | DNS_SEARCH_FMATCH EQUAL NUMBER   { default_core_cfg.dns_search_fmatch=$3; }
        | DNS_SEARCH_FMATCH 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 EQUAL NUMBER   { IF_DNS_FAILOVER(default_core_cfg.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 EQUAL NUMBER   { IF_DNS_CACHE(default_core_cfg.dns_cache_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 EQUAL NUMBER   { IF_DNS_CACHE(default_core_cfg.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 EQUAL NUMBER   { IF_DNS_CACHE(default_core_cfg.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 EQUAL NUMBER   { IF_DNS_CACHE(default_core_cfg.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 EQUAL NUMBER   { IF_DNS_CACHE(default_core_cfg.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"); }
-       | DNS_CACHE_DEL_NONEXP EQUAL NUMBER   { IF_DNS_CACHE(dns_cache_del_nonexp=$3); }
+       | DNS_CACHE_DEL_NONEXP EQUAL NUMBER   { IF_DNS_CACHE(default_core_cfg.dns_cache_del_nonexp=$3); }
        | DNS_CACHE_DEL_NONEXP error { yyerror("boolean value expected"); }
        | USE_DST_BLST EQUAL NUMBER   { IF_DST_BLACKLIST(default_core_cfg.use_dst_blacklist=$3); }
        | USE_DST_BLST error { yyerror("boolean value expected"); }
index 78b8f81..a1e4bd8 100644 (file)
  * History
  * -------
  *  2007-12-03 Initial version (Miklos)
+ *  2008-01-31  added DNS resolver parameters (Miklos)
  */
 
 #include "dprint.h"
+#ifdef USE_DST_BLACKLIST
 #include "dst_blacklist.h"
+#endif
+#include "resolve.h"
+#ifdef USE_DNS_CACHE
+#include "dns_cache.h"
+#endif
 #include "cfg/cfg.h"
 #include "cfg_core.h"
 
 struct cfg_group_core default_core_cfg = {
        L_DEFAULT, /*  print only msg. < L_WARN */
 #ifdef USE_DST_BLACKLIST
+       /* blacklist */
        0, /* dst blacklist is disabled by default */
        DEFAULT_BLST_TIMEOUT,
        DEFAULT_BLST_MAX_MEM,
 #endif
+       /* resolver */
+#ifdef USE_IPV6
+       1,  /* dns_try_ipv6 -- on by default */
+#else
+       0,  /* dns_try_ipv6 -- off, if no ipv6 support */
+#endif
+       0,  /* dns_try_naptr -- off by default */
+       3,  /* udp transport preference (for naptr) */
+       2,  /* tcp transport preference (for naptr) */
+       1,  /* tls transport preference (for naptr) */
+       -1, /* dns_retr_time */
+       -1, /* dns_retr_no */
+       -1, /* dns_servers_no */
+       1,  /* dns_search_list */
+       1,  /* dns_search_fmatch */
+       0,  /* dns_reinit */
+       /* DNS cache */
+#ifdef USE_DNS_CACHE
+       0,  /* dns_cache_flags */
+       0,  /* use_dns_failover -- off by default */
+       0,  /* dns_srv_lb -- off by default */
+       DEFAULT_DNS_NEG_CACHE_TTL, /* neg. cache ttl */
+       DEFAULT_DNS_CACHE_MIN_TTL, /* minimum ttl */
+       DEFAULT_DNS_CACHE_MAX_TTL, /* maximum ttl */
+       DEFAULT_DNS_MAX_MEM, /* dns_cache_max_mem */
+       0, /* dns_cache_del_nonexp -- delete only expired entries by default */
+#endif
 };
 
 void   *core_cfg = &default_core_cfg;
@@ -48,6 +83,7 @@ void  *core_cfg = &default_core_cfg;
 cfg_def_t core_cfg_def[] = {
        {"debug",       CFG_VAR_INT,    0, 0, 0, 0, "debug level"},
 #ifdef USE_DST_BLACKLIST
+       /* blacklist */
        {"use_dst_blacklist",   CFG_VAR_INT,    0, 0, 0, 0,
                "enable/disable destination blacklisting"},
        {"dst_blacklist_expire",        CFG_VAR_INT,    0, 0, 0, 0,
@@ -55,5 +91,64 @@ cfg_def_t core_cfg_def[] = {
        {"dst_blacklist_mem",   CFG_VAR_INT,    0, 0, blst_max_mem_fixup, 0,
                "maximum shared memory amount (in KB) used for keeping the blacklisted destinations"},
 #endif
+       /* resolver */
+#ifdef USE_DNS_CACHE
+       {"dns_try_ipv6",        CFG_VAR_INT,    0, 1, dns_try_ipv6_fixup, fix_dns_flags,
+#else
+       {"dns_try_ipv6",        CFG_VAR_INT,    0, 1, dns_try_ipv6_fixup, 0,
+#endif
+               "enable/disable IPv6 DNS lookups"},
+#ifdef USE_DNS_CACHE
+       {"dns_try_naptr",       CFG_VAR_INT,    0, 1, 0, fix_dns_flags,
+#else
+       {"dns_try_naptr",       CFG_VAR_INT,    0, 1, 0, 0,
+#endif
+               "enable/disable NAPTR DNS lookups"},
+       {"dns_udp_pref",        CFG_VAR_INT,    0, 0, 0, reinit_naptr_proto_prefs,
+               "udp protocol preference when doing NAPTR lookups"},
+       {"dns_tcp_pref",        CFG_VAR_INT,    0, 0, 0, reinit_naptr_proto_prefs,
+               "tcp protocol preference when doing NAPTR lookups"},
+       {"dns_tls_pref",        CFG_VAR_INT,    0, 0, 0, reinit_naptr_proto_prefs,
+               "tls protocol preference when doing NAPTR lookups"},
+       {"dns_retr_time",       CFG_VAR_INT,    0, 0, 0, resolv_reinit,
+               "time in s before retrying a dns request"},
+       {"dns_retr_no",         CFG_VAR_INT,    0, 0, 0, resolv_reinit,
+               "number of dns retransmissions before giving up"},
+       {"dns_servers_no",      CFG_VAR_INT,    0, 0, 0, resolv_reinit,
+               "how many dns servers from the ones defined in "
+               "/etc/resolv.conf will be used"},
+       {"dns_use_search_list", CFG_VAR_INT,    0, 1, 0, resolv_reinit,
+               "if set to 0, the search list in /etc/resolv.conf is ignored"},
+       {"dns_search_full_match",       CFG_VAR_INT,    0, 1, 0, 0,
+               "enable/disable domain name checks against the search list "
+               "in DNS answers"},
+       {"dns_reinit",          CFG_VAR_INT|CFG_INPUT_INT,      1, 1, dns_reinit_fixup, resolv_reinit,
+               "set to 1 in order to reinitialize the DNS resolver"},
+       /* DNS cache */
+#ifdef USE_DNS_CACHE
+       {"dns_cache_flags",     CFG_VAR_INT,    0, 4, 0, fix_dns_flags,
+               "dns cache specific resolver flags "
+               "(1=ipv4 only, 2=ipv6 only, 4=prefer ipv6"},
+       {"use_dns_failover",    CFG_VAR_INT,    0, 1, use_dns_failover_fixup, 0,
+               "enable/disable dns failover in case the destination "
+               "resolves to multiple ip addresses and/or multiple SRV records "
+               "(depends on use_dns_cache)"},
+       {"dns_srv_lb",          CFG_VAR_INT,    0, 1, 0, fix_dns_flags,
+               "enable/disable load balancing to different srv records "
+               "of the same priority based on the srv records weights "
+               "(depends on dns_failover)"},
+       {"dns_cache_negative_ttl",      CFG_VAR_INT,    0, 0, 0, 0,
+               "time to live for negative results (\"not found\") "
+               "in seconds. Use 0 to disable"},
+       {"dns_cache_min_ttl",   CFG_VAR_INT,    0, 0, 0, 0,
+               "minimum accepted time to live for a record, in seconds"},
+       {"dns_cache_max_ttl",   CFG_VAR_INT,    0, 0, 0, 0,
+               "maximum accepted time to live for a record, in seconds"},
+       {"dns_cache_mem",       CFG_VAR_INT,    0, 0, dns_cache_max_mem_fixup, 0,
+               "maximum memory used for the dns cache in Kb"},
+       {"dns_cache_del_nonexp",        CFG_VAR_INT,    0, 1, 0, 0,
+               "allow deletion of non-expired records from the cache when "
+               "there is no more space left for new ones"},
+#endif
        {0, 0, 0, 0, 0, 0}
 };
index 4152c62..06b1d43 100644 (file)
@@ -47,11 +47,35 @@ extern void *core_cfg;
 struct cfg_group_core {
        int     debug;
 #ifdef USE_DST_BLACKLIST
+       /* blacklist */
        int     use_dst_blacklist; /* 1 if blacklist is enabled */
        unsigned int    blst_timeout; /* blacklist entry ttl */
        unsigned int    blst_max_mem; /* maximum memory used for the
                                        blacklist entries */
 #endif
+       /* resolver */
+       int dns_try_ipv6;
+       int dns_try_naptr;
+       int dns_udp_pref;
+       int dns_tcp_pref;
+       int dns_tls_pref;
+       int dns_retr_time;
+       int dns_retr_no;
+       int dns_servers_no;
+       int dns_search_list;
+       int dns_search_fmatch;
+       int dns_reinit;
+       /* DNS cache */
+#ifdef USE_DNS_CACHE
+       int dns_cache_flags;
+       int use_dns_failover;
+       int dns_srv_lb;
+       unsigned int dns_neg_cache_ttl;
+       unsigned int dns_cache_min_ttl;
+       unsigned int dns_cache_max_ttl;
+       unsigned int dns_cache_max_mem;
+       int dns_cache_del_nonexp;
+#endif
 };
 
 extern struct cfg_group_core default_core_cfg;
index 2889c69..62399ac 100644 (file)
@@ -39,6 +39,8 @@
  *             of the cache (Miklos)
  *  2007-07-30  DNS cache measurements added (Gergo)
  *  2007-08-17  dns_cache_del_nonexp config option is introduced (Miklos)
+ *  2008-02-04  DNS cache options are adapted for the configuration
+ *             framework (Miklos)
  */
 
 #ifdef USE_DNS_CACHE
@@ -48,6 +50,7 @@
 #endif
 
 #include "globals.h"
+#include "cfg_core.h"
 #include "dns_cache.h"
 #include "dns_wrappers.h"
 #include "compiler_opt.h"
                                                           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) */
-int dns_srv_lb=0; /* off by default */
-int dns_cache_del_nonexp=0; /* delete only expired entries by default */
 
 #ifdef USE_DNS_CACHE_STATS
 struct t_dns_cache_stats* dns_cache_stats=0;
@@ -109,8 +101,12 @@ struct t_dns_cache_stats* dns_cache_stats=0;
 #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)))
+#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{
@@ -216,8 +212,8 @@ static ticks_t dns_timer(ticks_t ticks, struct timer_ln* tl, void* data)
        if (atomic_get(dns_servers_up) == 0)
                return (ticks_t)(-1);
 #endif
-       if (*dns_cache_mem_used>12*(dns_cache_max_mem/16)){ /* ~ 75% used */
-               dns_cache_free_mem(dns_cache_max_mem/2, 1);
+       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? */
@@ -265,7 +261,62 @@ void destroy_dns_cache()
        }
 }
 
+/* set the value of dns_flags */
+void fix_dns_flags(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
+               LOG(L_WARN, "WARING: fix_dns_flags: 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
+       LOG(L_WARN, "WARING: fix_dns_flags: 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 *name, void **val)
+{
+       if ((int)(long)(*val) && !use_dns_cache) {
+               LOG(L_ERR, "ERROR: use_dns_failover_fixup(): "
+                       "DNS cache is turned off, failover cannot be enabled. "
+                       "(set use_dns_cache to 1)\n");
+               return -1;
+       }
+       return 0;
+}
+
+/* KByte to Byte conversion */
+int dns_cache_max_mem_fixup(void *handle, str *name, void **val)
+{
+       unsigned int    u;
+
+       u = ((unsigned int)(long)(*val))<<10;
+       (*val) = (void *)(long)u;
+       return 0;
+}
 
 int init_dns_cache()
 {
@@ -322,29 +373,10 @@ int init_dns_cache()
 #endif
 
        /* fix options */
-       dns_cache_max_mem<<=10; /* Kb */ /* TODO: test with 0 */
+       default_core_cfg.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);
-       }
-       if (dns_srv_lb){
-#ifdef DNS_SRV_LB
-               dns_flags|=DNS_SRV_RR_LB;
-#else
-               LOG(L_WARN, "WARING: dns_cache_init: SRV loadbalaning is set, but"
-                                       " support for it is not compiled -- ignoring\n");
-#endif
-       }
-       if (dns_try_naptr){
-#ifndef USE_NAPTR
-       LOG(L_WARN, "WARING: dns_cache_init: NAPTR support is enabled, but"
-                               " support for it is not compiled -- ignoring\n");
-#endif
-               dns_flags|=DNS_TRY_NAPTR;
-       }
+       fix_dns_flags(NULL);
+
        dns_timer_h=timer_alloc();
        if (dns_timer_h==0){
                ret=E_OUT_OF_MEM;
@@ -599,10 +631,8 @@ inline static int dns_cache_clean(unsigned int no, int expired_only)
        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  ((s_ticks_t)(now-e->expire)>=0){
-                                       _dns_hash_remove(e);
-                                       deleted++;
-                               }
+                               _dns_hash_remove(e);
+                               deleted++;
                                n++;
                                if (n>=no) goto skip;
                        }
@@ -714,14 +744,15 @@ inline static int dns_cache_add(struct dns_hash_entry* e)
 
        /* check space */
        /* atomic_add_long(dns_cache_total_used, e->size); */
-       if ((*dns_cache_mem_used+e->total_size)>=dns_cache_max_mem){
+       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
                LOG(L_WARN, "WARNING: dns_cache_add: cache full, trying to free...\n");
                /* free ~ 12% of the cache */
-               dns_cache_free_mem(*dns_cache_mem_used/16*14, !dns_cache_del_nonexp);
-               if ((*dns_cache_mem_used+e->total_size)>=dns_cache_max_mem){
+               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)){
                        LOG(L_ERR, "ERROR: dns_cache_add: max. cache mem size exceeded\n");
                        return -1;
                }
@@ -753,16 +784,17 @@ inline static int dns_cache_add_unsafe(struct dns_hash_entry* e)
 
        /* check space */
        /* atomic_add_long(dns_cache_total_used, e->size); */
-       if ((*dns_cache_mem_used+e->total_size)>=dns_cache_max_mem){
+       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
                LOG(L_WARN, "WARNING: dns_cache_add: cache full, trying to free...\n");
                /* free ~ 12% of the cache */
                UNLOCK_DNS_HASH();
-               dns_cache_free_mem(*dns_cache_mem_used/16*14, !dns_cache_del_nonexp);
+               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)>=dns_cache_max_mem){
+               if ((*dns_cache_mem_used+e->total_size)>=cfg_get(core, core_cfg, dns_cache_max_mem)){
                        LOG(L_ERR, "ERROR: dns_cache_add: max. cache mem size exceeded\n");
                        return -1;
                }
@@ -1672,8 +1704,8 @@ inline static struct dns_hash_entry* dns_cache_do_request(str* name, int type)
                l=dns_cache_mk_rd_entry2(records);
 #endif
                free_rdata_list(records);
-       }else if (dns_neg_cache_ttl){
-               e=dns_cache_mk_bad_entry(name, type, dns_neg_cache_ttl, DNS_BAD_NAME);
+       }else if (cfg_get(core, core_cfg, dns_neg_cache_ttl)){
+               e=dns_cache_mk_bad_entry(name, type, cfg_get(core, core_cfg, dns_neg_cache_ttl), DNS_BAD_NAME);
                atomic_set(&e->refcnt, 1); /* 1 because we return a ref. to it */
                dns_cache_add(e); /* refcnt++ inside*/
                goto end;
@@ -3144,7 +3176,7 @@ void dns_cache_mem_info(rpc_t* rpc, void* ctx)
                rpc->fault(ctx, 500, "dns cache support disabled (see use_dns_cache)");
                return;
        }
-       rpc->add(ctx, "dd",  *dns_cache_mem_used, dns_cache_max_mem);
+       rpc->add(ctx, "dd",  *dns_cache_mem_used, cfg_get(core, core_cfg, dns_cache_max_mem));
 }
 
 
index 7ba3ce9..8ba753d 100644 (file)
 #error "DNS WATCHDOG requires DNS CACHE support (define USE_DNS_CACHE)"
 #endif
 
+#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 */
+
 /* uncomment the define below for SRV weight based load balancing */
 #define DNS_SRV_LB
 
@@ -173,6 +178,9 @@ struct dns_srv_handle{
 
 const char* dns_strerror(int err);
 
+void fix_dns_flags(str *name);
+int use_dns_failover_fixup(void *handle, str *name, void **val);
+int dns_cache_max_mem_fixup(void *handle, str *name, void **val);
 int init_dns_cache();
 #ifdef USE_DNS_CACHE_STATS
 int init_dns_cache_stats(int iproc_num);
index 71a8242..b6c543d 100644 (file)
--- a/forward.c
+++ b/forward.c
@@ -319,7 +319,7 @@ int forward_request(struct sip_msg* msg, str* dst, unsigned short port,
 
        if(dst){
 #ifdef USE_DNS_FAILOVER
-               if (use_dns_failover){
+               if (cfg_get(core, core_cfg, use_dns_failover)){
                        dns_srv_handle_init(&dns_srv_h);
                        err=dns_sip_resolve2su(&dns_srv_h, &send_info->to, dst, port,
                                                                        &send_info->proto, dns_flags);
@@ -454,7 +454,8 @@ int forward_request(struct sip_msg* msg, str* dst, unsigned short port,
                        goto end;
                }
 #ifdef USE_DNS_FAILOVER
-       }while(dst && use_dns_failover && dns_srv_handle_next(&dns_srv_h, err) && 
+       }while(dst && cfg_get(core, core_cfg, use_dns_failover) &&
+                       dns_srv_handle_next(&dns_srv_h, err) && 
                        ((err=dns_sip_resolve2su(&dns_srv_h, &send_info->to, dst, port,
                                                                  &send_info->proto, dns_flags))==0));
        if ((err!=0) && (err!=-E_DNS_EOR)){
@@ -471,7 +472,7 @@ error:
        STATS_TX_DROPS;
 end:
 #ifdef USE_DNS_FAILOVER
-       if (dst && use_dns_failover){
+       if (dst && cfg_get(core, core_cfg, use_dns_failover)){
                                dns_srv_handle_put(&dns_srv_h);
        }
 #endif
index 4ac0e94..04d5bc3 100644 (file)
--- a/globals.h
+++ b/globals.h
@@ -190,26 +190,11 @@ extern int rt_timer1_policy; /* "fast" timer, SCHED_OTHER */
 extern int rt_timer2_policy; /* "slow" timer, SCHED_OTHER */
 
 
-
-/* resolver */
-extern int dns_retr_time;
-extern int dns_retr_no;
-extern int dns_servers_no;
-extern int dns_search_list;
-extern int dns_search_fmatch;
 #ifdef USE_DNS_CACHE
 extern int use_dns_cache; /* 1 if the cache is enabled, 0 otherwise */
-extern int use_dns_failover; /* 1 if failover is enabled, 0 otherwise */
-extern unsigned int dns_cache_max_mem; /* maximum memory used for the cached
-                                                                                 entries*/
-extern unsigned int dns_neg_cache_ttl; /* neg. cache ttl */
-extern unsigned int dns_cache_max_ttl; /* maximum ttl */
-extern unsigned int dns_cache_min_ttl; /* minimum ttl */
 extern unsigned int dns_timer_interval; /* gc timer interval in s */
 extern int dns_flags; /* default flags used for the  dns_*resolvehost
                     (compatibility wrappers) */
-extern int dns_srv_lb; /* default SRV LB support value */
-extern int dns_cache_del_nonexp; /* delete non-expired values from the cache when it is full */
 
 #ifdef USE_DNS_CACHE_STATS
 struct t_dns_cache_stats{
diff --git a/main.c b/main.c
index a5f8db9..1ed2167 100644 (file)
--- a/main.c
+++ b/main.c
@@ -374,7 +374,6 @@ int mcast_ttl = -1; /* if -1, don't touch it, use the default (usually 1) */
 #endif /* USE_MCAST */
 #ifdef USE_DNS_CACHE
 int use_dns_cache=1; /* 1 if the cache is enabled, 0 otherwise */
-int use_dns_failover=0; /* 1 if failover is enabled, 0 otherwise */
 #endif
 
 int tos = IPTOS_LOWDELAY;
@@ -1279,7 +1278,6 @@ int main(int argc, char** argv)
        int rfd;
        int debug_save, debug_flag;
        int dont_fork_cnt;
-       int socket_types;
 
        /*init*/
        creator_pid = getpid();
@@ -1606,14 +1604,14 @@ try_again:
                        goto error;
                }
        }
-       if (fix_all_socket_lists(&socket_types)!=0){
+       if (fix_all_socket_lists()!=0){
                fprintf(stderr,  "failed to initialize list addresses\n");
                goto error;
        }
-       if (dns_try_ipv6 && !(socket_types & SOCKET_T_IPV6)){
+       if (default_core_cfg.dns_try_ipv6 && !(socket_types & SOCKET_T_IPV6)){
                /* if we are not listening on any ipv6 address => no point
                 * to try to resovle ipv6 addresses */
-               dns_try_ipv6=0;
+               default_core_cfg.dns_try_ipv6=0;
        }
        /* print all the listen addresses */
        printf("Listening on \n");
@@ -1660,7 +1658,7 @@ try_again:
                goto error;
        }
        if (use_dns_cache==0)
-               use_dns_failover=0; /* cannot work w/o dns_cache support */
+               default_core_cfg.use_dns_failover=0; /* cannot work w/o dns_cache support */
 #ifdef USE_DNS_CACHE_STATS
        /* preinitializing before the nubmer of processes is determined */
        if (init_dns_cache_stats(1)<0){
index ebd7eaf..30775d1 100644 (file)
 #include "config.h"
 #ifdef USE_DNS_FAILOVER
 #include "../../dns_cache.h"
+#include "../../cfg_core.h" /* cfg_get(core, core_cfg, use_dns_failover) */
 #endif
 #ifdef USE_DST_BLACKLIST
 #include "../../dst_blacklist.h"
@@ -395,7 +396,7 @@ int add_uac_dns_fallback( struct cell *t, struct sip_msg* msg,
        int ret;
        
        ret=-1;
-       if (use_dns_failover && 
+       if (cfg_get(core, core_cfg, use_dns_failover) && 
                        !((t->flags & T_DONT_FORK) || uac_dont_fork(old_uac)) &&
                        dns_srv_handle_next(&old_uac->dns_h, 0)){
                        if (lock_replies){
@@ -674,7 +675,7 @@ int t_send_branch( struct cell *t, int branch, struct sip_msg* p_msg ,
 #ifdef USE_DNS_FAILOVER
                        /* if the destination resolves to more ips, add another
                         *  branch/uac */
-                       if (use_dns_failover){
+                       if (cfg_get(core, core_cfg, use_dns_failover)){
                                ret=add_uac_dns_fallback(t, p_msg, uac, lock_replies);
                                if (ret>=0){
                                        su2ip_addr(&ip, &uac->request.dst.to);
@@ -709,7 +710,7 @@ int t_send_branch( struct cell *t, int branch, struct sip_msg* p_msg ,
 #ifdef USE_DNS_FAILOVER
                        /* if the destination resolves to more ips, add another
                         *  branch/uac */
-                       if (use_dns_failover){
+                       if (cfg_get(core, core_cfg, use_dns_failover)){
                                ret=add_uac_dns_fallback(t, p_msg, uac, lock_replies);
                                if (ret>=0){
                                        su2ip_addr(&ip, &uac->request.dst.to);
@@ -744,7 +745,7 @@ int t_send_branch( struct cell *t, int branch, struct sip_msg* p_msg ,
 #ifdef USE_DNS_FAILOVER
                /* if the destination resolves to more ips, add another
                 *  branch/uac */
-               if (use_dns_failover){
+               if (cfg_get(core, core_cfg, use_dns_failover)){
                        ret=add_uac_dns_fallback(t, p_msg, uac, lock_replies);
                        if (ret>=0){
                                /* success, return new branch */
index 42f4a8e..c3afb91 100644 (file)
@@ -66,6 +66,7 @@
 #include "uac.h"
 #ifdef USE_DNS_FAILOVER
 #include "../../dns_cache.h"
+#include "../../cfg_core.h" /* cfg_get(core, core_cfg, use_dns_failover) */
 #endif
 
 
@@ -598,7 +599,7 @@ char *build_dlg_ack(struct sip_msg* rpl, struct cell *Trans,
        
         /* via */
 #ifdef USE_DNS_FAILOVER
-       if (use_dns_failover){
+       if (cfg_get(core, core_cfg, use_dns_failover)){
                dns_srv_handle_init(&dns_h);
                if ((uri2dst(&dns_h , dst, rpl, &next_hop, PROTO_NONE)==0) ||
                                (dst->send_sock==0)){
index 8d22998..cf2f7fd 100644 (file)
 #ifdef USE_DST_BLACKLIST
 #include "../../dst_blacklist.h"
 #endif
+#ifdef USE_DNS_FAILOVER
+#include "../../dns_cache.h"
+#include "../../cfg_core.h" /* cfg_get(core, core_cfg, use_dns_failover) */
+#endif
 
 #include "defs.h"
 #include "h_table.h"
@@ -415,7 +419,7 @@ static int send_local_ack(struct sip_msg* msg, str* next_hop,
                return -1;
        }
 #ifdef USE_DNS_FAILOVER
-       if (use_dns_failover){
+       if (cfg_get(core, core_cfg, use_dns_failover)){
                dns_srv_handle_init(&dns_h);
                if ((uri2dst(&dns_h, &dst, msg,  next_hop, PROTO_NONE)==0) || 
                                (dst.send_sock==0)){
@@ -1837,7 +1841,10 @@ int reply_received( struct sip_msg  *p_msg )
                 *  This code is out of LOCK_REPLIES() to minimize the time the
                 *  reply lock is held (the lock won't be held while sending the
                 *   message)*/
-               if (use_dns_failover && (msg_status==503) && uac->request.t_active){
+               if (cfg_get(core, core_cfg, use_dns_failover) && 
+                       (msg_status==503) &&
+                       uac->request.t_active
+               ) {
                        branch_ret=add_uac_dns_fallback(t, t->uas.request, uac, 1);
                        prev_branch=-1;
                        while((branch_ret>=0) &&(branch_ret!=prev_branch)){
index f6ee0e0..03983e3 100644 (file)
 #include "t_hooks.h"
 #ifdef USE_DNS_FAILOVER
 #include "t_fwd.h" /* t_send_branch */
+#include "../../cfg_core.h" /* cfg_get(core, core_cfg, use_dns_failover) */
 #endif
 #ifdef USE_DST_BLACKLIST
 #include "../../dst_blacklist.h"
@@ -467,7 +468,7 @@ inline static void final_response_handler(  struct retr_buf* r_buf,
                /* if this is an invite, the destination resolves to more ips, and
                 *  it still hasn't passed more than fr_inv_timeout since we
                 *  started, add another branch/uac */
-               if (use_dns_failover){
+               if (cfg_get(core, core_cfg, use_dns_failover)){
                        now=get_ticks_raw();
                        if ((s_ticks_t)(t->end_of_life-now)>0){
                                branch_ret=add_uac_dns_fallback(t, t->uas.request,
index 55f86ad..e6238dc 100644 (file)
 #include "callid.h"
 #include "uac.h"
 #include "t_stats.h"
+#ifdef USE_DNS_FAILOVER
+#include "../../dns_cache.h"
+#include "../../cfg_core.h" /* cfg_get(core, core_cfg, use_dns_failover) */
+#endif
 
 
 #define FROM_TAG_LEN (MD5_LEN + 1 /* - */ + CRC16_LEN) /* length of FROM tags */
@@ -217,7 +221,7 @@ static inline int t_uac_prepare(uac_req_t *uac_r,
                        uac_r->dialog->hooks.next_hop->s);
        /* it's a new message, so we will take the default socket */
 #ifdef USE_DNS_FAILOVER
-       if (use_dns_failover){
+       if (cfg_get(core, core_cfg, use_dns_failover)){
                dns_srv_handle_init(&dns_h);
                if ((uri2dst(&dns_h, &dst, 0, uac_r->dialog->hooks.next_hop, PROTO_NONE)==0)
                                || (dst.send_sock==0)){
index e6d6544..a497b81 100644 (file)
@@ -58,6 +58,7 @@
 #include "../../resolve.h"
 #ifdef USE_DNS_FAILOVER
 #include "../../dns_cache.h"
+#include "../../cfg_core.h" /* cfg_get(core, core_cfg, use_dns_failover) */
 #endif
 
 /* a forced_proto takes precedence if != PROTO_NONE */
@@ -270,7 +271,7 @@ inline static struct dest_info *uri2dst(struct dest_info* dst,
 #endif
                host=&parsed_uri.host;
 #ifdef USE_DNS_FAILOVER
-       if (use_dns_failover && dns_h){
+       if (cfg_get(core, core_cfg, use_dns_failover) && dns_h){
                ip_found=0;
                do{
                        /* try all the ips until we find a good send socket */
index 19781a5..fe18e43 100644 (file)
--- a/resolve.c
+++ b/resolve.c
@@ -41,6 +41,8 @@
  *              new option dns_search_full_match (default on) controls
  *              whether rest of the name is matched against search list
  *              or blindly accepted (better performance but exploitable)
+ *  2008-01-31  resolver options use the configuration framework, and the
+ *             resolver is reinitialized when the options change (Miklos)
  */ 
 
 
@@ -57,6 +59,8 @@
 #include "ip_addr.h"
 #include "error.h"
 #include "globals.h" /* tcp_disable, tls_disable a.s.o */
+#include "cfg_core.h"
+#include "socket_info.h"
 
 #ifdef USE_DNS_CACHE
 #include "dns_cache.h"
 #define local_malloc pkg_malloc
 #define local_free   pkg_free
 
-#ifdef USE_IPV6
-int dns_try_ipv6=1; /* default on */
-#else
-int dns_try_ipv6=0; /* off, if no ipv6 support */
-#endif
-int dns_try_naptr=0;  /* off by default */
-
-int dns_udp_pref=3;  /* udp transport preference (for naptr) */
-int dns_tcp_pref=2;  /* tcp transport preference (for naptr) */
-int dns_tls_pref=1;  /* tls transport preference (for naptr) */
-
 #ifdef USE_NAPTR
 #define PROTO_LAST  PROTO_SCTP
 static int naptr_proto_pref[PROTO_LAST];
 #endif
 
-/* declared in globals.h */
-int dns_retr_time=-1;
-int dns_retr_no=-1;
-int dns_servers_no=-1;
-int dns_search_list=-1;
-int dns_search_fmatch=-1;
-
 #ifdef USE_NAPTR
 void init_naptr_proto_prefs()
 {
@@ -99,14 +85,28 @@ void init_naptr_proto_prefs()
                BUG("init_naptr_proto_prefs: array too small \n");
                return;
        }
-       naptr_proto_pref[PROTO_UDP]=dns_udp_pref;
-       naptr_proto_pref[PROTO_TCP]=dns_tcp_pref;
-       naptr_proto_pref[PROTO_TLS]=dns_tls_pref;
+       naptr_proto_pref[PROTO_UDP]=cfg_get(core, core_cfg, dns_udp_pref);
+       naptr_proto_pref[PROTO_TCP]=cfg_get(core, core_cfg, dns_tcp_pref);
+       naptr_proto_pref[PROTO_TLS]=cfg_get(core, core_cfg, dns_tls_pref);
 }
 
 #endif /* USE_NAPTR */
 
+#ifdef DNS_WATCHDOG_SUPPORT
+static on_resolv_reinit        on_resolv_reinit_cb = NULL;
 
+/* register the callback function */
+int register_resolv_reinit_cb(on_resolv_reinit cb)
+{
+       if (on_resolv_reinit_cb) {
+               LOG(L_ERR, "ERROR: register_resolv_reinit_cb(): "
+                       "callback function has been already registered\n");
+               return -1;
+       }
+       on_resolv_reinit_cb = cb;
+       return 0;
+}
+#endif
 
 /* init. the resolver
  * params: retr_time  - time before retransmitting (must be >0)
@@ -122,30 +122,82 @@ void init_naptr_proto_prefs()
  * will be used. See also resolv.conf(5).
  * returns: 0 on success, -1 on error
  */
-int resolv_init()
+static int _resolv_init()
 {
        res_init();
 #ifdef HAVE_RESOLV_RES
-       if (dns_retr_time>0)
-               _res.retrans=dns_retr_time;
-       if (dns_retr_no>0)
-               _res.retry=dns_retr_no;
-       if (dns_servers_no>=0)
-               _res.nscount=dns_servers_no;
-       if (dns_search_list==0)
+       if (cfg_get(core, core_cfg, dns_retr_time)>0)
+               _res.retrans=cfg_get(core, core_cfg, dns_retr_time);
+       if (cfg_get(core, core_cfg, dns_retr_no)>0)
+               _res.retry=cfg_get(core, core_cfg, dns_retr_no);
+       if (cfg_get(core, core_cfg, dns_servers_no)>=0)
+               _res.nscount=cfg_get(core, core_cfg, dns_servers_no);
+       if (cfg_get(core, core_cfg, dns_search_list)==0)
                _res.options&=~(RES_DEFNAMES|RES_DNSRCH);
 #else
 #warning "no resolv timeout support"
-       LOG(L_WARN, "WARNING: resolv_init: no resolv options support - resolv"
+       LOG(L_WARN, "WARNING: _resolv_init: no resolv options support - resolv"
                        " options will be ignored\n");
 #endif
+       return 0;
+}
+
+/* wrapper function to initialize the resolver at startup */
+int resolv_init()
+{
+       _resolv_init();
+
 #ifdef USE_NAPTR
        init_naptr_proto_prefs();
 #endif
        return 0;
 }
 
+/* wrapper function to reinitialize the resolver
+ * This function must be called by each child process whenever
+ * a resolver option changes
+ */
+void resolv_reinit(str *name)
+{
+       _resolv_init();
+
+#ifdef DNS_WATCHDOG_SUPPORT
+       if (on_resolv_reinit_cb) on_resolv_reinit_cb();
+#endif
+       LOG(L_DBG, "DEBUG: resolv_reinit(): "
+               "DNS resolver has been reinitialized\n");
+}
+
+/* fixup function for dns_reinit variable
+ * (resets the variable to 0)
+ */
+int dns_reinit_fixup(void *handle, str *name, void **val)
+{
+       *val = (void *)(long)0;
+       return 0;
+}
+
+/* wrapper function to recalculate the naptr protocol preferences */
+void reinit_naptr_proto_prefs(str *name)
+{
+#ifdef USE_NAPTR
+       init_naptr_proto_prefs();
+#endif
+}
 
+/* fixup function for dns_try_ipv6
+ * verifies that SER really listens on an ipv6 interface
+ */
+int dns_try_ipv6_fixup(void *handle, str *name, void **val)
+{
+       if ((int)(long)(*val) && !(socket_types & SOCKET_T_IPV6)) {
+               LOG(L_ERR, "ERROR: dns_try_ipv6_fixup(): "
+                       "SER does not listen on any ipv6 interface, "
+                       "there is no point in resolving ipv6 addresses\n");
+               return -1;
+       }
+       return 0;
+}
 
  /*  skips over a domain name in a dns message
  *  (it can be  a sequence of labels ending in \0, a pointer or
@@ -459,7 +511,7 @@ struct rdata* get_record(char* name, int type, int flags)
        int name_len;
        struct rdata* fullname_rd;
        
-       if (dns_search_list==0) {
+       if (cfg_get(core, core_cfg, dns_search_list)==0) {
                search_list_used=0;
                name_len=0;
        } else {
@@ -574,7 +626,7 @@ again:
                        /* this is safe.... here was rec_name_len > name_len */
                        else if (rec_name[name_len]=='.') {
 #ifdef HAVE_RESOLV_RES
-                               if ((dns_search_fmatch==0) ||
+                               if ((cfg_get(core, core_cfg, dns_search_fmatch)==0) ||
                                                (match_search_list(&_res, rec_name+name_len+1)!=0))
 #endif
                                        fullname_rd=rd;
@@ -1221,7 +1273,7 @@ end:
 struct hostent* _sip_resolvehost(str* name, unsigned short* port, char* proto)
 {
 #ifdef USE_NAPTR
-       if (dns_try_naptr)
+       if (cfg_get(core, core_cfg, dns_try_naptr))
                return naptr_sip_resolvehost(name, port, proto);
 #endif
        return srv_sip_resolvehost(name, 0, port, proto, 0, 0);
index 0402611..1ac54c2 100644 (file)
--- a/resolve.h
+++ b/resolve.h
@@ -159,12 +159,6 @@ struct rdata* get_record(char* name, int type, int flags);
 void free_rdata_list(struct rdata* head);
 
 
-extern int dns_try_ipv6;
-extern int dns_try_naptr;
-extern int dns_udp_pref;  /* udp transport preference (for naptr) */
-extern int dns_tcp_pref;  /* tcp transport preference (for naptr) */
-extern int dns_tls_pref;  /* tls transport preference (for naptr) */
-
 
 #define rev_resolvehost(ip)\
                                        gethostbyaddr((char*)(ip)->u.addr, (ip)->len, (ip)->af)
@@ -382,7 +376,7 @@ static inline struct hostent* _resolvehost(char* name)
        /* ipv4 */
        he=gethostbyname(name);
 #ifdef USE_IPV6
-       if(he==0 && dns_try_ipv6){
+       if(he==0 && cfg_get(core, core_cfg, dns_try_ipv6)){
 #ifndef DNS_IP_HACK
 skip_ipv4:
 #endif
@@ -407,9 +401,27 @@ skip_ipv4:
 }
 
 
-
 int resolv_init();
 
+/* callback/fixup functions executed by the configuration framework */
+void resolv_reinit(str *name);
+int dns_reinit_fixup(void *handle, str *name, void **val);
+int dns_try_ipv6_fixup(void *handle, str *name, void **val);
+void reinit_naptr_proto_prefs(str *name);
+
+#ifdef DNS_WATCHDOG_SUPPORT
+/* callback function that is called by the child processes
+ * when they reinitialize the resolver
+ *
+ * Note, that this callback is called by each chiled process separately!!!
+ * If the callback is registered after forking, only the child process
+ * that installs the hook will call the callback.
+ */
+typedef void (*on_resolv_reinit)(void);
+int register_resolv_reinit_cb(on_resolv_reinit cb);
+#endif
+
+
 int sip_hostport2su(union sockaddr_union* su, str* host, unsigned short port,
                                                char* proto);
 
index f7aa7f4..d023355 100644 (file)
@@ -715,18 +715,15 @@ error:
        return -1;
 }
 
-
+int socket_types = 0;
 
 /* fix all 3 socket lists, fills socket_types if non-null
  * return 0 on success, -1 on error */
-int fix_all_socket_lists(int* socket_types)
+int fix_all_socket_lists()
 {
        struct utsname myname;
        int flags;
        
-       if (socket_types)
-               *socket_types=0;
-       
        if ((udp_listen==0)
 #ifdef USE_TCP
                        && (tcp_listen==0)
@@ -771,8 +768,8 @@ int fix_all_socket_lists(int* socket_types)
                                " udp failed\n");
                goto error;
        }
-       if (flags && socket_types){
-               *socket_types|=flags|SOCKET_T_UDP;
+       if (flags){
+               socket_types|=flags|SOCKET_T_UDP;
        }
 #ifdef USE_TCP
        if (!tcp_disable && (fix_socket_list(&tcp_listen, &flags)!=0)){
@@ -780,8 +777,8 @@ int fix_all_socket_lists(int* socket_types)
                                " tcp failed\n");
                goto error;
        }
-       if (flags && socket_types){
-               *socket_types|=flags|SOCKET_T_TCP;
+       if (flags){
+               socket_types|=flags|SOCKET_T_TCP;
        }
 #ifdef USE_TLS
        if (!tls_disable && (fix_socket_list(&tls_listen, &flags)!=0)){
@@ -789,8 +786,8 @@ int fix_all_socket_lists(int* socket_types)
                                " tls failed\n");
                goto error;
        }
-       if (flags && socket_types){
-               *socket_types|=flags|SOCKET_T_TLS;
+       if (flags){
+               socket_types|=flags|SOCKET_T_TLS;
        }
 #endif
 #endif
index cf8aae9..21033f3 100644 (file)
@@ -59,10 +59,11 @@ struct socket_info* tls_listen;
 #define SOCKET_T_TCP  8
 #define SOCKET_T_TLS 16
 
+extern int socket_types;
 
 int add_listen_iface(char* name, unsigned short port, unsigned short proto,
                                                        enum si_flags flags);
-int fix_all_socket_lists(int* socket_types);
+int fix_all_socket_lists();
 void print_all_socket_lists();
 void print_aliases();