Merge lp:~davewalker/ubuntu/lucid/asterisk/lp605358 into lp:ubuntu/lucid/asterisk

[Dave Walker]

asterisk (1:1.6.2.5-0ubuntu1.1) lucid-proposed; urgency=low

  * debian/patches/dnsmgr-A-SRV-handling: Resolve handling of A and
    SRV record changes and problem with multiple A/SRV records returned.
    Patch based on Asterisk project's upstream patch. (LP: #605358)

 -- Dave Walker (Daviey) <email address hidden> Wed, 14 Jul 2010 11:40:55 +0100

SRU:-
 IMPACT: New users or users upgrading to Lucid, who use a provider that has multiple A/SRV records, after a short amount of time will not be able to make outgoing calls.
 FIX: Patch derived from upstream asterisk addresses this issue with better dnsmgr handling
 TEST CASE: Install asterisk, set up a peer using multiple A or SRV records, observe:
   "[Jul 14 12:07:57] WARNING[25721]: chan_sip.c:3581 __sip_xmit: sip_xmit of 0xb9bdb680 (len 536) to X.X.X.X:5060 returned -1: Address family not supported by protocol", and therefore outgoing calls fail.
 Notes: Applied in current upstream trunk and stable, and therefore will be in Maverick in a forthcoming merge.

[lp:~davewalker/ubuntu/lucid/asterisk/lp605358]

58. By Dave Walker on 2010-07-14

debian/changelog: Removed .patch extension from new patch

59. By Dave Walker on 2010-07-16

Added .pc quilt meta files for completness

[Dave Walker (davewalker)]

Merged, uploaded etc - marking as such.

=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2010-07-16 10:16:00 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2010-07-16 10:16:00 +0000
@@ -0,0 +1,1 @@
+series

=== added file '.pc/allow-tilde-destdir/.timestamp'
=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2010-03-02 10:00:03 +0000
+++ .pc/applied-patches	2010-07-16 10:16:00 +0000
@@ -11,3 +11,4 @@
 dahdi_ptmp_nt
 dahdi_pri_debug_spannums
 sound_files
+dnsmgr-A-SRV-handling

=== added file '.pc/astgenkey-security/.timestamp'
=== added file '.pc/dahdi-fxsks-hookstate/.timestamp'
=== added file '.pc/dahdi_pri_debug_spannums/.timestamp'
=== added file '.pc/dahdi_ptmp_nt/.timestamp'
=== added directory '.pc/dnsmgr-A-SRV-handling'
=== added file '.pc/dnsmgr-A-SRV-handling/.timestamp'
=== added directory '.pc/dnsmgr-A-SRV-handling/include'
=== added directory '.pc/dnsmgr-A-SRV-handling/include/asterisk'
=== added file '.pc/dnsmgr-A-SRV-handling/include/asterisk/dnsmgr.h'
--- .pc/dnsmgr-A-SRV-handling/include/asterisk/dnsmgr.h	1970-01-01 00:00:00 +0000
+++ .pc/dnsmgr-A-SRV-handling/include/asterisk/dnsmgr.h	2010-07-16 10:16:00 +0000
@@ -0,0 +1,105 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2005, Digium, Inc.
+ *
+ * Kevin P. Fleming <[e-mail]>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ * \brief Background DNS update manager
+ */
+
+#ifndef _ASTERISK_DNSMGR_H
+#define _ASTERISK_DNSMGR_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "asterisk/network.h"
+#include "asterisk/srv.h"
+
+/*!
+ * \brief A DNS manager entry
+ *
+ * This is an opaque type.
+ */
+struct ast_dnsmgr_entry;
+
+/*!
+ * \brief Allocate a new DNS manager entry
+ *
+ * \param name the hostname
+ * \param result where the DNS manager should store the IP address as it refreshes it.
+ *      it.
+ *
+ * This function allocates a new DNS manager entry object, and fills it with the
+ * provided hostname and IP address.  This function does not force an initial lookup
+ * of the IP address.  So, generally, this should be used when the initial address
+ * is already known.
+ *
+ * \return a DNS manager entry
+ * \version 1.6.1 result changed from struct in_addr to struct sockaddr_in to store port number
+ */
+struct ast_dnsmgr_entry *ast_dnsmgr_get(const char *name, struct sockaddr_in *result, const char *service);
+
+/*!
+ * \brief Free a DNS manager entry
+ *
+ * \param entry the DNS manager entry to free
+ *
+ * \return nothing
+ */
+void ast_dnsmgr_release(struct ast_dnsmgr_entry *entry);
+
+/*!
+ * \brief Allocate and initialize a DNS manager entry
+ *
+ * \param name the hostname
+ * \param result where to store the IP address as the DNS manager refreshes it
+ * \param dnsmgr Where to store the allocate DNS manager entry
+ *
+ * This function allocates a new DNS manager entry object, and fills it with
+ * the provided hostname and IP address.  This function _does_ force an initial
+ * lookup, so it may block for some period of time.
+ *
+ * \retval 0 success
+ * \retval non-zero failure
+ * \version 1.6.1 result changed from struct in_addr to struct aockaddr_in to store port number
+ */
+int ast_dnsmgr_lookup(const char *name, struct sockaddr_in *result, struct ast_dnsmgr_entry **dnsmgr, const char *service);
+
+/*!
+ * \brief Force a refresh of a dnsmgr entry
+ *
+ * \retval non-zero if the result is different than the previous result
+ * \retval zero if the result is the same as the previous result
+ */
+int ast_dnsmgr_refresh(struct ast_dnsmgr_entry *entry);
+
+/*!
+ * \brief Check is see if a dnsmgr entry has changed
+ *
+ * \retval non-zero if the dnsmgr entry has changed since the last call to
+ *                  this function
+ * \retval zero     if the dnsmgr entry has not changed since the last call to
+ *                  this function
+ */
+int ast_dnsmgr_changed(struct ast_dnsmgr_entry *entry);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif /* c_plusplus */
+
+#endif /* ASTERISK_DNSMGR_H */

