Index: channels/chan_iax2.c
===================================================================
--- channels/chan_iax2.c	(revision 12869)
+++ channels/chan_iax2.c	(working copy)
@@ -402,6 +402,7 @@
 	int callno;				/*!< Associated call number if applicable */
 	struct sockaddr_in us;			/*!< Who the server thinks we are */
 	struct iax2_registry *next;
+	struct ast_dnsmgr_entry *dnsmgr;	/*!< DNS refresh manager */
 };
 
 static struct iax2_registry *registrations;
@@ -4356,8 +4357,8 @@
 
 static int iax2_show_registry(int fd, int argc, char *argv[])
 {
-#define FORMAT2 "%-20.20s  %-10.10s  %-20.20s %8.8s  %s\n"
-#define FORMAT "%-20.20s  %-10.10s  %-20.20s %8d  %s\n"
+#define FORMAT2 "%-20.20s  %-6.6s  %-10.10s  %-20.20s %8.8s  %s\n"
+#define FORMAT  "%-20.20s  %-6.6s  %-10.10s  %-20.20s %8d  %s\n"
 	struct iax2_registry *reg;
 	char host[80];
 	char perceived[80];
@@ -4365,14 +4366,19 @@
 	if (argc != 3)
 		return RESULT_SHOWUSAGE;
 	ast_mutex_lock(&peerl.lock);
-	ast_cli(fd, FORMAT2, "Host", "Username", "Perceived", "Refresh", "State");
+	ast_cli(fd, FORMAT2, "Host", "dnsmgr", "Username", "Perceived", "Refresh", "State");
 	for (reg = registrations;reg;reg = reg->next) {
-		snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(iabuf, sizeof(iabuf), reg->addr.sin_addr), ntohs(reg->addr.sin_port));
+		if (reg->addr.sin_addr.s_addr) {
+			snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(iabuf, sizeof(iabuf), reg->addr.sin_addr), ntohs(reg->addr.sin_port));
+		} else {
+			snprintf(host, sizeof(host), "%s:%d", "unresolved", ntohs(reg->addr.sin_port));
+		}
 		if (reg->us.sin_addr.s_addr) 
 			snprintf(perceived, sizeof(perceived), "%s:%d", ast_inet_ntoa(iabuf, sizeof(iabuf), reg->us.sin_addr), ntohs(reg->us.sin_port));
 		else
 			ast_copy_string(perceived, "<Unregistered>", sizeof(perceived));
-		ast_cli(fd, FORMAT, host, 
+		ast_cli(fd, FORMAT, host,
+					(reg->dnsmgr) ? "Y" : "N", 
 					reg->username, perceived, reg->refresh, regstate2str(reg->regstate));
 	}
 	ast_mutex_unlock(&peerl.lock);
@@ -5497,7 +5503,6 @@
 	char *porta;
 	char *stringp=NULL;
 	
-	struct ast_hostent ahp; struct hostent *hp;
 	if (!value)
 		return -1;
 	ast_copy_string(copy, value, sizeof(copy));
@@ -5519,21 +5524,19 @@
 		ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
 		return -1;
 	}
