Use common net utility code (address and sockaddr manipulation).

9 files changed, 21 insertions, 409 deletions

diff --git a/source3/Makefile.in b/source3/Makefile.in
index dad046f0e1..01ea90ab9e 100644
--- a/source3/Makefile.in
+++ b/source3/Makefile.in
@@ -321,7 +321,7 @@ UTIL_OBJ = ../lib/util/rbtree.o ../lib/util/signal.o ../lib/util/time.o \
 		   ../lib/util/util_file.o ../lib/util/data_blob.o \
 		   ../lib/util/util.o ../lib/util/fsusage.o \
 		   ../lib/util/params.o ../lib/util/talloc_stack.o \
-		   ../lib/util/genrand.o 
+		   ../lib/util/genrand.o ../lib/util/util_net.o
 
 CRYPTO_OBJ = ../lib/crypto/crc32.o ../lib/crypto/md5.o \
 			 ../lib/crypto/hmacmd5.o ../lib/crypto/arcfour.o \
diff --git a/source3/include/proto.h b/source3/include/proto.h
index 96389802f6..61f864d3eb 100644
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -1476,11 +1476,13 @@ NTSTATUS sid_array_from_info3(TALLOC_CTX *mem_ctx,
 
 /* The following definitions come from lib/util_sock.c  */
 
+bool interpret_string_addr_internal(struct addrinfo **ppres,
+					const char *str, int flags);
 bool is_ipaddress_v4(const char *str);
 bool is_ipaddress(const char *str);
 bool is_broadcast_addr(const struct sockaddr *pss);
 uint32 interpret_addr(const char *str);
-struct in_addr *interpret_addr2(struct in_addr *ip, const char *str);
+struct in_addr interpret_addr2(const char *str);
 bool interpret_string_addr(struct sockaddr_storage *pss,
 		const char *str,
 		int flags);
diff --git a/source3/lib/util_sock.c b/source3/lib/util_sock.c
index d6677e2598..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 a broadcast address ?
-****************************************************************************/
-
-bool is_broadcast_addr(const struct sockaddr *pss)
-{
-#if defined(HAVE_IPV6)
-	if (pss->sa_family == AF_INET6) {
-		const struct in6_addr *sin6 =
-			&((const struct sockaddr_in6 *)pss)->sin6_addr;
-		return IN6_IS_ADDR_MULTICAST(sin6);
-	}
-#endif
-	if (pss->sa_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 is the loopback address.
-******************************************************************/
-
-bool is_loopback_addr(const struct sockaddr *pss)
-{
-#if defined(HAVE_IPV6)
-	if (pss->sa_family == AF_INET6) {
-		struct in6_addr *pin6 =
-			&((struct sockaddr_in6 *)pss)->sin6_addr;
-		return IN6_IS_ADDR_LOOPBACK(pin6);
-	}
-#endif
-	if (pss->sa_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 has an unspecified address.
-******************************************************************/
-
-bool is_zero_addr(const struct sockaddr *pss)
-{
-#if defined(HAVE_IPV6)
-	if (pss->sa_family == AF_INET6) {
-		struct in6_addr *pin6 =
-			&((struct sockaddr_in6 *)pss)->sin6_addr;
-		return IN6_IS_ADDR_UNSPECIFIED(pin6);
-	}
-#endif
-	if (pss->sa_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 *ip1,
-		const struct sockaddr *ip2,
-		const struct sockaddr *mask)
-{
-	if (ip1->sa_family != ip2->sa_family) {
-		/* Never on the same net. */
-		return false;
-	}
-
-#if defined(HAVE_IPV6)
-	if (ip1->sa_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->sa_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 's the same family and address ? Ignore port etc.
-********************************************************************/
-
-bool addr_equal(const struct sockaddr *ip1,
-		const struct sockaddr *ip2)
-{
-	if (ip1->sa_family != ip2->sa_family) {
-		/* Never the same. */
-		return false;
-	}
-
-#if defined(HAVE_IPV6)
-	if (ip1->sa_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->sa_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 *psa)
-{
-#if defined(HAVE_IPV6)
-	if (psa->sa_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->sa_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.
 ****************************************************************************/
@@ -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) {
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) {
diff --git a/source3/nmbd/nmbd_mynames.c b/source3/nmbd/nmbd_mynames.c
index 62c8dd0cf0..ed48095f23 100644
--- a/source3/nmbd/nmbd_mynames.c
+++ b/source3/nmbd/nmbd_mynames.c
@@ -168,7 +168,8 @@ bool register_my_workgroup_and_names(void)
 					namerec = find_name_on_subnet(unicast_subnet, &nmbname, FIND_SELF_NAME);
 					if (namerec == NULL) continue;
 					for (a=0;cluster_addresses[a];a++) {
-						add_ip_to_name_record(namerec, *interpret_addr2(&ip, cluster_addresses[a]));
+						ip = interpret_addr2(cluster_addresses[a]);
+						add_ip_to_name_record(namerec, ip);
 					}
 				}
 			}
diff --git a/source3/nmbd/nmbd_sendannounce.c b/source3/nmbd/nmbd_sendannounce.c
index 3cc9bb52b0..d5a7ba58fd 100644
--- a/source3/nmbd/nmbd_sendannounce.c
+++ b/source3/nmbd/nmbd_sendannounce.c
@@ -490,7 +490,7 @@ void announce_remote(time_t t)
 		else
 			wgroup = pwgroup;
 
-		(void)interpret_addr2(&addr,s2);
+		addr = interpret_addr2(s2);
 
 		/* Announce all our names including aliases */
 		/* Give the ip address as the address of our first
@@ -574,7 +574,7 @@ for workgroup %s on subnet %s.\n", lp_workgroup(), FIRST_SUBNET->subnet_name ));
 	frame = talloc_stackframe();
 	for (ptr=s; next_token_talloc(frame,&ptr,&s2,NULL); ) {
 		/* The entries are of the form a.b.c.d */
-		(void)interpret_addr2(&addr,s2);
+		addr = interpret_addr2(s2);
 
 		DEBUG(5,("announce_remote: Doing remote browse sync announce for server %s to IP %s.\n",
 			global_myname(), inet_ntoa(addr) ));
diff --git a/source3/nmbd/nmbd_winsserver.c b/source3/nmbd/nmbd_winsserver.c
index 5ee6e83138..74bed684fd 100644
--- a/source3/nmbd/nmbd_winsserver.c
+++ b/source3/nmbd/nmbd_winsserver.c
@@ -701,7 +701,7 @@ bool initialise_wins(void)
 		next_token_talloc(frame,&ptr,&ttl_str,NULL);
 		for(i = 0; i < num_ips; i++) {
 			next_token_talloc(frame,&ptr, &ip_str, NULL);
-			(void)interpret_addr2(&ip_list[i], ip_str);
+			ip_list[i] = interpret_addr2(ip_str);
 		}
 		next_token_talloc(frame,&ptr,&nb_flags_str,NULL);
 
@@ -835,7 +835,7 @@ void wins_process_name_refresh_request( struct subnet_record *subrec,
 	struct in_addr from_ip;
 	struct in_addr our_fake_ip;
 
-	(void)interpret_addr2(&our_fake_ip, "0.0.0.0");
+	our_fake_ip = interpret_addr2("0.0.0.0");
 	putip( (char *)&from_ip, &nmb->additional->rdata[2] );
 
 	if(bcast) {
@@ -1142,7 +1142,7 @@ void wins_process_name_registration_request(struct subnet_record *subrec,
 	bool registering_group_name = (nb_flags & NB_GROUP) ? True : False;
 	struct in_addr our_fake_ip;
 
-	(void)interpret_addr2(&our_fake_ip, "0.0.0.0");
+	our_fake_ip = interpret_addr2("0.0.0.0");
 	putip((char *)&from_ip,&nmb->additional->rdata[2]);
 
 	if(bcast) {
@@ -1217,7 +1217,7 @@ to register name %s. Name already exists in WINS with source type %d.\n",
 	 */
 
 	if(registering_group_name && (question->name_type != 0x1c)) {
-		(void)interpret_addr2(&from_ip, "255.255.255.255");
+		from_ip = interpret_addr2("255.255.255.255");
 	}
 
 	/*
@@ -1424,7 +1424,7 @@ static void wins_multihomed_register_query_success(struct subnet_record *subrec,
 	int ttl;
 	struct in_addr our_fake_ip;
 
-	(void)interpret_addr2(&our_fake_ip, "0.0.0.0");
+	our_fake_ip = interpret_addr2("0.0.0.0");
 	memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
 
 	nmb = &orig_reg_packet->packet.nmb;
@@ -1515,7 +1515,7 @@ void wins_process_multihomed_name_registration_request( struct subnet_record *su
 	struct in_addr our_fake_ip;
 	unstring qname;
 
-	(void)interpret_addr2(&our_fake_ip, "0.0.0.0");
+	our_fake_ip = interpret_addr2("0.0.0.0");
 	putip((char *)&from_ip,&nmb->additional->rdata[2]);
 
 	if(bcast) {
@@ -2141,7 +2141,7 @@ static int wins_processing_traverse_fn(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA
 	struct name_record *namerec = NULL;
 	struct in_addr our_fake_ip;
 
-	(void)interpret_addr2(&our_fake_ip, "0.0.0.0");
+	our_fake_ip = interpret_addr2("0.0.0.0");
 	if (kbuf.dsize != sizeof(unstring) + 1) {
 		return 0;
 	}
@@ -2422,7 +2422,7 @@ void nmbd_wins_new_entry(struct messaging_context *msg,
 	struct in_addr our_fake_ip;
 	int i;
 
-	(void)interpret_addr2(&our_fake_ip, "0.0.0.0");
+	our_fake_ip = interpret_addr2("0.0.0.0");
 	if (buf==NULL) {
 		return;
 	}
diff --git a/source3/utils/nmblookup.c b/source3/utils/nmblookup.c
index 45da3f1e88..63c9a34dd8 100644
--- a/source3/utils/nmblookup.c
+++ b/source3/utils/nmblookup.c
@@ -332,7 +332,7 @@ int main(int argc,char *argv[])
 
 		if(lookup_by_ip) {
 			struct sockaddr_storage ss;
-			(void)interpret_addr2(&ip, lookup);
+			ip = interpret_addr2(lookup);
 			in_addr_to_sockaddr_storage(&ss, ip);
 			fstrcpy(lookup,"*");
 			do_node_status(ServerFD, lookup, lookup_type, &ss);
diff --git a/source3/utils/smbcontrol.c b/source3/utils/smbcontrol.c
index 750030d916..9d571f7ee3 100644
--- a/source3/utils/smbcontrol.c
+++ b/source3/utils/smbcontrol.c
@@ -1129,7 +1129,7 @@ static bool do_nodestatus(struct messaging_context *msg_ctx,
 
 	ZERO_STRUCT(p);
 
-	(void)interpret_addr2(&p.ip, argv[1]);
+	p.ip = interpret_addr2(argv[1]);
 	p.port = 137;
 	p.packet_type = NMB_PACKET;