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

1 files changed, 322 insertions, 43 deletions

diff --git a/lib/util/util_net.c b/lib/util/util_net.c
index 7bd083cc3a..eb5e2255c9 100644
--- a/lib/util/util_net.c
+++ b/lib/util/util_net.c
@@ -3,7 +3,7 @@
    Samba utility functions
    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
    Copyright (C) Andrew Tridgell 1992-1998
-   Copyright (C) Jeremy Allison 2001-2002
+   Copyright (C) Jeremy Allison 2001-2007
    Copyright (C) Simo Sorce 2001
    Copyright (C) Jim McDonough (jmcd@us.ibm.com)  2003.
    Copyright (C) James J Myers 2003
@@ -26,50 +26,105 @@
 #include "system/network.h"
 #include "system/locale.h"
 #include "system/filesys.h"
+#undef strcasecmp
 
 /**
- Interpret an internet address or name into an IP address in 4 byte form.
-**/
-_PUBLIC_ uint32_t interpret_addr(const char *str)
+ * Wrap getaddrinfo...
+ */
+bool interpret_string_addr_internal(struct addrinfo **ppres,
+					const char *str, int flags)
 {
-	struct hostent *hp;
-	uint32_t res;
+	int ret;
+	struct addrinfo hints;
 
-	if (str == NULL || *str == 0 ||
-	    strcmp(str,"0.0.0.0") == 0) {
-		return 0;
-	}
-	if (strcmp(str,"255.255.255.255") == 0) {
-		return 0xFFFFFFFF;
-	}
-	/* recognise 'localhost' as a special name. This fixes problems with
-	   some hosts that don't have localhost in /etc/hosts */
-	if (strcasecmp(str,"localhost") == 0) {
-		str = "127.0.0.1";
+	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_t interpret_addr(const char *str)
+{
+	uint32_t ret;
 
-	/* if it's in the form of an IP address then get the lib to interpret it */
-	if (is_ipaddress(str)) {
-		res = inet_addr(str);
+	/* 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 
-			sys_gethostbyname */
-		if ((hp = sys_gethostbyname(str)) == 0) {
-			DEBUG(3,("sys_gethostbyname: Unknown host. %s\n",str));
+		/* 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;
 		}
 
-		if(hp->h_addr == NULL) {
-			DEBUG(3,("sys_gethostbyname: host address is invalid for host %s\n",str));
+		/* 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;
 		}
-		memcpy((char *)&res,(char *)hp->h_addr, 4);
+		memcpy((char *)&ret,
+			&((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr,
+			sizeof(ret));
+		if (res_list) {
+			freeaddrinfo(res_list);
+		}
 	}
 
-	if (res == (uint32_t)-1)
-		return(0);
+	/* This is so bogus - all callers need fixing... JRA. */
+	if (ret == (uint32_t)-1) {
+		return 0;
+	}
 
-	return(res);
+	return ret;
 }
 
 /**
@@ -87,7 +142,7 @@ _PUBLIC_ struct in_addr interpret_addr2(const char *str)
  Check if an IP is the 0.0.0.0.
 **/
 
-_PUBLIC_ bool is_zero_ip(struct in_addr ip)
+_PUBLIC_ bool is_zero_ip_v4(struct in_addr ip)
 {
 	return ip.s_addr == 0;
 }
@@ -108,24 +163,248 @@ _PUBLIC_ bool same_net_v4(struct in_addr ip1, struct in_addr ip2, struct in_addr
 }
 
 /**
- Return true if a string could be a pure IP address.
-**/
+ * 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;
+}
+
+/**
+ * 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);
+}
 
-_PUBLIC_ bool is_ipaddress(const char *str)
+/**
+ * Check if a struct sockaddr is the loopback address.
+ */
+bool is_loopback_addr(const struct sockaddr *pss)
 {
-	bool pure_address = true;
-	int i;
+#if defined(HAVE_IPV6)
+	if (pss->sa_family == AF_INET6) {
+		const struct in6_addr *pin6 =
+			&((const struct sockaddr_in6 *)pss)->sin6_addr;
+		return IN6_IS_ADDR_LOOPBACK(pin6);
+	}
+#endif
+	if (pss->sa_family == AF_INET) {
+		const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
+		return is_loopback_ip_v4(*pin);
+	}
+	return false;
+}
 
-	if (str == NULL) return false;
+/**
+ * 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) {
+		const struct in6_addr *pin6 =
+			&((const struct sockaddr_in6 *)pss)->sin6_addr;
+		return IN6_IS_ADDR_UNSPECIFIED(pin6);
+	}
+#endif
+	if (pss->sa_family == AF_INET) {
+		const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
+		return is_zero_ip_v4(*pin);
+	}
+	return false;
+}
 
-	for (i=0; pure_address && str[i]; i++)
-		if (!(isdigit((int)str[i]) || str[i] == '.'))
-			pure_address = false;
+/**
+ * Set an IP to 0.0.0.0.
+ */
+void zero_ip_v4(struct in_addr *ip)
+{
+	memset(ip, '\0', sizeof(struct in_addr));
+}
 
-	/* Check that a pure number is not misinterpreted as an IP */
-	pure_address = pure_address && (strchr(str, '.') != NULL);
+/**
+ * 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;
+}
 
-	return pure_address;
+#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 = *(const struct sockaddr_in6 *)ip1;
+		struct sockaddr_in6 ip2_6 = *(const struct sockaddr_in6 *)ip2;
+		struct sockaddr_in6 mask_6 = *(const 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) {
+		const struct sockaddr_in6 *si6 = (const 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) {
+		const struct sockaddr_in *si = (const struct sockaddr_in *)psa;
+		if (si->sin_addr.s_addr == INADDR_ANY) {
+			return true;
+		}
+		return false;
+	}
+	return false;
+}