-	hp = ast_gethostbyname(hostname, &ahp);
-	if (!hp) {
-		ast_log(LOG_WARNING, "Host '%s' not found at line %d\n", hostname, lineno);
-		return -1;
-	}
 	reg = malloc(sizeof(struct iax2_registry));
 	if (reg) {
 		memset(reg, 0, sizeof(struct iax2_registry));
+		if (ast_dnsmgr_lookup(hostname, &reg->addr.sin_addr, &reg->dnsmgr) < 0) {
+			free(reg);
+			return -1;
+		}
 		ast_copy_string(reg->username, username, sizeof(reg->username));
 		if (secret)
 			ast_copy_string(reg->secret, secret, sizeof(reg->secret));
 		reg->expire = -1;
 		reg->refresh = IAX_DEFAULT_REG_EXPIRE;
 		reg->addr.sin_family = AF_INET;
-		memcpy(&reg->addr.sin_addr, hp->h_addr, sizeof(&reg->addr.sin_addr));
 		reg->addr.sin_port = porta ? htons(atoi(porta)) : htons(IAX_DEFAULT_PORTNO);
 		reg->next = registrations;
 		reg->callno = 0;
@@ -7629,8 +7632,34 @@
 static int iax2_do_register(struct iax2_registry *reg)
 {
 	struct iax_ie_data ied;
+
 	if (option_debug && iaxdebug)
 		ast_log(LOG_DEBUG, "Sending registration request for '%s'\n", reg->username);
+
+	if (reg->dnsmgr && 
+	    ((reg->regstate == REG_STATE_TIMEOUT) || !reg->addr.sin_addr.s_addr)) {
+		/* Maybe the IP has changed, force DNS refresh */
+		ast_dnsmgr_refresh(reg->dnsmgr, 1);
+	}
+	
+	/*
+	 * if IP has Changed, free allocated call to create a new one with new IP
+	 * call has the pointer to IP and must be updated to the new one
+	 */
+	if (reg->dnsmgr && ast_dnsmgr_changed(reg->dnsmgr) && (reg->callno > 0)) {
+		iax2_destroy(reg->callno);
+		reg->callno = 0;
+	}
+	if (!reg->addr.sin_addr.s_addr) {
+		if (option_debug && iaxdebug)
+			ast_log(LOG_DEBUG, "Unable to send registration request for '%s' without IP address\n", reg->username);
+		/* Setup the next registration attempt */
+		if (reg->expire > -1)
+			ast_sched_del(sched, reg->expire);
+		reg->expire  = ast_sched_add(sched, (5 * reg->refresh / 6) * 1000, iax2_do_register_s, reg);
+		return -1;
+	}
+
 	if (!reg->callno) {
 		if (option_debug)
 			ast_log(LOG_DEBUG, "Allocate call number\n");
@@ -8211,7 +8240,7 @@
 						ast_sched_del(sched, peer->expire);
 					peer->expire = -1;
 					ast_clear_flag(peer, IAX_DYNAMIC);
-					if (ast_dnsmgr_lookup(v->value, &peer->addr.sin_addr, &peer->dnsmgr)) {
+					if (ast_dnsmgr_lookup(v->value, &peer->addr.sin_addr, &peer->dnsmgr) < 0) {
 						free(peer);
 						return NULL;
 					}
@@ -8477,6 +8506,8 @@
 			}
 			ast_mutex_unlock(&iaxsl[regl->callno]);
 		}
+		if (regl->dnsmgr)
+			ast_dnsmgr_release(regl->dnsmgr);
 		free(regl);
 	}
 	registrations = NULL;
Index: include/asterisk/dnsmgr.h
===================================================================
--- include/asterisk/dnsmgr.h	(revision 12869)
+++ include/asterisk/dnsmgr.h	(working copy)
@@ -37,6 +37,10 @@
 
 int ast_dnsmgr_lookup(const char *name, struct in_addr *result, struct ast_dnsmgr_entry **dnsmgr);
 
+int ast_dnsmgr_refresh(struct ast_dnsmgr_entry *entry, int verbose);
+
+int ast_dnsmgr_changed(struct ast_dnsmgr_entry *entry);
+
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif /* c_plusplus */
Index: dnsmgr.c
===================================================================
--- dnsmgr.c	(revision 12869)
+++ dnsmgr.c	(working copy)
@@ -52,9 +52,11 @@
 static pthread_t refresh_thread = AST_PTHREADT_NULL;
 
 struct ast_dnsmgr_entry {
-	struct in_addr *result;
+	struct in_addr *result; 	/* where we will store the resulting address */
+	struct in_addr last; 		/* the last result, used to check if address has changed */
+	int changed;
 	AST_LIST_ENTRY(ast_dnsmgr_entry) list;
-	char name[1];
+	char name[1];			/* just 1 here, but we use calloc to allocate the correct size */
 };
 
 static AST_LIST_HEAD(entry_list, ast_dnsmgr_entry) entry_list;
@@ -107,6 +109,8 @@
 	AST_LIST_LOCK(&entry_list);
 	AST_LIST_REMOVE(&entry_list, entry, list);
 	AST_LIST_UNLOCK(&entry_list);
+	if (option_verbose > 2)
+		ast_verbose(VERBOSE_PREFIX_2 "removing manager for '%s'\n", entry->name);
 	free(entry);
 }
 
