* @returns True if the first mask_bits of address matches the first
* mask_bits of mask.
*/
- CoreExport bool MatchCIDRBits(unsigned char* address, unsigned char* mask, unsigned int mask_bits);
+ CoreExport bool MatchCIDRBits(const unsigned char* address, const unsigned char* mask, unsigned int mask_bits);
/** Match CIDR, without matching username/nickname parts.
*
* @param cidr_mask The human readable mask, e.g. 1.2.0.0/16
* @return True if the mask matches the address
*/
- CoreExport bool MatchCIDR(const char* address, const char* cidr_mask);
+ CoreExport bool MatchCIDR(const std::string &address, const std::string &cidr_mask);
/** Match CIDR, including an optional username/nickname part.
*
* @param cidr_mask The human readable mask, e.g. *\@1.2.0.0/16
* @return True if the mask matches the address
*/
- CoreExport bool MatchCIDR(const char* address, const char* cidr_mask, bool match_with_username);
+ CoreExport bool MatchCIDR(const std::string &address, const std::string &cidr_mask, bool match_with_username);
/** Convert an insp_inaddr into human readable form.
*
~TestSuite();
bool DoThreadTests();
+ bool DoWildTests();
};
#endif
* @param mask the mask to check against
* @return true if the strings match
*/
-CoreExport bool match(const char *str, const char *mask);
+CoreExport bool match(const std::string &str, const std::string &mask);
/** Match a string against a mask, and define wether or not to use CIDR rules
* @param str The string to check
* @param mask the mask to check against
* @param use_cidr_match True if CIDR matching rules should be applied first
* @return true if the strings match
*/
-CoreExport bool match(const char *str, const char *mask, bool use_cidr_match);
+CoreExport bool match(const std::string &str, const std::string &mask, bool use_cidr_match);
/** Match a string against a mask, defining wether case sensitivity applies.
* @param str The string to check
* @param mask the mask to check against
* @param case_sensitive True if the match is case sensitive
* @return True if the strings match
*/
-CoreExport bool match(bool case_sensitive, const char *str, const char *mask);
+CoreExport bool match(bool case_sensitive, const std::string &str, const std::string &mask);
/** Match a string against a mask, defining wether case sensitivity applies,
* and defining wether or not to use CIDR rules first.
* @param case_sensitive True if the match is case sensitive
* @param use_cidr_match True if CIDR matching rules should be applied first
* @return true if the strings match
*/
-CoreExport bool match(bool case_sensitive, const char *str, const char *mask, bool use_cidr_match);
+CoreExport bool match(bool case_sensitive, const std::string &str, const std::string &mask, bool use_cidr_match);
/* 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 */
}
/* 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);
}
* 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
*/
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;
}
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);
/* 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);
/* 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);
}
-
* e.g. we are restarting, or being launched by cron. Dont kill parent, and dont
* close stdin/stdout
*/
- if (!do_nofork)
+ if ((!do_nofork) && (!do_testsuite))
{
fclose(stdin);
fclose(stderr);
#include "inspircd.h"
#include "testsuite.h"
#include "threadengine.h"
+#include "wildcard.h"
#include <iostream>
using namespace std;
cout << "\n\n*** STARTING TESTSUITE ***\n";
std::string modname;
- std::string choice;
-
- ServerInstance->SE->Blocking(fileno(stdin));
+ char choice;
while (1)
{
cout << "(2) Load a module\n";
cout << "(3) Unload a module\n";
cout << "(4) Threading tests\n";
+ cout << "(5) Wildcard and CIDR tests\n";
cout << endl << "(X) Exit test suite\n";
cout << "\nChoice: ";
cin >> choice;
- switch (*choice.begin())
+ if (!choice)
+ continue;
+
+ switch (choice)
{
case '1':
FOREACH_MOD(I_OnRunTestSuite, OnRunTestSuite());
case '4':
cout << (DoThreadTests() ? "\nSUCCESS!\n" : "\nFAILURE\n");
break;
+ case '5':
+ cout << (DoWildTests() ? "\nSUCCESS!\n" : "\nFAILURE\n");
+ break;
case 'X':
return;
break;
}
}
+/* Test that x matches y with match() */
+#define WCTEST(x, y) cout << "match(\"" << x << "\",\"" << y "\") " << ((passed = (match(x, y) || passed)) ? " SUCCESS!\n" : " FAILURE\n")
+/* Test that x does not match y with match() */
+#define WCTESTNOT(x, y) cout << "!match(\"" << x << "\",\"" << y "\") " << ((passed = ((!match(x, y)) || passed)) ? " SUCCESS!\n" : " FAILURE\n")
+
+/* Test that x matches y with match() and cidr enabled */
+#define CIDRTEST(x, y) cout << "match(\"" << x << "\",\"" << y "\", true) " << ((passed = (match(x, y, true) || passed)) ? " SUCCESS!\n" : " FAILURE\n")
+/* Test that x does not match y with match() and cidr enabled */
+#define CIDRTESTNOT(x, y) cout << "!match(\"" << x << "\",\"" << y "\", true) " << ((passed = ((!match(x, y, true)) || passed)) ? " SUCCESS!\n" : " FAILURE\n")
+
+bool TestSuite::DoWildTests()
+{
+ cout << "\n\nWildcard and CIDR tests\n\n";
+ bool passed = false;
+
+ WCTEST("foobar", "*");
+ WCTEST("foobar", "foo*");
+ WCTEST("foobar", "*bar");
+ WCTEST("foobar", "foo??r");
+
+ WCTESTNOT("foobar", "bazqux");
+ WCTESTNOT("foobar", "*qux");
+ WCTESTNOT("foobar", "foo*x");
+ WCTESTNOT("foobar", "baz*");
+
+ CIDRTEST("brain@1.2.3.4", "*@1.2.0.0/16");
+ CIDRTEST("brain@1.2.3.4", "*@1.2.3.0/24");
+
+ CIDRTESTNOT("brain@1.2.3.4", "x*@1.2.0.0/16");
+ CIDRTESTNOT("brain@1.2.3.4", "*@1.3.4.0/24");
+
+ return passed;
+}
+
bool TestSuite::DoThreadTests()
{
std::string anything;
using irc::sockets::MatchCIDR;
-// Wed 27 Apr 2005 - Brain
-// I've taken our our old wildcard routine -
-// although comprehensive, it was topheavy and very
-// slow, and ate masses of cpu when doing lots of
-// comparisons. This is the 'de-facto' routine used
-// by many, nobody really knows who wrote it first
-// or what license its under, i've seen examples of it
-// (unattributed to any author) all over the 'net.
-// For now, we'll just consider this public domain.
-
-CoreExport bool csmatch(const char *str, const char *mask)
+/* Rewritten to operate on more effective C++ std::string types
+ * rather than char* to avoid data copies.
+ * - Brain
+ */
+
+CoreExport bool csmatch(const std::string &str, const std::string &mask)
{
- unsigned char *cp = NULL, *mp = NULL;
- unsigned char* string = (unsigned char*)str;
- unsigned char* wild = (unsigned char*)mask;
+ std::string::const_iterator cp, mp;
+
+ //unsigned char *cp = NULL, *mp = NULL;
+ //unsigned char* string = (unsigned char*)str;
+ //unsigned char* wild = (unsigned char*)mask;
+
+ std::string::const_iterator wild = mask.begin();
+ std::string::const_iterator string = str.begin();
- while ((*string) && (*wild != '*'))
+ while ((string != str.end()) && (wild != mask.end()) && (*wild != '*'))
{
if ((*wild != *string) && (*wild != '?'))
- {
return 0;
- }
+
wild++;
string++;
}
- while (*string)
+ while (string != str.end())
{
if (*wild == '*')
{
- if (!*++wild)
- {
+ if (++wild == mask.end())
return 1;
- }
+
mp = wild;
- cp = string+1;
+ cp = string;
+ cp++;
}
else
if ((*wild == *string) || (*wild == '?'))
}
- while (*wild == '*')
- {
+ while ((wild != mask.end()) && (*wild == '*'))
wild++;
- }
- return !*wild;
+ return wild == mask.end();
}
-CoreExport bool match(const char *str, const char *mask)
+CoreExport bool match(const std::string &str, const std::string &mask)
{
- unsigned char *cp = NULL, *mp = NULL;
- unsigned char* string = (unsigned char*)str;
- unsigned char* wild = (unsigned char*)mask;
+ std::string::const_iterator cp, mp;
+ std::string::const_iterator wild = mask.begin();
+ std::string::const_iterator string = str.begin();
- while ((*string) && (*wild != '*'))
+ while ((string != str.end()) && (wild != mask.end()) && (*wild != '*'))
{
- if ((lowermap[*wild] != lowermap[*string]) && (*wild != '?'))
- {
+ if ((lowermap[(unsigned char)*wild] != lowermap[(unsigned char)*string]) && (*wild != '?'))
return 0;
- }
+
wild++;
string++;
}
- while (*string)
+ while (string != str.end())
{
if (*wild == '*')
{
- if (!*++wild)
- {
+ if (++wild == mask.end())
return 1;
- }
+
mp = wild;
- cp = string+1;
+ cp = string;
+ cp++;
}
else
- if ((lowermap[*wild] == lowermap[*string]) || (*wild == '?'))
+ if ((lowermap[(unsigned char)*wild] == lowermap[(unsigned char)*string]) || (*wild == '?'))
{
wild++;
string++;
}
- while (*wild == '*')
- {
+ while ((wild != mask.end()) && (*wild == '*'))
wild++;
- }
- return !*wild;
+ return wild == mask.end();
}
/* Overloaded function that has the option of using cidr */
-CoreExport bool match(const char *str, const char *mask, bool use_cidr_match)
+CoreExport bool match(const std::string &str, const std::string &mask, bool use_cidr_match)
{
if (use_cidr_match && MatchCIDR(str, mask, true))
return true;
return match(str, mask);
}
-CoreExport bool match(bool case_sensitive, const char *str, const char *mask, bool use_cidr_match)
+CoreExport bool match(bool case_sensitive, const std::string &str, const std::string &mask, bool use_cidr_match)
{
if (use_cidr_match && MatchCIDR(str, mask, true))
return true;
return case_sensitive ? csmatch(str, mask) : match(str, mask);
}
-CoreExport bool match(bool case_sensitive, const char *str, const char *mask)
+CoreExport bool match(bool case_sensitive, const std::string &str, const std::string &mask)
{
return case_sensitive ? csmatch(str, mask) : match(str, mask);
}
projects / user / henk / code / inspircd.git / commitdiff