Convert CIDR matching and wildcard matching to operate on std::strings

git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@9681 e03df62e-2008-0410-955e-edbf42e46eb7

1 files changed, 20 insertions, 53 deletions

diff --git a/src/cidr.cpp b/src/cidr.cpp
index 1288d269b..90654ee82 100644
--- a/src/cidr.cpp
+++ b/src/cidr.cpp
@@ -33,7 +33,7 @@ const unsigned char inverted_bits[8] = {	0x00, /* 00000000 - 0 bits - never actu
 
 
 /* Match raw bytes using CIDR bit matching, used by higher level MatchCIDR() */
-bool irc::sockets::MatchCIDRBits(unsigned char* address, unsigned char* mask, unsigned int mask_bits)
+bool irc::sockets::MatchCIDRBits(const unsigned char* address, const unsigned char* mask, unsigned int mask_bits)
 {
 	unsigned int divisor = mask_bits / 8; /* Number of whole bytes in the mask */
 	unsigned int modulus = mask_bits % 8; /* Remaining bits in the mask after whole bytes are dealt with */
@@ -53,7 +53,7 @@ bool irc::sockets::MatchCIDRBits(unsigned char* address, unsigned char* mask, un
 }
 
 /* Match CIDR, but dont attempt to match() against leading *!*@ sections */
-bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask)
+bool irc::sockets::MatchCIDR(const std::string &address, const std::string &cidr_mask)
 {
 	return MatchCIDR(address, cidr_mask, false);
 }
@@ -65,12 +65,14 @@ bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask)
  * This will also attempt to match any leading usernames or nicknames on the mask, using
  * match(), when match_with_username is true.
  */
-bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask, bool match_with_username)
+bool irc::sockets::MatchCIDR(const std::string &address, const std::string &cidr_mask, bool match_with_username)
 {
 	unsigned char addr_raw[16];
 	unsigned char mask_raw[16];
 	unsigned int bits = 0;
-	char* mask = NULL;
+
+	std::string address_copy;
+	std::string cidr_copy;
 
 	/* The caller is trying to match ident@<mask>/bits.
 	 * Chop off the ident@ portion, use match() on it
@@ -78,69 +80,39 @@ bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask, bool ma
 	 */
 	if (match_with_username)
 	{
-		/* Duplicate the strings, and try to find the position
-		 * of the @ symbol in each
-		 */
-		char* address_dupe = strdup(address);
-		char* cidr_dupe = strdup(cidr_mask);
-	
 		/* Use strchr not strrchr, because its going to be nearer to the left */
-		char* username_mask_pos = strrchr(cidr_dupe, '@');
-		char* username_addr_pos = strrchr(address_dupe, '@');
+		std::string::size_type username_mask_pos = cidr_mask.rfind('@');
+		std::string::size_type username_addr_pos = address.rfind('@');
 
 		/* Both strings have an @ symbol in them */
-		if (username_mask_pos && username_addr_pos)
+		if (username_mask_pos != std::string::npos && username_addr_pos != std::string::npos)
 		{
-			/* Zero out the location of the @ symbol */
-			*username_mask_pos = *username_addr_pos = 0;
-
 			/* Try and match() the strings before the @
 			 * symbols, and recursively call MatchCIDR without
 			 * username matching enabled to match the host part.
 			 */
-			bool result = (match(address_dupe, cidr_dupe) && MatchCIDR(username_addr_pos + 1, username_mask_pos + 1, false));
-
-			/* Free the stuff we created */
-			free(address_dupe);
-			free(cidr_dupe);
-
-			/* Return a result */
-			return result;
+			return (match(address.substr(0, username_addr_pos), cidr_mask.substr(0, username_mask_pos)) &&
+					MatchCIDR(address.substr(username_addr_pos + 1), cidr_mask.substr(username_mask_pos + 1), false));
 		}
 		else
 		{
-			/* One or both didnt have an @ in,
-			 * just match as CIDR
-			 */
-			free(address_dupe);
-			free(cidr_dupe);
-			mask = strdup(cidr_mask);
+			address_copy = address.substr(username_addr_pos + 1);
+			cidr_copy = cidr_mask.substr(username_mask_pos + 1);
 		}
 	}
-	else
-	{
-		/* Make a copy of the cidr mask string,
-		 * we're going to change it
-		 */
-		mask = strdup(cidr_mask);
-	}
 
 	in_addr  address_in4;
 	in_addr  mask_in4;
 
+	std::string::size_type bits_chars = cidr_copy.rfind('/');
 
-	/* Use strrchr for this, its nearer to the right */
-	char* bits_chars = strrchr(mask,'/');
-
-	if (bits_chars)
+	if (bits_chars != std::string::npos)
 	{
-		bits = atoi(bits_chars + 1);
-		*bits_chars = 0;
+		bits = atoi(cidr_copy.substr(bits_chars + 1).c_str());
 	}
 	else
 	{
 		/* No 'number of bits' field! */
-		free(mask);
 		return false;
 	}
 
@@ -148,9 +120,9 @@ bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask, bool ma
 	in6_addr address_in6;
 	in6_addr mask_in6;
 
-	if (inet_pton(AF_INET6, address, &address_in6) > 0)
+	if (inet_pton(AF_INET6, address_copy.c_str(), &address_in6) > 0)
 	{
-		if (inet_pton(AF_INET6, mask, &mask_in6) > 0)
+		if (inet_pton(AF_INET6, cidr_copy.c_str(), &mask_in6) > 0)
 		{
 			memcpy(&addr_raw, &address_in6.s6_addr, 16);
 			memcpy(&mask_raw, &mask_in6.s6_addr, 16);
@@ -163,15 +135,14 @@ bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask, bool ma
 			/* The address was valid ipv6, but the mask
 			 * that goes with it wasnt.
 			 */
-			free(mask);
 			return false;
 		}
 	}
 	else
 #endif
-	if (inet_pton(AF_INET, address, &address_in4) > 0)
+	if (inet_pton(AF_INET, address_copy.c_str(), &address_in4) > 0)
 	{
-		if (inet_pton(AF_INET, mask, &mask_in4) > 0)
+		if (inet_pton(AF_INET, cidr_copy.c_str(), &mask_in4) > 0)
 		{
 			memcpy(&addr_raw, &address_in4.s_addr, 4);
 			memcpy(&mask_raw, &mask_in4.s_addr, 4);
@@ -184,21 +155,17 @@ bool irc::sockets::MatchCIDR(const char* address, const char* cidr_mask, bool ma
 			/* The address was valid ipv4,
 			 * but the mask that went with it wasnt.
 			 */
-			free(mask);
 			return false;
 		}
 	}
 	else
 	{
 		/* The address was neither ipv4 or ipv6 */
-		free(mask);
 		return false;
 	}
 
 	/* Low-level-match the bits in the raw data */
-	free(mask);
 	return MatchCIDRBits(addr_raw, mask_raw, bits);
 }
 
 
-