@@ -119,7 +123,7 @@
 		return 0;
 
 	if (option_verbose > 3)
-		ast_verbose(VERBOSE_PREFIX_3 "doing lookup for '%s'\n", name);
+		ast_verbose(VERBOSE_PREFIX_3 "doing dnsmgr_lookup for '%s'\n", name);
 
 	/* if it's actually an IP address and not a name,
 	   there's no need for a managed lookup */
@@ -137,12 +141,62 @@
 		return 0;
 	} else {
 		if (option_verbose > 2)
-			ast_verbose(VERBOSE_PREFIX_2 "adding manager for '%s'\n", name);
+			ast_verbose(VERBOSE_PREFIX_2 "adding dns manager for '%s'\n", name);
 		*dnsmgr = ast_dnsmgr_get(name, result);
-		return !*dnsmgr;
+		if (*dnsmgr) {
+			return 1;
+		} else {
+			return -1;
+		}
 	}
 }
 
+/*
+ * Refresh a dnsmgr entry
+ *
+ * XXX maybe we must lock the entry to make safer
+ */
+int ast_dnsmgr_refresh(struct ast_dnsmgr_entry *entry, int verbose)
+{
+	struct ast_hostent ahp;
+	struct hostent *hp;
+        char iabuf[INET_ADDRSTRLEN];
+        char iabuf2[INET_ADDRSTRLEN];
+        struct in_addr tmp;
+        
+	if (verbose && (option_verbose > 2))
+		ast_verbose(VERBOSE_PREFIX_2 "refreshing '%s'\n", entry->name);
+
+	if ((hp = ast_gethostbyname(entry->name, &ahp))) {
+		/* check to see if it has changed, do callback if requested (where de callback is defined ????) */
+		memcpy(&tmp, hp->h_addr, sizeof(tmp));
+		if (tmp.s_addr != entry->last.s_addr) {
+			ast_log(LOG_NOTICE, "host '%s' changed from %s to %s\n", 
+				entry->name,
+				ast_inet_ntoa(iabuf, sizeof(iabuf), entry->last),
+				ast_inet_ntoa(iabuf2, sizeof(iabuf2), tmp));
+
+			memcpy(entry->result, hp->h_addr, sizeof(entry->result));
+			memcpy(&entry->last, hp->h_addr, sizeof(entry->last));
+			entry->changed = 1;
+			return 1;
+		} 
+		
+	}
+	return 0;
+}
+
+/*
+ * Check if dnsmgr entry has changed from since last call to this function
+ */
+int ast_dnsmgr_changed(struct ast_dnsmgr_entry *entry) 
+{
+	int ret = entry->changed;
+	entry->changed = 0;
+	
+	return ret;
+}
+
 static void *do_refresh(void *data)
 {
 	for (;;) {
@@ -158,8 +212,6 @@
 {
 	struct refresh_info *info = data;
 	struct ast_dnsmgr_entry *entry;
-	struct ast_hostent ahp;
-	struct hostent *hp;
 
 	/* if a refresh or reload is already in progress, exit now */
 	if (ast_mutex_trylock(&refresh_lock)) {
@@ -175,13 +227,7 @@
 		if (info->regex_present && regexec(&info->filter, entry->name, 0, NULL, 0))
 		    continue;
 
-		if (info->verbose && (option_verbose > 2))
-			ast_verbose(VERBOSE_PREFIX_2 "refreshing '%s'\n", entry->name);
-
-		if ((hp = ast_gethostbyname(entry->name, &ahp))) {
-			/* check to see if it has changed, do callback if requested */
-			memcpy(entry->result, hp->h_addr, sizeof(entry->result));
-		}
+		ast_dnsmgr_refresh(entry, info->verbose);
 	}
 	AST_LIST_UNLOCK(info->entries);