=== added directory '.pc/dnsmgr-A-SRV-handling/main'
=== added file '.pc/dnsmgr-A-SRV-handling/main/acl.c'
--- .pc/dnsmgr-A-SRV-handling/main/acl.c	1970-01-01 00:00:00 +0000
+++ .pc/dnsmgr-A-SRV-handling/main/acl.c	2010-07-16 10:16:00 +0000
@@ -0,0 +1,541 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2006, Digium, Inc.
+ *
+ * Mark Spencer <[e-mail]>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Various sorts of access control
+ *
+ * \author Mark Spencer <[e-mail]>
+ */
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision: 248849 $")
+
+#include "asterisk/network.h"
+
+#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__Darwin__)
+#include <fcntl.h>
+#include <net/route.h>
+#endif
+
+#if defined(SOLARIS)
+#include <sys/sockio.h>
+#include <net/if.h>
+#elif defined(HAVE_GETIFADDRS)
+#include <ifaddrs.h>
+#endif
+
+#include "asterisk/acl.h"
+#include "asterisk/channel.h"
+#include "asterisk/utils.h"
+#include "asterisk/lock.h"
+#include "asterisk/srv.h"
+
+#if (!defined(SOLARIS) && !defined(HAVE_GETIFADDRS))
+static int get_local_address(struct in_addr *ourip)
+{
+	return -1;
+}
+#else
+static void score_address(const struct sockaddr_in *sin, struct in_addr *best_addr, int *best_score)
+{
+	const char *address;
+	int score;
+
+	address = ast_inet_ntoa(sin->sin_addr);
+
+	/* RFC 1700 alias for the local network */
+	if (address[0] == '0') {
+		score = -25;
+	/* RFC 1700 localnet */
+	} else if (strncmp(address, "127", 3) == 0) {
+		score = -20;
+	/* RFC 1918 non-public address space */
+	} else if (strncmp(address, "10.", 3) == 0) {
+		score = -5;
+	/* RFC 1918 non-public address space */
+	} else if (strncmp(address, "172", 3) == 0) {
+		/* 172.16.0.0 - 172.19.255.255, but not 172.160.0.0 - 172.169.255.255 */
+		if (address[4] == '1' && address[5] >= '6' && address[6] == '.') {
+			score = -5;
+		/* 172.20.0.0 - 172.29.255.255, but not 172.200.0.0 - 172.255.255.255 nor 172.2.0.0 - 172.2.255.255 */
+		} else if (address[4] == '2' && address[6] == '.') {
+			score = -5;
+		/* 172.30.0.0 - 172.31.255.255 */
+		} else if (address[4] == '3' && address[5] <= '1') {
+			score = -5;
+		/* All other 172 addresses are public */
+		} else {
+			score = 0;
+		}
+	/* RFC 2544 Benchmark test range (198.18.0.0 - 198.19.255.255, but not 198.180.0.0 - 198.199.255.255) */
+	} else if (strncmp(address, "198.1", 5) == 0 && address[5] >= '8' && address[6] == '.') {
+		score = -10;
+	/* RFC 1918 non-public address space */
+	} else if (strncmp(address, "192.168", 7) == 0) {
+		score = -5;
+	/* RFC 3330 Zeroconf network */
+	} else if (strncmp(address, "169.254", 7) == 0) {
+		/*!\note Better score than a test network, but not quite as good as RFC 1918
+		 * address space.  The reason is that some Linux distributions automatically
+		 * configure a Zeroconf address before trying DHCP, so we want to prefer a
+		 * DHCP lease to a Zeroconf address.
+		 */
+		score = -10;
+	/* RFC 3330 Test network */
+	} else if (strncmp(address, "192.0.2.", 8) == 0) {
+		score = -15;
+	/* Every other address should be publically routable */
+	} else {
+		score = 0;
+	}
+
+	if (score > *best_score) {
+		*best_score = score;
+		memcpy(best_addr, &sin->sin_addr, sizeof(*best_addr));
+	}
+}
+
+static int get_local_address(struct in_addr *ourip)
+{
+	int s, res = -1;
+#ifdef SOLARIS
+	struct lifreq *ifr = NULL;
+	struct lifnum ifn;
+	struct lifconf ifc;
+	struct sockaddr_in *sa;
+	char *buf = NULL;
+	int bufsz, x;
+#endif /* SOLARIS */
+#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__linux__) || defined(__Darwin__)
+	struct ifaddrs *ifap, *ifaphead;
+	int rtnerr;
+	const struct sockaddr_in *sin;
+#endif /* BSD_OR_LINUX */
+	struct in_addr best_addr;
+	int best_score = -100;
+	memset(&best_addr, 0, sizeof(best_addr));
+
+#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__linux__) || defined(__Darwin__)
+	rtnerr = getifaddrs(&ifaphead);
+	if (rtnerr) {
+		perror(NULL);
+		return -1;
+	}
+#endif /* BSD_OR_LINUX */
+
+	s = socket(AF_INET, SOCK_STREAM, 0);
+
+	if (s > 0) {
+#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__linux__) || defined(__Darwin__)
+		for (ifap = ifaphead; ifap; ifap = ifap->ifa_next) {
+
+			if (ifap->ifa_addr && ifap->ifa_addr->sa_family == AF_INET) {
+				sin = (const struct sockaddr_in *) ifap->ifa_addr;
+				score_address(sin, &best_addr, &best_score);
+				res = 0;
+
+				if (best_score == 0) {
+					break;
+				}
+			}
+		}
+#endif /* BSD_OR_LINUX */
+
+		/* There is no reason whatsoever that this shouldn't work on Linux or BSD also. */
+#ifdef SOLARIS
+		/* Get a count of interfaces on the machine */
+		ifn.lifn_family = AF_INET;
+		ifn.lifn_flags = 0;
+		ifn.lifn_count = 0;
+		if (ioctl(s, SIOCGLIFNUM, &ifn) < 0) {
+			close(s);
+			return -1;
+		}
+
+		bufsz = ifn.lifn_count * sizeof(struct lifreq);
+		if (!(buf = malloc(bufsz))) {
+			close(s);
+			return -1;
+		}
+		memset(buf, 0, bufsz);
+
+		/* Get a list of interfaces on the machine */
+		ifc.lifc_len = bufsz;
+		ifc.lifc_buf = buf;
+		ifc.lifc_family = AF_INET;
+		ifc.lifc_flags = 0;
+		if (ioctl(s, SIOCGLIFCONF, &ifc) < 0) {
+			close(s);
+			free(buf);
+			return -1;
+		}
+
+		for (ifr = ifc.lifc_req, x = 0; x < ifn.lifn_count; ifr++, x++) {
+			sa = (struct sockaddr_in *)&(ifr->lifr_addr);
+			score_address(sa, &best_addr, &best_score);
+			res = 0;
+
+			if (best_score == 0) {
+				break;
+			}
+		}
+
+		free(buf);
+#endif /* SOLARIS */
+
+		close(s);
+	}
+#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__linux__) || defined(__Darwin__)
+	freeifaddrs(ifaphead);
+#endif /* BSD_OR_LINUX */
+
+	if (res == 0 && ourip) {
+		memcpy(ourip, &best_addr, sizeof(*ourip));
+	}
+	return res;
+}
+#endif /* HAVE_GETIFADDRS */
+
+/* Free HA structure */
+void ast_free_ha(struct ast_ha *ha)
+{
+	struct ast_ha *hal;
+	while (ha) {
+		hal = ha;
+		ha = ha->next;
+		ast_free(hal);
+	}
+}
+
+/* Copy HA structure */
+void ast_copy_ha(const struct ast_ha *from, struct ast_ha *to)
+{
+	memcpy(&to->netaddr, &from->netaddr, sizeof(from->netaddr));
+	memcpy(&to->netmask, &from->netmask, sizeof(from->netmask));
+	to->sense = from->sense;
+}
+
+/* Create duplicate of ha structure */
+static struct ast_ha *ast_duplicate_ha(struct ast_ha *original)
+{
+	struct ast_ha *new_ha;
+
+	if ((new_ha = ast_malloc(sizeof(*new_ha)))) {
+		/* Copy from original to new object */
+		ast_copy_ha(original, new_ha);
+	}
+
+	return new_ha;
+}
+
+/* Create duplicate HA link list */
+/*  Used in chan_sip2 templates */
+struct ast_ha *ast_duplicate_ha_list(struct ast_ha *original)
+{
+	struct ast_ha *start = original;
+	struct ast_ha *ret = NULL;
+	struct ast_ha *current, *prev = NULL;
+
+	while (start) {
+		current = ast_duplicate_ha(start);  /* Create copy of this object */
+		if (prev) {
+			prev->next = current;           /* Link previous to this object */
+		}
+
+		if (!ret) {
+			ret = current;                  /* Save starting point */
+		}
+
+		start = start->next;                /* Go to next object */
+		prev = current;                     /* Save pointer to this object */
+	}
+	return ret;                             /* Return start of list */
+}
+
+struct ast_ha *ast_append_ha(const char *sense, const char *stuff, struct ast_ha *path, int *error)
+{
+	struct ast_ha *ha;
+	char *nm;
+	struct ast_ha *prev = NULL;
+	struct ast_ha *ret;
+	int x;
+	char *tmp = ast_strdupa(stuff);
+
+	ret = path;
+	while (path) {
+		prev = path;
+		path = path->next;
+	}
+
+	if (!(ha = ast_malloc(sizeof(*ha)))) {
+		return ret;
+	}
+
+	if (!(nm = strchr(tmp, '/'))) {
+		/* assume /32. Yes, htonl does not do anything for this particular mask
+		   but we better use it to show we remember about byte order */
+		ha->netmask.s_addr = htonl(0xFFFFFFFF);
+	} else {
+		*nm = '\0';
+		nm++;
+
+		if (!strchr(nm, '.')) {
+			if ((sscanf(nm, "%30d", &x) == 1) && (x >= 0) && (x <= 32)) {
+				if (x == 0) {
+					/* This is special-cased to prevent unpredictable
+					 * behavior of shifting left 32 bits
+					 */
+					ha->netmask.s_addr = 0;
+				} else {
+					ha->netmask.s_addr = htonl(0xFFFFFFFF << (32 - x));
+				}
+			} else {
+				ast_log(LOG_WARNING, "Invalid CIDR in %s\n", stuff);
+				ast_free(ha);
+				if (error) {
+					*error = 1;
+				}
+				return ret;
+			}
+		} else if (!inet_aton(nm, &ha->netmask)) {
+			ast_log(LOG_WARNING, "Invalid mask in %s\n", stuff);
+			ast_free(ha);
+			if (error) {
+				*error = 1;
+			}
+			return ret;
+		}
+	}
+
+	if (!inet_aton(tmp, &ha->netaddr)) {
+		ast_log(LOG_WARNING, "Invalid IP address in %s\n", stuff);
+		ast_free(ha);
+		if (error) {
+			*error = 1;
+		}
+		return ret;
+	}
+
+	ha->netaddr.s_addr &= ha->netmask.s_addr;
+
+	ha->sense = strncasecmp(sense, "p", 1) ? AST_SENSE_DENY : AST_SENSE_ALLOW;
+
+	ha->next = NULL;
+	if (prev) {
+		prev->next = ha;
+	} else {
+		ret = ha;
+	}
+
+	ast_debug(1, "%s/%s sense %d appended to acl for peer\n", ast_strdupa(ast_inet_ntoa(ha->netaddr)), ast_strdupa(ast_inet_ntoa(ha->netmask)), ha->sense);
+
+	return ret;
+}
+
+int ast_apply_ha(struct ast_ha *ha, struct sockaddr_in *sin)
+{
+	/* Start optimistic */
+	int res = AST_SENSE_ALLOW;
+	while (ha) {
+#if 0	/* debugging code */
+		char iabuf[INET_ADDRSTRLEN];
+		char iabuf2[INET_ADDRSTRLEN];
+		/* DEBUG */
+		ast_copy_string(iabuf, ast_inet_ntoa(sin->sin_addr), sizeof(iabuf));
+		ast_copy_string(iabuf2, ast_inet_ntoa(ha->netaddr), sizeof(iabuf2));
+		ast_debug(1, "##### Testing %s with %s\n", iabuf, iabuf2);
+#endif
+		/* For each rule, if this address and the netmask = the net address
+		   apply the current rule */
+		if ((sin->sin_addr.s_addr & ha->netmask.s_addr) == ha->netaddr.s_addr) {
+			res = ha->sense;
+		}
+		ha = ha->next;
+	}
+	return res;
+}
+
+int ast_get_ip_or_srv(struct sockaddr_in *sin, const char *value, const char *service)
+{
+	struct hostent *hp;
+	struct ast_hostent ahp;
+	char srv[256];
+	char host[256];
+	int tportno = ntohs(sin->sin_port);
+	if (service) {
+		snprintf(srv, sizeof(srv), "%s.%s", service, value);
+		if (ast_get_srv(NULL, host, sizeof(host), &tportno, srv) > 0) {
+			sin->sin_port = htons(tportno);
+			value = host;
+		}
+	}
+	if ((hp = ast_gethostbyname(value, &ahp))) {
+		memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
+	} else {
+		ast_log(LOG_WARNING, "Unable to lookup '%s'\n", value);
+		return -1;
+	}
+	return 0;
+}
+
+struct dscp_codepoint {
+	char *name;
+	unsigned int space;
+};
+
+/* IANA registered DSCP codepoints */
+
+static const struct dscp_codepoint dscp_pool1[] = {
+	{ "CS0", 0x00 },
+	{ "CS1", 0x08 },
+	{ "CS2", 0x10 },
+	{ "CS3", 0x18 },
+	{ "CS4", 0x20 },
+	{ "CS5", 0x28 },
+	{ "CS6", 0x30 },
+	{ "CS7", 0x38 },
+	{ "AF11", 0x0A },
+	{ "AF12", 0x0C },
+	{ "AF13", 0x0E },
+	{ "AF21", 0x12 },
+	{ "AF22", 0x14 },
+	{ "AF23", 0x16 },
+	{ "AF31", 0x1A },
+	{ "AF32", 0x1C },
+	{ "AF33", 0x1E },
+	{ "AF41", 0x22 },
+	{ "AF42", 0x24 },
+	{ "AF43", 0x26 },
+	{ "EF", 0x2E },
+};
+
+int ast_str2cos(const char *value, unsigned int *cos)
+{
+	int fval;
+
+	if (sscanf(value, "%30d", &fval) == 1) {
+		if (fval < 8) {
+		    *cos = fval;
+		    return 0;
+		}
+	}
+
+	return -1;
+}
+
+int ast_str2tos(const char *value, unsigned int *tos)
+{
+	int fval;
+	unsigned int x;
+
+	if (sscanf(value, "%30i", &fval) == 1) {
+		*tos = fval & 0xFF;
+		return 0;
+	}
+
+	for (x = 0; x < ARRAY_LEN(dscp_pool1); x++) {
+		if (!strcasecmp(value, dscp_pool1[x].name)) {
+			*tos = dscp_pool1[x].space << 2;
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+const char *ast_tos2str(unsigned int tos)
+{
+	unsigned int x;
+
+	for (x = 0; x < ARRAY_LEN(dscp_pool1); x++) {
+		if (dscp_pool1[x].space == (tos >> 2)) {
+			return dscp_pool1[x].name;
+		}
+	}
+
+	return "unknown";
+}
+
+int ast_get_ip(struct sockaddr_in *sin, const char *value)
+{
+	return ast_get_ip_or_srv(sin, value, NULL);
+}
+
+int ast_ouraddrfor(struct in_addr *them, struct in_addr *us)
+{
+	int s;
+	struct sockaddr_in sin;
+	socklen_t slen;
+
+	if ((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
+		ast_log(LOG_ERROR, "Cannot create socket\n");
+		return -1;
+	}
+	sin.sin_family = AF_INET;
+	sin.sin_port = htons(5060);
+	sin.sin_addr = *them;
+	if (connect(s, (struct sockaddr *)&sin, sizeof(sin))) {
+		ast_log(LOG_WARNING, "Cannot connect\n");
+		close(s);
+		return -1;
+	}
+	slen = sizeof(sin);
+	if (getsockname(s, (struct sockaddr *)&sin, &slen)) {
+		ast_log(LOG_WARNING, "Cannot get socket name\n");
+		close(s);
+		return -1;
+	}
+	close(s);
+	ast_debug(3, "Found IP address for this socket\n");
+	*us = sin.sin_addr;
+	return 0;
+}
+
+int ast_find_ourip(struct in_addr *ourip, struct sockaddr_in bindaddr)
+{
+	char ourhost[MAXHOSTNAMELEN] = "";
+	struct ast_hostent ahp;
+	struct hostent *hp;
+	struct in_addr saddr;
+
+	/* just use the bind address if it is nonzero */
+	if (ntohl(bindaddr.sin_addr.s_addr)) {
+		memcpy(ourip, &bindaddr.sin_addr, sizeof(*ourip));
+		ast_debug(3, "Attached to given IP address\n");
+		return 0;
+	}
+	/* try to use our hostname */
+	if (gethostname(ourhost, sizeof(ourhost) - 1)) {
+		ast_log(LOG_WARNING, "Unable to get hostname\n");
+	} else {
+		if ((hp = ast_gethostbyname(ourhost, &ahp))) {
+			memcpy(ourip, hp->h_addr, sizeof(*ourip));
+			ast_debug(3, "Found one IP address based on local hostname %s.\n", ourhost);
+			return 0;
+		}
+	}
+	ast_debug(3, "Trying to check A.ROOT-SERVERS.NET and get our IP address for that connection\n");
+	/* A.ROOT-SERVERS.NET. */
+	if (inet_aton("198.41.0.4", &saddr) && !ast_ouraddrfor(&saddr, ourip)) {
+		return 0;
+	}
+	return get_local_address(ourip);
+}
+

=== added file '.pc/dnsmgr-A-SRV-handling/main/dnsmgr.c'
--- .pc/dnsmgr-A-SRV-handling/main/dnsmgr.c	1970-01-01 00:00:00 +0000
+++ .pc/dnsmgr-A-SRV-handling/main/dnsmgr.c	2010-07-16 10:16:00 +0000
@@ -0,0 +1,439 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2005-2006, Kevin P. Fleming
+ *
+ * Kevin P. Fleming <[e-mail]>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Background DNS update manager
+ *
+ * \author Kevin P. Fleming <[e-mail]> 
+ *
+ * \bug There is a minor race condition.  In the event that an IP address
+ * of a dnsmgr managed host changes, there is the potential for the consumer
+ * of that address to access the in_addr data at the same time that the dnsmgr
+ * thread is in the middle of updating it to the new address.
+ */
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision: 211580 $")
+
+#include "asterisk/_private.h"
+#include <regex.h>
+#include <signal.h>
+
+#include "asterisk/dnsmgr.h"
+#include "asterisk/linkedlists.h"
+#include "asterisk/utils.h"
+#include "asterisk/config.h"
+#include "asterisk/sched.h"
+#include "asterisk/cli.h"
+#include "asterisk/manager.h"
+#include "asterisk/acl.h"
+
+static struct sched_context *sched;
+static int refresh_sched = -1;
+static pthread_t refresh_thread = AST_PTHREADT_NULL;
+
+struct ast_dnsmgr_entry {
+	/*! where we will store the resulting IP address and port number */
+	struct sockaddr_in *result;
+	/*! the last result, used to check if address/port has changed */
+	struct sockaddr_in last;
+	/*! SRV record to lookup, if provided. Composed of service, protocol, and domain name: _Service._Proto.Name */
+	char *service;
+	/*! Set to 1 if the entry changes */
+	unsigned int changed:1;
+	ast_mutex_t lock;
+	AST_RWLIST_ENTRY(ast_dnsmgr_entry) list;
+	/*! just 1 here, but we use calloc to allocate the correct size */
+	char name[1];
+};
+
+static AST_RWLIST_HEAD_STATIC(entry_list, ast_dnsmgr_entry);
+
+AST_MUTEX_DEFINE_STATIC(refresh_lock);
+
+#define REFRESH_DEFAULT 300
+
+static int enabled;
+static int refresh_interval;
+
+struct refresh_info {
+	struct entry_list *entries;
+	int verbose;
+	unsigned int regex_present:1;
+	regex_t filter;
+};
+
+static struct refresh_info master_refresh_info = {
+	.entries = &entry_list,
+	.verbose = 0,
+};
+
+struct ast_dnsmgr_entry *ast_dnsmgr_get(const char *name, struct sockaddr_in *result, const char *service)
+{
+	struct ast_dnsmgr_entry *entry;
+	int total_size = sizeof(*entry) + strlen(name) + (service ? strlen(service) + 1 : 0);
+
+	if (!result || ast_strlen_zero(name) || !(entry = ast_calloc(1, total_size)))
+		return NULL;
+
+	entry->result = result;
+	ast_mutex_init(&entry->lock);
+	strcpy(entry->name, name);
+	memcpy(&entry->last, result, sizeof(entry->last));
+	if (service) {
+		entry->service = ((char *) entry) + sizeof(*entry) + strlen(name);
+		strcpy(entry->service, service);
+	}
+
+	AST_RWLIST_WRLOCK(&entry_list);
+	AST_RWLIST_INSERT_HEAD(&entry_list, entry, list);
+	AST_RWLIST_UNLOCK(&entry_list);
+
+	return entry;
+}
+
+void ast_dnsmgr_release(struct ast_dnsmgr_entry *entry)
+{
+	if (!entry)
+		return;
+
+	AST_RWLIST_WRLOCK(&entry_list);
+	AST_RWLIST_REMOVE(&entry_list, entry, list);
+	AST_RWLIST_UNLOCK(&entry_list);
+	ast_verb(4, "removing dns manager for '%s'\n", entry->name);
+
+	ast_mutex_destroy(&entry->lock);
+	ast_free(entry);
+}
+
+int ast_dnsmgr_lookup(const char *name, struct sockaddr_in *result, struct ast_dnsmgr_entry **dnsmgr, const char *service)
+{
+	if (ast_strlen_zero(name) || !result || !dnsmgr)
+		return -1;
+
+	if (*dnsmgr && !strcasecmp((*dnsmgr)->name, name))
+		return 0;
+
+	/* if it's actually an IP address and not a name,
+	   there's no need for a managed lookup */
+	if (inet_aton(name, &result->sin_addr))
+		return 0;
+
+	ast_verb(4, "doing dnsmgr_lookup for '%s'\n", name);
+
+	/* do a lookup now but add a manager so it will automagically get updated in the background */
+	ast_get_ip_or_srv(result, name, service);
+	
+	/* if dnsmgr is not enable don't bother adding an entry */
+	if (!enabled)
+		return 0;
+	
+	ast_verb(3, "adding dns manager for '%s'\n", name);
+	*dnsmgr = ast_dnsmgr_get(name, result, service);
+	return !*dnsmgr;
+}
+
+/*
+ * Refresh a dnsmgr entry
+ */
+static int dnsmgr_refresh(struct ast_dnsmgr_entry *entry, int verbose)
+{
+	char iabuf[INET_ADDRSTRLEN];
+	char iabuf2[INET_ADDRSTRLEN];
+	struct sockaddr_in tmp;
+	int changed = 0;
+        
+	ast_mutex_lock(&entry->lock);
+	if (verbose)
+		ast_verb(3, "refreshing '%s'\n", entry->name);
+
+	tmp.sin_port = entry->last.sin_port;
+	
+	if (!ast_get_ip_or_srv(&tmp, entry->name, entry->service) && inaddrcmp(&tmp, &entry->last)) {
+		ast_copy_string(iabuf, ast_inet_ntoa(entry->last.sin_addr), sizeof(iabuf));
+		ast_copy_string(iabuf2, ast_inet_ntoa(tmp.sin_addr), sizeof(iabuf2));
+		ast_log(LOG_NOTICE, "dnssrv: host '%s' changed from %s:%d to %s:%d\n", 
+			entry->name, iabuf, ntohs(entry->last.sin_port), iabuf2, ntohs(tmp.sin_port));
+		*entry->result = tmp;
+		entry->last = tmp;
+		changed = entry->changed = 1;
+	}
+
+	ast_mutex_unlock(&entry->lock);
+	return changed;
+}
+
+int ast_dnsmgr_refresh(struct ast_dnsmgr_entry *entry)
+{
+	return dnsmgr_refresh(entry, 0);
+}
+
+/*
+ * Check if dnsmgr entry has changed from since last call to this function
+ */
+int ast_dnsmgr_changed(struct ast_dnsmgr_entry *entry) 
+{
+	int changed;
+
+	ast_mutex_lock(&entry->lock);
+
+	changed = entry->changed;
+	entry->changed = 0;
+
+	ast_mutex_unlock(&entry->lock);
+	
+	return changed;
+}
+
+static void *do_refresh(void *data)
+{
+	for (;;) {
+		pthread_testcancel();
+		usleep((ast_sched_wait(sched)*1000));
+		pthread_testcancel();
+		ast_sched_runq(sched);
+	}
+	return NULL;
+}
+
+static int refresh_list(const void *data)
+{
+	struct refresh_info *info = (struct refresh_info *)data;
+	struct ast_dnsmgr_entry *entry;
+
+	/* if a refresh or reload is already in progress, exit now */
+	if (ast_mutex_trylock(&refresh_lock)) {
+		if (info->verbose)
+			ast_log(LOG_WARNING, "DNS Manager refresh already in progress.\n");
+		return -1;
+	}
+
+	ast_verb(3, "Refreshing DNS lookups.\n");
+	AST_RWLIST_RDLOCK(info->entries);
+	AST_RWLIST_TRAVERSE(info->entries, entry, list) {
+		if (info->regex_present && regexec(&info->filter, entry->name, 0, NULL, 0))
+		    continue;
+
+		dnsmgr_refresh(entry, info->verbose);
+	}
+	AST_RWLIST_UNLOCK(info->entries);
+
+	ast_mutex_unlock(&refresh_lock);
+
+	/* automatically reschedule based on the interval */
+	return refresh_interval * 1000;
+}
+
+void dnsmgr_start_refresh(void)
+{
+	if (refresh_sched > -1) {
+		AST_SCHED_DEL(sched, refresh_sched);
+		refresh_sched = ast_sched_add_variable(sched, 100, refresh_list, &master_refresh_info, 1);
+	}
+}
+
+static int do_reload(int loading);
+
+static char *handle_cli_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "dnsmgr reload";
+		e->usage = 
+			"Usage: dnsmgr reload\n"
+			"       Reloads the DNS manager configuration.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;	
+	}
+	if (a->argc > 2)
+		return CLI_SHOWUSAGE;
+
+	do_reload(0);
+	return CLI_SUCCESS;
+}
+
+static char *handle_cli_refresh(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	struct refresh_info info = {
+		.entries = &entry_list,
+		.verbose = 1,
+	};
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "dnsmgr refresh";
+		e->usage = 
+			"Usage: dnsmgr refresh [pattern]\n"
+			"       Peforms an immediate refresh of the managed DNS entries.\n"
+			"       Optional regular expression pattern is used to filter the entries to refresh.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;	
+	}
+
+	if (!enabled) {
+		ast_cli(a->fd, "DNS Manager is disabled.\n");
+		return 0;
+	}
+
+	if (a->argc > 3) {
+		return CLI_SHOWUSAGE;
+	}
+
+	if (a->argc == 3) {
+		if (regcomp(&info.filter, a->argv[2], REG_EXTENDED | REG_NOSUB)) {
+			return CLI_SHOWUSAGE;
+		} else {
+			info.regex_present = 1;
+		}
+	}
+
+	refresh_list(&info);
+
+	if (info.regex_present) {
+		regfree(&info.filter);
+	}
+
+	return CLI_SUCCESS;
+}
+
+static char *handle_cli_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	int count = 0;
+	struct ast_dnsmgr_entry *entry;
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "dnsmgr status";
+		e->usage = 
+			"Usage: dnsmgr status\n"
+			"       Displays the DNS manager status.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;	
+	}
+
+	if (a->argc > 2)
+		return CLI_SHOWUSAGE;
+
+	ast_cli(a->fd, "DNS Manager: %s\n", enabled ? "enabled" : "disabled");
+	ast_cli(a->fd, "Refresh Interval: %d seconds\n", refresh_interval);
+	AST_RWLIST_RDLOCK(&entry_list);
+	AST_RWLIST_TRAVERSE(&entry_list, entry, list)
+		count++;
+	AST_RWLIST_UNLOCK(&entry_list);
+	ast_cli(a->fd, "Number of entries: %d\n", count);
+
+	return CLI_SUCCESS;
+}
+
+static struct ast_cli_entry cli_reload = AST_CLI_DEFINE(handle_cli_reload, "Reloads the DNS manager configuration");
+static struct ast_cli_entry cli_refresh = AST_CLI_DEFINE(handle_cli_refresh, "Performs an immediate refresh");
+static struct ast_cli_entry cli_status = AST_CLI_DEFINE(handle_cli_status, "Display the DNS manager status");
+
+int dnsmgr_init(void)
+{
+	if (!(sched = sched_context_create())) {
+		ast_log(LOG_ERROR, "Unable to create schedule context.\n");
+		return -1;
+	}
+	ast_cli_register(&cli_reload);
+	ast_cli_register(&cli_status);
+	ast_cli_register(&cli_refresh);
+	return do_reload(1);
+}
+
+int dnsmgr_reload(void)
+{
+	return do_reload(0);
+}
+
+static int do_reload(int loading)
+{
+	struct ast_config *config;
+	struct ast_flags config_flags = { loading ? 0 : CONFIG_FLAG_FILEUNCHANGED };
+	const char *interval_value;
+	const char *enabled_value;
+	int interval;
+	int was_enabled;
+	int res = -1;
+
+	config = ast_config_load2("dnsmgr.conf", "dnsmgr", config_flags);
+	if (config == CONFIG_STATUS_FILEMISSING || config == CONFIG_STATUS_FILEUNCHANGED || config == CONFIG_STATUS_FILEINVALID) {
+		return 0;
+	}
+
+	/* ensure that no refresh cycles run while the reload is in progress */
+	ast_mutex_lock(&refresh_lock);
+
+	/* reset defaults in preparation for reading config file */
+	refresh_interval = REFRESH_DEFAULT;
+	was_enabled = enabled;
+	enabled = 0;
+
+	AST_SCHED_DEL(sched, refresh_sched);
+
+	if (config) {
+		if ((enabled_value = ast_variable_retrieve(config, "general", "enable"))) {
+			enabled = ast_true(enabled_value);
+		}
+		if ((interval_value = ast_variable_retrieve(config, "general", "refreshinterval"))) {
+			if (sscanf(interval_value, "%30d", &interval) < 1)
+				ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", interval_value);
+			else if (interval < 0)
+				ast_log(LOG_WARNING, "Invalid refresh interval '%d' specified, using default\n", interval);
+			else
+				refresh_interval = interval;
+		}
+		ast_config_destroy(config);
+	}
+
+	if (enabled && refresh_interval)
+		ast_log(LOG_NOTICE, "Managed DNS entries will be refreshed every %d seconds.\n", refresh_interval);
+
+	/* if this reload enabled the manager, create the background thread
+	   if it does not exist */
+	if (enabled) {
+		if (!was_enabled && (refresh_thread == AST_PTHREADT_NULL)) {
+			if (ast_pthread_create_background(&refresh_thread, NULL, do_refresh, NULL) < 0) {
+				ast_log(LOG_ERROR, "Unable to start refresh thread.\n");
+			}
+		}
+		/* make a background refresh happen right away */
+		refresh_sched = ast_sched_add_variable(sched, 100, refresh_list, &master_refresh_info, 1);
+		res = 0;
+	}
+	/* if this reload disabled the manager and there is a background thread,
+	   kill it */
+	else if (!enabled && was_enabled && (refresh_thread != AST_PTHREADT_NULL)) {
+		/* wake up the thread so it will exit */
+		pthread_cancel(refresh_thread);
+		pthread_kill(refresh_thread, SIGURG);
+		pthread_join(refresh_thread, NULL);
+		refresh_thread = AST_PTHREADT_NULL;
+		res = 0;
+	}
+	else
+		res = 0;
+
+	ast_mutex_unlock(&refresh_lock);
+	manager_event(EVENT_FLAG_SYSTEM, "Reload", "Module: DNSmgr\r\nStatus: %s\r/nMessage: DNSmgr reload Requested\r\n", enabled ? "Enabled" : "Disabled");
+
+	return res;
+}

