Merge branch 'master' of git://git.samba.org/samba

5 files changed, 43 insertions, 652 deletions

diff --git a/source3/lib/access.c b/source3/lib/access.c
index 966d8ce87c..0b09e83ce3 100644
--- a/source3/lib/access.c
+++ b/source3/lib/access.c
@@ -66,7 +66,7 @@ static bool masked_match(const char *tok, const char *slash, const char *s)
 		}
         }
 
-	return same_net(&ss_host, &ss_tok, &ss_mask);
+	return same_net((struct sockaddr *)&ss_host, (struct sockaddr *)&ss_tok, (struct sockaddr *)&ss_mask);
 }
 
 /* string_match - match string s against token tok */
diff --git a/source3/lib/genrand.c b/source3/lib/genrand.c
deleted file mode 100644
index 076a2fd518..0000000000
--- a/source3/lib/genrand.c
+++ /dev/null
@@ -1,220 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-
-   Functions to create reasonable random numbers for crypto use.
-
-   Copyright (C) Jeremy Allison 2001
-   
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-
-static struct arcfour_state smb_arc4_state;
-static uint32 counter;
-
-static bool done_reseed = False;
-static void (*reseed_callback)(int *newseed);
-
-/**************************************************************** 
- Copy any user given reseed data.
-*****************************************************************/
-
-void set_rand_reseed_callback(void (*fn)(int *))
-{
-	reseed_callback = fn;
-	set_need_random_reseed();
-}
-
-void set_need_random_reseed(void)
-{
-	done_reseed = False;
-}
-
-static void get_rand_reseed_data(int *reseed_data)
-{
-	if (reseed_callback) {
-		reseed_callback(reseed_data);
-	} else {
-		*reseed_data = 0;
-	}
-}
-
-/****************************************************************
- Get a 16 byte hash from the contents of a file.
- Note that the hash is not initialised.
-*****************************************************************/
-
-static void do_filehash(const char *fname, unsigned char *the_hash)
-{
-	unsigned char buf[1011]; /* deliberate weird size */
-	unsigned char tmp_md4[16];
-	int fd, n;
-
-	fd = sys_open(fname,O_RDONLY,0);
-	if (fd == -1)
-		return;
-
-	while ((n = read(fd, (char *)buf, sizeof(buf))) > 0) {
-		mdfour(tmp_md4, buf, n);
-		for (n=0;n<16;n++)
-			the_hash[n] ^= tmp_md4[n];
-	}
-	close(fd);
-}
-
-/**************************************************************
- Try and get a good random number seed. Try a number of
- different factors. Firstly, try /dev/urandom - use if exists.
-
- We use /dev/urandom as a read of /dev/random can block if
- the entropy pool dries up. This leads clients to timeout
- or be very slow on connect.
-
- If we can't use /dev/urandom then seed the stream random generator
- above...
-**************************************************************/
-
-static int do_reseed(bool use_fd, int fd)
-{
-	unsigned char seed_inbuf[40];
-	DATA_BLOB seed_blob = { seed_inbuf, 40 };
-	uint32 v1, v2; struct timeval tval; pid_t mypid;
-	struct passwd *pw;
-	int reseed_data = 0;
-
-	if (use_fd) {
-		if (fd != -1)
-			return fd;
-
-		fd = sys_open( "/dev/urandom", O_RDONLY,0);
-		if(fd >= 0)
-			return fd;
-	}
-
-	/* Add in some secret file contents */
-
-	do_filehash("/etc/shadow", &seed_inbuf[0]);
-	do_filehash(lp_smb_passwd_file(), &seed_inbuf[16]);
-
-	/*
-	 * Add in the root encrypted password.
-	 * On any system where security is taken
-	 * seriously this will be secret.
-	 */
-
-	pw = getpwnam_alloc(NULL, "root");
-	if (pw && pw->pw_passwd) {
-		size_t i;
-		unsigned char md4_tmp[16];
-		mdfour(md4_tmp, (unsigned char *)pw->pw_passwd, strlen(pw->pw_passwd));
-		for (i=0;i<16;i++)
-			seed_inbuf[8+i] ^= md4_tmp[i];
-		TALLOC_FREE(pw);
-	}
-
-	/*
-	 * Add the counter, time of day, and pid.
-	 */
-
-	GetTimeOfDay(&tval);
-	mypid = sys_getpid();
-	v1 = (counter++) + mypid + tval.tv_sec;
-	v2 = (counter++) * mypid + tval.tv_usec;
-
-	SIVAL(seed_inbuf, 32, v1 ^ IVAL(seed_inbuf, 32));
-	SIVAL(seed_inbuf, 36, v2 ^ IVAL(seed_inbuf, 36));
-
-	/*
-	 * Add any user-given reseed data.
-	 */
-
-	get_rand_reseed_data(&reseed_data);
-	if (reseed_data) {
-		size_t i;
-		for (i = 0; i < sizeof(seed_inbuf); i++)
-			seed_inbuf[i] ^= ((char *)(&reseed_data))[i % sizeof(reseed_data)];
-	}
-
-	arcfour_init(&smb_arc4_state, &seed_blob);
-
-	return -1;
-}
-
-/*******************************************************************
- Interface to the (hopefully) good crypto random number generator.
-********************************************************************/
-
-void generate_random_buffer(uint8_t *out, int len)
-{
-	static int urand_fd = -1;
-	unsigned char md4_buf[64];
-	unsigned char tmp_buf[16];
-	unsigned char *p;
-
-	if(!done_reseed) {
-		urand_fd = do_reseed(True, urand_fd);
-		done_reseed = True;
-	}
-
-	if (urand_fd != -1 && len > 0) {
-
-		if (read(urand_fd, out, len) == len)
-			return; /* len bytes of random data read from urandom. */
-
-		/* Read of urand error, drop back to non urand method. */
-		close(urand_fd);
-		urand_fd = -1;
-		do_reseed(False, -1);
-		done_reseed = True;
-	}
-
-	/*
-	 * Generate random numbers in chunks of 64 bytes,
-	 * then md4 them & copy to the output buffer.
-	 * This way the raw state of the stream is never externally
-	 * seen.
-	 */
-
-	p = out;
-	while(len > 0) {
-		int copy_len = len > 16 ? 16 : len;
-
-		arcfour_crypt_sbox(&smb_arc4_state, md4_buf, sizeof(md4_buf));
-		mdfour(tmp_buf, md4_buf, sizeof(md4_buf));
-		memcpy(p, tmp_buf, copy_len);
-		p += copy_len;
-		len -= copy_len;
-	}
-}
-
-/*******************************************************************
- Use the random number generator to generate a random string.
-********************************************************************/
-
-static char c_list[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#.,";
-
-char *generate_random_str(TALLOC_CTX *mem_ctx, size_t len)
-{
-	unsigned char *retstr = talloc_zero_array(mem_ctx, unsigned char, len);
-	size_t i;
-
-	generate_random_buffer( retstr, len);
-	for (i = 0; i < len; i++)
-		retstr[i] = c_list[ retstr[i] % (sizeof(c_list)-1) ];
-
-	retstr[i] = '\0';
-
-	return (char *)retstr;
-}
diff --git a/source3/lib/interface.c b/source3/lib/interface.c
index 2e7c2706a0..4536990d28 100644
--- a/source3/lib/interface.c
+++ b/source3/lib/interface.c
@@ -29,11 +29,11 @@ static struct interface *local_interfaces;
  Check if an IP is one of mine.
 **************************************************************************/
 
-bool ismyaddr(const struct sockaddr_storage *ip)
+bool ismyaddr(const struct sockaddr *ip)
 {
 	struct interface *i;
 	for (i=local_interfaces;i;i=i->next) {
-		if (addr_equal(&i->ip,ip)) {
+		if (addr_equal((struct sockaddr *)&i->ip,ip)) {
 			return true;
 		}
 	}
@@ -44,14 +44,14 @@ bool ismyip_v4(struct in_addr ip)
 {
 	struct sockaddr_storage ss;
 	in_addr_to_sockaddr_storage(&ss, ip);
-	return ismyaddr(&ss);
+	return ismyaddr((struct sockaddr *)&ss);
 }
 
 /****************************************************************************
  Try and find an interface that matches an ip. If we cannot, return NULL.
 **************************************************************************/
 
-static struct interface *iface_find(const struct sockaddr_storage *ip,
+static struct interface *iface_find(const struct sockaddr *ip,
 				bool check_mask)
 {
 	struct interface *i;
@@ -62,10 +62,10 @@ static struct interface *iface_find(const struct sockaddr_storage *ip,
 
 	for (i=local_interfaces;i;i=i->next) {
 		if (check_mask) {
-			if (same_net(ip, &i->ip, &i->netmask)) {
+			if (same_net(ip, (struct sockaddr *)&i->ip, (struct sockaddr *)&i->netmask)) {
 				return i;
 			}
-		} else if (addr_equal(&i->ip, ip)) {
+		} else if (addr_equal((struct sockaddr *)&i->ip, ip)) {
 			return i;
 		}
 	}
@@ -77,11 +77,11 @@ static struct interface *iface_find(const struct sockaddr_storage *ip,
  Check if a packet is from a local (known) net.
 **************************************************************************/
 
-bool is_local_net(const struct sockaddr_storage *from)
+bool is_local_net(const struct sockaddr *from)
 {
 	struct interface *i;
 	for (i=local_interfaces;i;i=i->next) {
-		if (same_net(from, &i->ip, &i->netmask)) {
+		if (same_net(from, (struct sockaddr *)&i->ip, (struct sockaddr *)&i->netmask)) {
 			return true;
 		}
 	}
@@ -89,11 +89,11 @@ bool is_local_net(const struct sockaddr_storage *from)
 }
 
 #if defined(HAVE_IPV6)
-void setup_linklocal_scope_id(struct sockaddr_storage *pss)
+void setup_linklocal_scope_id(struct sockaddr *pss)
 {
 	struct interface *i;
 	for (i=local_interfaces;i;i=i->next) {
-		if (addr_equal(&i->ip,pss)) {
+		if (addr_equal((struct sockaddr *)&i->ip,pss)) {
 			struct sockaddr_in6 *psa6 =
 				(struct sockaddr_in6 *)pss;
 			psa6->sin6_scope_id = if_nametoindex(i->name);
@@ -112,7 +112,7 @@ bool is_local_net_v4(struct in_addr from)
 	struct sockaddr_storage ss;
 
 	in_addr_to_sockaddr_storage(&ss, from);
-	return is_local_net(&ss);
+	return is_local_net((struct sockaddr *)&ss);
 }
 
 /****************************************************************************
@@ -140,7 +140,7 @@ int iface_count_v4_nl(void)
 	struct interface *i;
 
 	for (i=local_interfaces;i;i=i->next) {
-		if (is_loopback_addr(&i->ip)) {
+		if (is_loopback_addr((struct sockaddr *)&i->ip)) {
 			continue;
 		}
 		if (i->ip.ss_family == AF_INET) {
@@ -265,7 +265,7 @@ const struct sockaddr_storage *iface_n_bcast(int n)
    an appropriate interface they return the requested field of the
    first known interface. */
 
-const struct sockaddr_storage *iface_ip(const struct sockaddr_storage *ip)
+const struct sockaddr_storage *iface_ip(const struct sockaddr *ip)
 {
 	struct interface *i = iface_find(ip, true);
 	if (i) {
@@ -276,7 +276,7 @@ const struct sockaddr_storage *iface_ip(const struct sockaddr_storage *ip)
 	 * matching address family. */
 
 	for (i=local_interfaces;i;i=i->next) {
-		if (i->ip.ss_family == ip->ss_family) {
+		if (i->ip.ss_family == ip->sa_family) {
 			return &i->ip;
 		}
 	}
@@ -287,7 +287,7 @@ const struct sockaddr_storage *iface_ip(const struct sockaddr_storage *ip)
   return True if a IP is directly reachable on one of our interfaces
 */
 
-bool iface_local(const struct sockaddr_storage *ip)
+bool iface_local(const struct sockaddr *ip)
 {
 	return iface_find(ip, True) ? true : false;
 }
@@ -301,7 +301,7 @@ static void add_interface(const struct iface_struct *ifs)
 	char addr[INET6_ADDRSTRLEN];
 	struct interface *iface;
 
-	if (iface_find(&ifs->ip, False)) {
+	if (iface_find((struct sockaddr *)&ifs->ip, False)) {
 		DEBUG(3,("add_interface: not adding duplicate interface %s\n",
 			print_sockaddr(addr, sizeof(addr), &ifs->ip) ));
 		return;
@@ -388,7 +388,7 @@ static void interpret_interface(char *token)
 		}
 
 		for (i=0;i<total_probed;i++) {
-			if (addr_equal(&ss, &probed_ifaces[i].ip)) {
+			if (addr_equal((struct sockaddr *)&ss, (struct sockaddr *)&probed_ifaces[i].ip)) {
 				add_interface(&probed_ifaces[i]);
 				return;
 			}
@@ -441,9 +441,12 @@ static void interpret_interface(char *token)
 	make_net(&ss_net, &ss, &ss_mask);
 
 	/* Maybe the first component was a broadcast address. */
-	if (addr_equal(&ss_bcast, &ss) || addr_equal(&ss_net, &ss)) {
+	if (addr_equal((struct sockaddr *)&ss_bcast, (struct sockaddr *)&ss) || 
+		addr_equal((struct sockaddr *)&ss_net, (struct sockaddr *)&ss)) {
 		for (i=0;i<total_probed;i++) {
-			if (same_net(&ss, &probed_ifaces[i].ip, &ss_mask)) {
+			if (same_net((struct sockaddr *)&ss, 
+						 (struct sockaddr *)&probed_ifaces[i].ip, 
+						 (struct sockaddr *)&ss_mask)) {
 				/* Temporarily replace netmask on
 				 * the detected interface - user knows
 				 * best.... */
diff --git a/source3/lib/util_sock.c b/source3/lib/util_sock.c
index f3dc3fc1d1..667dbf6dad 100644
--- a/source3/lib/util_sock.c
+++ b/source3/lib/util_sock.c
@@ -21,188 +21,6 @@
 
 #include "includes.h"
 
-/****************************************************************************
- Return true if a string could be an IPv4 address.
-****************************************************************************/
-
-bool is_ipaddress_v4(const char *str)
-{
-	int ret = -1;
-	struct in_addr dest;
-
-	ret = inet_pton(AF_INET, str, &dest);
-	if (ret > 0) {
-		return true;
-	}
-	return false;
-}
-
-/****************************************************************************
- Return true if a string could be an IPv4 or IPv6 address.
-****************************************************************************/
-
-bool is_ipaddress(const char *str)
-{
-#if defined(HAVE_IPV6)
-	int ret = -1;
-
-	if (strchr_m(str, ':')) {
-		char addr[INET6_ADDRSTRLEN];
-		struct in6_addr dest6;
-		const char *sp = str;
-		char *p = strchr_m(str, '%');
-
-		/*
-		 * Cope with link-local.
-		 * This is IP:v6:addr%ifname.
-		 */
-
-		if (p && (p > str) && (if_nametoindex(p+1) != 0)) {
-			strlcpy(addr, str,
-				MIN(PTR_DIFF(p,str)+1,
-					sizeof(addr)));
-			sp = addr;
-		}
-		ret = inet_pton(AF_INET6, sp, &dest6);
-		if (ret > 0) {
-			return true;
-		}
-	}
-#endif
-	return is_ipaddress_v4(str);
-}
-
-/****************************************************************************
- Is a sockaddr_storage a broadcast address ?
-****************************************************************************/
-
-bool is_broadcast_addr(const struct sockaddr_storage *pss)
-{
-#if defined(HAVE_IPV6)
-	if (pss->ss_family == AF_INET6) {
-		const struct in6_addr *sin6 =
-			&((const struct sockaddr_in6 *)pss)->sin6_addr;
-		return IN6_IS_ADDR_MULTICAST(sin6);
-	}
-#endif
-	if (pss->ss_family == AF_INET) {
-		uint32_t addr =
-		ntohl(((const struct sockaddr_in *)pss)->sin_addr.s_addr);
-		return addr == INADDR_BROADCAST;
-	}
-	return false;
-}
-
-/*******************************************************************
- Wrap getaddrinfo...
-******************************************************************/
-
-static bool interpret_string_addr_internal(struct addrinfo **ppres,
-					const char *str, int flags)
-{
-	int ret;
-	struct addrinfo hints;
-
-	memset(&hints, '\0', sizeof(hints));
-	/* By default make sure it supports TCP. */
-	hints.ai_socktype = SOCK_STREAM;
-	hints.ai_flags = flags;
-
-	/* Linux man page on getaddinfo() says port will be
-	   uninitialized when service string in NULL */
-
-	ret = getaddrinfo(str, NULL,
-			&hints,
-			ppres);
-
-	if (ret) {
-		DEBUG(3,("interpret_string_addr_internal: getaddrinfo failed "
-			"for name %s [%s]\n",
-			str,
-			gai_strerror(ret) ));
-		return false;
-	}
-	return true;
-}
-
-/****************************************************************************
- Interpret an internet address or name into an IP address in 4 byte form.
- RETURNS IN NETWORK BYTE ORDER (big endian).
-****************************************************************************/
-
-uint32 interpret_addr(const char *str)
-{
-	uint32 ret;
-
-	/* If it's in the form of an IP address then
-	 * get the lib to interpret it */
-	if (is_ipaddress_v4(str)) {
-		struct in_addr dest;
-
-		if (inet_pton(AF_INET, str, &dest) <= 0) {
-			/* Error - this shouldn't happen ! */
-			DEBUG(0,("interpret_addr: inet_pton failed "
-				"host %s\n",
-				str));
-			return 0;
-		}
-		ret = dest.s_addr; /* NETWORK BYTE ORDER ! */
-	} else {
-		/* Otherwise assume it's a network name of some sort and use
-			getadddrinfo. */
-		struct addrinfo *res = NULL;
-		struct addrinfo *res_list = NULL;
-		if (!interpret_string_addr_internal(&res_list,
-					str,
-					AI_ADDRCONFIG)) {
-			DEBUG(3,("interpret_addr: Unknown host. %s\n",str));
-			return 0;
-		}
-
-		/* Find the first IPv4 address. */
-		for (res = res_list; res; res = res->ai_next) {
-			if (res->ai_family != AF_INET) {
-				continue;
-			}
-			if (res->ai_addr == NULL) {
-				continue;
-			}
-			break;
-		}
-		if(res == NULL) {
-			DEBUG(3,("interpret_addr: host address is "
-				"invalid for host %s\n",str));
-			if (res_list) {
-				freeaddrinfo(res_list);
-			}
-			return 0;
-		}
-		putip((char *)&ret,
-			&((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr);
-		if (res_list) {
-			freeaddrinfo(res_list);
-		}
-	}
-
-	/* This is so bogus - all callers need fixing... JRA. */
-	if (ret == (uint32)-1) {
-		return 0;
-	}
-
-	return ret;
-}
-
-/*******************************************************************
- A convenient addition to interpret_addr().
-******************************************************************/
-
-struct in_addr *interpret_addr2(struct in_addr *ip, const char *str)
-{
-	uint32 a = interpret_addr(str);
-	ip->s_addr = a;
-	return ip;
-}
-
 /*******************************************************************
  Map a text hostname or IP address (IPv4 or IPv6) into a
  struct sockaddr_storage.
@@ -260,77 +78,6 @@ bool interpret_string_addr(struct sockaddr_storage *pss,
 }
 
 /*******************************************************************
- Check if an IPv7 is 127.0.0.1
-******************************************************************/
-
-bool is_loopback_ip_v4(struct in_addr ip)
-{
-	struct in_addr a;
-	a.s_addr = htonl(INADDR_LOOPBACK);
-	return(ip.s_addr == a.s_addr);
-}
-
-/*******************************************************************
- Check if a struct sockaddr_storage is the loopback address.
-******************************************************************/
-
-bool is_loopback_addr(const struct sockaddr_storage *pss)
-{
-#if defined(HAVE_IPV6)
-	if (pss->ss_family == AF_INET6) {
-		struct in6_addr *pin6 =
-			&((struct sockaddr_in6 *)pss)->sin6_addr;
-		return IN6_IS_ADDR_LOOPBACK(pin6);
-	}
-#endif
-	if (pss->ss_family == AF_INET) {
-		struct in_addr *pin = &((struct sockaddr_in *)pss)->sin_addr;
-		return is_loopback_ip_v4(*pin);
-	}
-	return false;
-}
-
-/*******************************************************************
- Check if an IPv4 is 0.0.0.0.
-******************************************************************/
-
-bool is_zero_ip_v4(struct in_addr ip)
-{
-	uint32 a;
-	putip((char *)&a,(char *)&ip);
-	return(a == 0);
-}
-
-/*******************************************************************
- Check if a struct sockaddr_storage has an unspecified address.
-******************************************************************/
-
-bool is_zero_addr(const struct sockaddr_storage *pss)
-{
-#if defined(HAVE_IPV6)
-	if (pss->ss_family == AF_INET6) {
-		struct in6_addr *pin6 =
-			&((struct sockaddr_in6 *)pss)->sin6_addr;
-		return IN6_IS_ADDR_UNSPECIFIED(pin6);
-	}
-#endif
-	if (pss->ss_family == AF_INET) {
-		struct in_addr *pin = &((struct sockaddr_in *)pss)->sin_addr;
-		return is_zero_ip_v4(*pin);
-	}
-	return false;
-}
-
-/*******************************************************************
- Set an IP to 0.0.0.0.
-******************************************************************/
-
-void zero_ip_v4(struct in_addr *ip)
-{
-	memset(ip, '\0', sizeof(struct in_addr));
-}
-
-/*******************************************************************
  Set an address to INADDR_ANY.
 ******************************************************************/
 
@@ -341,144 +88,6 @@ void zero_addr(struct sockaddr_storage *pss)
 	pss->ss_family = AF_INET;
 }
 
-/*******************************************************************
- Are two IPs on the same subnet - IPv4 version ?
-********************************************************************/
-
-bool same_net_v4(struct in_addr ip1,struct in_addr ip2,struct in_addr mask)
-{
-	uint32 net1,net2,nmask;
-
-	nmask = ntohl(mask.s_addr);
-	net1  = ntohl(ip1.s_addr);
-	net2  = ntohl(ip2.s_addr);
-
-	return((net1 & nmask) == (net2 & nmask));
-}
-
-/*******************************************************************
- Convert an IPv4 struct in_addr to a struct sockaddr_storage.
-********************************************************************/
-
-void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
-		struct in_addr ip)
-{
-	struct sockaddr_in *sa = (struct sockaddr_in *)ss;
-	memset(ss, '\0', sizeof(*ss));
-	sa->sin_family = AF_INET;
-	sa->sin_addr = ip;
-}
-
-#if defined(HAVE_IPV6)
-/*******************************************************************
- Convert an IPv6 struct in_addr to a struct sockaddr_storage.
-********************************************************************/
-
- void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
-		struct in6_addr ip)
-{
-	struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss;
-	memset(ss, '\0', sizeof(*ss));
-	sa->sin6_family = AF_INET6;
-	sa->sin6_addr = ip;
-}
-#endif
-
-/*******************************************************************
- Are two IPs on the same subnet?
-********************************************************************/
-
-bool same_net(const struct sockaddr_storage *ip1,
-		const struct sockaddr_storage *ip2,
-		const struct sockaddr_storage *mask)
-{
-	if (ip1->ss_family != ip2->ss_family) {
-		/* Never on the same net. */
-		return false;
-	}
-
-#if defined(HAVE_IPV6)
-	if (ip1->ss_family == AF_INET6) {
-		struct sockaddr_in6 ip1_6 = *(struct sockaddr_in6 *)ip1;
-		struct sockaddr_in6 ip2_6 = *(struct sockaddr_in6 *)ip2;
-		struct sockaddr_in6 mask_6 = *(struct sockaddr_in6 *)mask;
-		char *p1 = (char *)&ip1_6.sin6_addr;
-		char *p2 = (char *)&ip2_6.sin6_addr;
-		char *m = (char *)&mask_6.sin6_addr;
-		int i;
-
-		for (i = 0; i < sizeof(struct in6_addr); i++) {
-			*p1++ &= *m;
-			*p2++ &= *m;
-			m++;
-		}
-		return (memcmp(&ip1_6.sin6_addr,
-				&ip2_6.sin6_addr,
-				sizeof(struct in6_addr)) == 0);
-	}
-#endif
-	if (ip1->ss_family == AF_INET) {
-		return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr,
-				((const struct sockaddr_in *)ip2)->sin_addr,
-				((const struct sockaddr_in *)mask)->sin_addr);
-	}
-	return false;
-}
-
-/*******************************************************************
- Are two sockaddr_storage's the same family and address ? Ignore port etc.
-********************************************************************/
-
-bool addr_equal(const struct sockaddr_storage *ip1,
-		const struct sockaddr_storage *ip2)
-{
-	if (ip1->ss_family != ip2->ss_family) {
-		/* Never the same. */
-		return false;
-	}
-
-#if defined(HAVE_IPV6)
-	if (ip1->ss_family == AF_INET6) {
-		return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr,
-				&((const struct sockaddr_in6 *)ip2)->sin6_addr,
-				sizeof(struct in6_addr)) == 0);
-	}
-#endif
-	if (ip1->ss_family == AF_INET) {
-		return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr,
-				&((const struct sockaddr_in *)ip2)->sin_addr,
-				sizeof(struct in_addr)) == 0);
-	}
-	return false;
-}
-
-/****************************************************************************
- Is an IP address the INADDR_ANY or in6addr_any value ?
-****************************************************************************/
-
-bool is_address_any(const struct sockaddr_storage *psa)
-{
-#if defined(HAVE_IPV6)
-	if (psa->ss_family == AF_INET6) {
-		struct sockaddr_in6 *si6 = (struct sockaddr_in6 *)psa;
-		if (memcmp(&in6addr_any,
-				&si6->sin6_addr,
-				sizeof(in6addr_any)) == 0) {
-			return true;
-		}
-		return false;
-	}
-#endif
-	if (psa->ss_family == AF_INET) {
-		struct sockaddr_in *si = (struct sockaddr_in *)psa;
-		if (si->sin_addr.s_addr == INADDR_ANY) {
-			return true;
-		}
-		return false;
-	}
-	return false;
-}
-
 /****************************************************************************
  Get a port number in host byte order from a sockaddr_storage.
 ****************************************************************************/
@@ -508,13 +117,13 @@ uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
 
 static char *print_sockaddr_len(char *dest,
 			size_t destlen,
-			const struct sockaddr_storage *psa,
+			const struct sockaddr *psa,
 			socklen_t psalen)
 {
 	if (destlen > 0) {
 		dest[0] = '\0';
 	}
-	(void)sys_getnameinfo((const struct sockaddr *)psa,
+	(void)sys_getnameinfo(psa,
 			psalen,
 			dest, destlen,
 			NULL, 0,
@@ -530,7 +139,7 @@ char *print_sockaddr(char *dest,
 			size_t destlen,
 			const struct sockaddr_storage *psa)
 {
-	return print_sockaddr_len(dest, destlen, psa,
+	return print_sockaddr_len(dest, destlen, (struct sockaddr *)psa,
 			sizeof(struct sockaddr_storage));
 }
 
@@ -596,7 +205,7 @@ static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
 		return addr_buf;
 	}
 
-	return print_sockaddr_len(addr_buf, addr_len, &sa, length);
+	return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
 }
 
 #if 0
@@ -1313,7 +922,7 @@ int open_socket_out(int type,
 		psa6->sin6_port = htons(port);
 		if (psa6->sin6_scope_id == 0 &&
 				IN6_IS_ADDR_LINKLOCAL(&psa6->sin6_addr)) {
-			setup_linklocal_scope_id(&sock_out);
+			setup_linklocal_scope_id((struct sockaddr *)&sock_out);
 		}
 	}
 #endif
@@ -1555,7 +1164,7 @@ int open_udp_socket(const char *host, int port)
 	int res;
 	struct in_addr addr;
 
-	(void)interpret_addr2(&addr, host);
+	addr = interpret_addr2(host);
 
 	res = socket(PF_INET, type, 0);
 	if (res == -1) {
@@ -1583,7 +1192,7 @@ int open_udp_socket(const char *host, int port)
 static const char *get_peer_addr_internal(int fd,
 				char *addr_buf,
 				size_t addr_buf_len,
-				struct sockaddr_storage *pss,
+				struct sockaddr *pss,
 				socklen_t *plength)
 {
 	struct sockaddr_storage ss;
@@ -1596,9 +1205,7 @@ static const char *get_peer_addr_internal(int fd,
 	}
 
 	if (pss == NULL) {
-		pss = &ss;
-	}
-	if (plength == NULL) {
+		pss = (struct sockaddr *)&ss;
 		plength = &length;
 	}
 
@@ -1621,7 +1228,7 @@ static const char *get_peer_addr_internal(int fd,
 ******************************************************************/
 
 static bool matchname(const char *remotehost,
-		const struct sockaddr_storage *pss,
+		const struct sockaddr *pss,
 		socklen_t len)
 {
 	struct addrinfo *res = NULL;
@@ -1659,8 +1266,8 @@ static bool matchname(const char *remotehost,
 		if (!res->ai_addr) {
 			continue;
 		}
-		if (addr_equal((const struct sockaddr_storage *)res->ai_addr,
-					pss)) {
+		if (addr_equal((const struct sockaddr *)res->ai_addr,
+					(struct sockaddr *)pss)) {
 			freeaddrinfo(ailist);
 			return true;
 		}
@@ -1760,7 +1367,7 @@ const char *get_peer_name(int fd, bool force_lookup)
 	if (!lp_hostname_lookups() && (force_lookup == false)) {
 		length = sizeof(nc.ss);
 		nc.name = get_peer_addr_internal(fd, addr_buf, sizeof(addr_buf),
-			&nc.ss, &length);
+			(struct sockaddr *)&nc.ss, &length);
 		store_nc(&nc);
 		lookup_nc(&nc);
 		return nc.name ? nc.name : "UNKNOWN";
@@ -1769,10 +1376,10 @@ const char *get_peer_name(int fd, bool force_lookup)
 	lookup_nc(&nc);
 
 	memset(&ss, '\0', sizeof(ss));
-	p = get_peer_addr_internal(fd, addr_buf, sizeof(addr_buf), &ss, &length);
+	p = get_peer_addr_internal(fd, addr_buf, sizeof(addr_buf), (struct sockaddr *)&ss, &length);
 
 	/* it might be the same as the last one - save some DNS work */
-	if (addr_equal(&ss, &nc.ss)) {
+	if (addr_equal((struct sockaddr *)&ss, (struct sockaddr *)&nc.ss)) {
 		return nc.name ? nc.name : "UNKNOWN";
 	}
 
@@ -1797,7 +1404,7 @@ const char *get_peer_name(int fd, bool force_lookup)
 			gai_strerror(ret)));
 		strlcpy(name_buf, p, sizeof(name_buf));
 	} else {
-		if (!matchname(name_buf, &ss, length)) {
+		if (!matchname(name_buf, (struct sockaddr *)&ss, length)) {
 			DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
 			strlcpy(name_buf,"UNKNOWN",sizeof(name_buf));
 		}
@@ -2080,7 +1687,8 @@ bool is_myname_or_ipaddr(const char *s)
 			return false;
 		}
 
-		if (is_zero_addr(&ss) || is_loopback_addr(&ss)) {
+		if (is_zero_addr((struct sockaddr *)&ss) || 
+			is_loopback_addr((struct sockaddr *)&ss)) {
 			return false;
 		}
 
@@ -2091,7 +1699,7 @@ bool is_myname_or_ipaddr(const char *s)
 		}
 		n = get_interfaces(nics, MAX_INTERFACES);
 		for (i=0; i<n; i++) {
-			if (addr_equal(&nics[i].ip, &ss)) {
+			if (addr_equal((struct sockaddr *)&nics[i].ip, (struct sockaddr *)&ss)) {
 				TALLOC_FREE(nics);
 				return true;
 			}
diff --git a/source3/lib/wins_srv.c b/source3/lib/wins_srv.c
index 0e184a6b7c..b2c0bf8b87 100644
--- a/source3/lib/wins_srv.c
+++ b/source3/lib/wins_srv.c
@@ -183,11 +183,11 @@ static void parse_ip(struct tagged_ip *ip, const char *str)
 	char *s = strchr(str, ':');
 	if (!s) {
 		fstrcpy(ip->tag, "*");
-		(void)interpret_addr2(&ip->ip,str);
+		ip->ip = interpret_addr2(str);
 		return;
 	} 
 
-	(void)interpret_addr2(&ip->ip,s+1);
+	ip->ip = interpret_addr2(s+1);
 	fstrcpy(ip->tag, str);
 	s = strchr(ip->tag, ':');
 	if (s) {