=== added file '.pc/h323-fix-makefile/.timestamp'
=== added file '.pc/h323-no-deps-on-asterisk/.timestamp'
=== added file '.pc/h323-workaround-openh323-segfault/.timestamp'
=== added file '.pc/hack-multiple-app-voicemail/.timestamp'
=== added file '.pc/make-clean-fixes/.timestamp'
=== added file '.pc/safe_asterisk-config/.timestamp'
=== added file '.pc/safe_asterisk-nobg/.timestamp'
=== added file '.pc/sound_files/.timestamp'
=== modified file 'debian/changelog'
--- debian/changelog	2010-04-13 16:27:27 +0000
+++ debian/changelog	2010-07-16 10:16:00 +0000
@@ -1,3 +1,11 @@
+asterisk (1:1.6.2.5-0ubuntu1.1) lucid-proposed; urgency=low
+
+  * debian/patches/dnsmgr-A-SRV-handling: Resolve handling of A and SRV 
+    record changes and problem with multiple A/SRV records returned.  
+    Patch based on Asterisk project's upstream patch.  (LP: #605358)
+
+ -- Dave Walker (Daviey) <[e-mail]>  Wed, 14 Jul 2010 11:40:55 +0100
+
 asterisk (1:1.6.2.5-0ubuntu1) lucid; urgency=low
 
   * New upstream bugfix release (1.6.2.5)

=== added file 'debian/patches/dnsmgr-A-SRV-handling'
--- debian/patches/dnsmgr-A-SRV-handling	1970-01-01 00:00:00 +0000
+++ debian/patches/dnsmgr-A-SRV-handling	2010-07-16 10:16:00 +0000
@@ -0,0 +1,132 @@
+Description: Resolve handling of A and SRV record changes and problem with multiple A/SRV records returned.
+Origin: upstream, https://issues.asterisk.org/file_download.php?file_id=25360&type=bug
+Bug: https://issues.asterisk.org/view.php?id=15827
+Bug-Ubuntu: https://launchpad.net/bugs/605358
+Last-Update: 2010-07-14
+--- a/include/asterisk/dnsmgr.h
++++ b/include/asterisk/dnsmgr.h
+@@ -42,12 +42,12 @@
+  *
+  * \param name the hostname
+  * \param result where the DNS manager should store the IP address as it refreshes it.
+- *      it.
++ * \param service SRV prefix (optional, set to NULL to disable SRV)
+  *
+  * This function allocates a new DNS manager entry object, and fills it with the
+  * provided hostname and IP address.  This function does not force an initial lookup
+- * of the IP address.  So, generally, this should be used when the initial address
+- * is already known.
++ * of the IP address.  So, this should be used when the initial address
++ * is already known and stored in result.
+  *
+  * \return a DNS manager entry
+  * \version 1.6.1 result changed from struct in_addr to struct sockaddr_in to store port number
+@@ -69,6 +69,7 @@
+  * \param name the hostname
+  * \param result where to store the IP address as the DNS manager refreshes it
+  * \param dnsmgr Where to store the allocate DNS manager entry
++ * \param service SRV prefix (optional, set to NULL to disable SRV)
+  *
+  * This function allocates a new DNS manager entry object, and fills it with
+  * the provided hostname and IP address.  This function _does_ force an initial
+--- a/main/acl.c
++++ b/main/acl.c
+@@ -387,6 +387,7 @@
+ 		}
+ 	}
+ 	if ((hp = ast_gethostbyname(value, &ahp))) {
++		sin->sin_family = hp->h_addrtype;
+ 		memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
+ 	} else {
+ 		ast_log(LOG_WARNING, "Unable to lookup '%s'\n", value);
+--- a/main/dnsmgr.c
++++ b/main/dnsmgr.c
+@@ -52,8 +52,6 @@
+ struct ast_dnsmgr_entry {
+ 	/*! where we will store the resulting IP address and port number */
+ 	struct sockaddr_in *result;
+-	/*! the last result, used to check if address/port has changed */
+-	struct sockaddr_in last;
+ 	/*! SRV record to lookup, if provided. Composed of service, protocol, and domain name: _Service._Proto.Name */
+ 	char *service;
+ 	/*! Set to 1 if the entry changes */
+@@ -85,6 +83,9 @@
+ 	.verbose = 0,
+ };
+ 
++/* 
++ * Allocate a new DNS manager entry
++ */
+ struct ast_dnsmgr_entry *ast_dnsmgr_get(const char *name, struct sockaddr_in *result, const char *service)
+ {
+ 	struct ast_dnsmgr_entry *entry;
+@@ -96,7 +97,6 @@
+ 	entry->result = result;
+ 	ast_mutex_init(&entry->lock);
+ 	strcpy(entry->name, name);
+-	memcpy(&entry->last, result, sizeof(entry->last));
+ 	if (service) {
+ 		entry->service = ((char *) entry) + sizeof(*entry) + strlen(name);
+ 		strcpy(entry->service, service);
+@@ -109,6 +109,9 @@
+ 	return entry;
+ }
+ 
++/* 
++ * Free a DNS manager entry
++ */
+ void ast_dnsmgr_release(struct ast_dnsmgr_entry *entry)
+ {
+ 	if (!entry)
+@@ -123,6 +126,9 @@
+ 	ast_free(entry);
+ }
+ 
++/* 
++ * Allocate a new DNS manager entry and perform the initial lookup before returning
++ */
+ int ast_dnsmgr_lookup(const char *name, struct sockaddr_in *result, struct ast_dnsmgr_entry **dnsmgr, const char *service)
+ {
+ 	if (ast_strlen_zero(name) || !result || !dnsmgr)
+@@ -133,8 +139,10 @@
+ 
+ 	/* if it's actually an IP address and not a name,
+ 	   there's no need for a managed lookup */
+-	if (inet_aton(name, &result->sin_addr))
++	if (inet_aton(name, &result->sin_addr)) {
++		result->sin_family = AF_INET;
+ 		return 0;
++		}
+ 
+ 	ast_verb(4, "doing dnsmgr_lookup for '%s'\n", name);
+ 
+@@ -151,7 +159,7 @@
+ }
+ 
+ /*
+- * Refresh a dnsmgr entry
++ * Force a refresh of a dnsmgr entry
+  */
+ static int dnsmgr_refresh(struct ast_dnsmgr_entry *entry, int verbose)
+ {
+@@ -164,15 +172,15 @@
+ 	if (verbose)
+ 		ast_verb(3, "refreshing '%s'\n", entry->name);
+ 
+-	tmp.sin_port = entry->last.sin_port;
++	memset(&tmp, 0, sizeof(tmp));
++	tmp.sin_port = entry->result->sin_port;
+ 	
+-	if (!ast_get_ip_or_srv(&tmp, entry->name, entry->service) && inaddrcmp(&tmp, &entry->last)) {
+-		ast_copy_string(iabuf, ast_inet_ntoa(entry->last.sin_addr), sizeof(iabuf));
++	if (!ast_get_ip_or_srv(&tmp, entry->name, entry->service) && inaddrcmp(&tmp, entry->result)) {
++		ast_copy_string(iabuf, ast_inet_ntoa(entry->result->sin_addr), sizeof(iabuf));
+ 		ast_copy_string(iabuf2, ast_inet_ntoa(tmp.sin_addr), sizeof(iabuf2));
+ 		ast_log(LOG_NOTICE, "dnssrv: host '%s' changed from %s:%d to %s:%d\n", 
+-			entry->name, iabuf, ntohs(entry->last.sin_port), iabuf2, ntohs(tmp.sin_port));
++			entry->name, iabuf, ntohs(entry->result->sin_port), iabuf2, ntohs(tmp.sin_port));
+ 		*entry->result = tmp;
+-		entry->last = tmp;
+ 		changed = entry->changed = 1;
+ 	}
+ 

=== modified file 'debian/patches/series'
--- debian/patches/series	2010-02-16 14:08:54 +0000
+++ debian/patches/series	2010-07-16 10:16:00 +0000
@@ -17,3 +17,4 @@
 dahdi_ptmp_nt
 dahdi_pri_debug_spannums
 sound_files
+dnsmgr-A-SRV-handling

=== modified file 'include/asterisk/dnsmgr.h'
--- include/asterisk/dnsmgr.h	2009-03-29 22:21:47 +0000
+++ include/asterisk/dnsmgr.h	2010-07-16 10:16:00 +0000
@@ -42,12 +42,12 @@
  *
  * \param name the hostname
  * \param result where the DNS manager should store the IP address as it refreshes it.
- *      it.
+ * \param service SRV prefix (optional, set to NULL to disable SRV)
  *
  * This function allocates a new DNS manager entry object, and fills it with the
  * provided hostname and IP address.  This function does not force an initial lookup
- * of the IP address.  So, generally, this should be used when the initial address
- * is already known.
+ * of the IP address.  So, this should be used when the initial address
+ * is already known and stored in result.
  *
  * \return a DNS manager entry
  * \version 1.6.1 result changed from struct in_addr to struct sockaddr_in to store port number
@@ -69,6 +69,7 @@
  * \param name the hostname
  * \param result where to store the IP address as the DNS manager refreshes it
  * \param dnsmgr Where to store the allocate DNS manager entry
+ * \param service SRV prefix (optional, set to NULL to disable SRV)
  *
  * This function allocates a new DNS manager entry object, and fills it with
  * the provided hostname and IP address.  This function _does_ force an initial

=== modified file 'main/acl.c'
--- main/acl.c	2010-04-13 16:27:27 +0000
+++ main/acl.c	2010-07-16 10:16:00 +0000
@@ -387,6 +387,7 @@
 		}
 	}
 	if ((hp = ast_gethostbyname(value, &ahp))) {
+		sin->sin_family = hp->h_addrtype;
 		memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
 	} else {
 		ast_log(LOG_WARNING, "Unable to lookup '%s'\n", value);

=== modified file 'main/dnsmgr.c'
--- main/dnsmgr.c	2010-02-16 14:08:54 +0000
+++ main/dnsmgr.c	2010-07-16 10:16:00 +0000
@@ -52,8 +52,6 @@
 struct ast_dnsmgr_entry {
 	/*! where we will store the resulting IP address and port number */
 	struct sockaddr_in *result;
-	/*! the last result, used to check if address/port has changed */
-	struct sockaddr_in last;
 	/*! SRV record to lookup, if provided. Composed of service, protocol, and domain name: _Service._Proto.Name */
 	char *service;
 	/*! Set to 1 if the entry changes */
@@ -85,6 +83,9 @@
 	.verbose = 0,
 };
 
+/* 
+ * Allocate a new DNS manager entry
+ */
 struct ast_dnsmgr_entry *ast_dnsmgr_get(const char *name, struct sockaddr_in *result, const char *service)
 {
 	struct ast_dnsmgr_entry *entry;
@@ -96,7 +97,6 @@
 	entry->result = result;
 	ast_mutex_init(&entry->lock);
 	strcpy(entry->name, name);
-	memcpy(&entry->last, result, sizeof(entry->last));
 	if (service) {
 		entry->service = ((char *) entry) + sizeof(*entry) + strlen(name);
 		strcpy(entry->service, service);
@@ -109,6 +109,9 @@
 	return entry;
 }
 
+/* 
+ * Free a DNS manager entry
+ */
 void ast_dnsmgr_release(struct ast_dnsmgr_entry *entry)
 {
 	if (!entry)
@@ -123,6 +126,9 @@
 	ast_free(entry);
 }
 
+/* 
+ * Allocate a new DNS manager entry and perform the initial lookup before returning
+ */
 int ast_dnsmgr_lookup(const char *name, struct sockaddr_in *result, struct ast_dnsmgr_entry **dnsmgr, const char *service)
 {
 	if (ast_strlen_zero(name) || !result || !dnsmgr)
@@ -133,8 +139,10 @@
 
 	/* if it's actually an IP address and not a name,
 	   there's no need for a managed lookup */
-	if (inet_aton(name, &result->sin_addr))
+	if (inet_aton(name, &result->sin_addr)) {
+		result->sin_family = AF_INET;
 		return 0;
+		}
 
 	ast_verb(4, "doing dnsmgr_lookup for '%s'\n", name);
 
@@ -151,7 +159,7 @@
 }
 
 /*
- * Refresh a dnsmgr entry
+ * Force a refresh of a dnsmgr entry
  */
 static int dnsmgr_refresh(struct ast_dnsmgr_entry *entry, int verbose)
 {
@@ -164,15 +172,15 @@
 	if (verbose)
 		ast_verb(3, "refreshing '%s'\n", entry->name);
 
-	tmp.sin_port = entry->last.sin_port;
+	memset(&tmp, 0, sizeof(tmp));
+	tmp.sin_port = entry->result->sin_port;
 	
-	if (!ast_get_ip_or_srv(&tmp, entry->name, entry->service) && inaddrcmp(&tmp, &entry->last)) {
-		ast_copy_string(iabuf, ast_inet_ntoa(entry->last.sin_addr), sizeof(iabuf));
+	if (!ast_get_ip_or_srv(&tmp, entry->name, entry->service) && inaddrcmp(&tmp, entry->result)) {
+		ast_copy_string(iabuf, ast_inet_ntoa(entry->result->sin_addr), sizeof(iabuf));
 		ast_copy_string(iabuf2, ast_inet_ntoa(tmp.sin_addr), sizeof(iabuf2));
 		ast_log(LOG_NOTICE, "dnssrv: host '%s' changed from %s:%d to %s:%d\n", 
-			entry->name, iabuf, ntohs(entry->last.sin_port), iabuf2, ntohs(tmp.sin_port));
+			entry->name, iabuf, ntohs(entry->result->sin_port), iabuf2, ntohs(tmp.sin_port));
 		*entry->result = tmp;
-		entry->last = tmp;
 		changed = entry->changed = 1;
 	}