]> git.netwichtig.de Git - user/henk/code/inspircd.git/blobdiff - src/hashcomp.cpp
Remove InspIRCd::WriteOpers in favour of snomask O
[user/henk/code/inspircd.git] / src / hashcomp.cpp
index e1dbad06fd0deaf85279d87d78e8eef56b73036c..15be92bd7105cbd631824ea8076da9bbd50f59da 100644 (file)
@@ -2,24 +2,27 @@
  *       | Inspire Internet Relay Chat Daemon |
  *       +------------------------------------+
  *
- *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- *                    E-mail:
- *             <brain@chatspike.net>
- *             <Craig@chatspike.net>
+ *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
+ * See: http://www.inspircd.org/wiki/index.php/Credits
  *
- * Written by Craig Edwards, Craig McLure, and others.
  * This program is free but copyrighted software; see
- *         the file COPYING for details.
+ *            the file COPYING for details.
  *
  * ---------------------------------------------------
  */
 
-using namespace std;
+/* $Core: libIRCDhash */
 
 #include "inspircd.h"
 #include "hashcomp.h"
+#ifndef WIN32
 #include <ext/hash_map>
 #define nspace __gnu_cxx
+#else
+#include <hash_map>
+#define nspace stdext
+using stdext::hash_map;
+#endif
 
 /******************************************************
  *
@@ -44,13 +47,8 @@ using namespace std;
  * Scandanavian Comparisons: The characters [, ], \ will
  * be considered the lowercase of {, } and |.
  *
- * This file also contains hashing methods for hashing
- * insp_inaddr structs, we use this if we want to cache IP
- * addresses.
- *
  ******************************************************/
 
-using namespace std;
 using namespace irc::sockets;
 
 /* convert a string to lowercase. Note following special circumstances
@@ -71,14 +69,11 @@ void nspace::strlower(char *n)
        }
 }
 
-size_t nspace::hash<insp_inaddr>::operator()(const insp_inaddr &a) const
-{
-       size_t q;
-       memcpy(&q,&a,sizeof(size_t));
-       return q;
-}
-
+#ifndef WIN32
 size_t nspace::hash<string>::operator()(const string &s) const
+#else
+size_t nspace::hash_compare<string, std::less<string> >::operator()(const string &s) const
+#endif
 {
        /* XXX: NO DATA COPIES! :)
         * The hash function here is practically
@@ -92,6 +87,18 @@ size_t nspace::hash<string>::operator()(const string &s) const
        return t;
 }
 
+#ifndef WIN32
+size_t nspace::hash<irc::string>::operator()(const irc::string &s) const
+#else
+size_t nspace::hash_compare<irc::string, std::less<irc::string> >::operator()(const irc::string &s) const
+#endif
+{
+       register size_t t = 0;
+       for (irc::string::const_iterator x = s.begin(); x != s.end(); ++x) /* ++x not x++, as its faster */
+               t = 5 * t + lowermap[(unsigned char)*x];
+       return t;
+}
+
 bool irc::StrHashComp::operator()(const std::string& s1, const std::string& s2) const
 {
        unsigned char* n1 = (unsigned char*)s1.c_str();
@@ -102,18 +109,6 @@ bool irc::StrHashComp::operator()(const std::string& s1, const std::string& s2)
        return (lowermap[*n1] == lowermap[*n2]);
 }
 
-bool irc::InAddr_HashComp::operator()(const insp_inaddr &s1, const insp_inaddr &s2) const
-{
-#ifdef IPV6
-       for (int n = 0; n < 16; n++)
-               if (s2.s6_addr[n] != s1.s6_addr[n])
-                       return false;
-       return true;
-#else
-       return (s1.s_addr == s1.s_addr);
-#endif
-}
-
 /******************************************************
  *
  * This is the implementation of our special irc::string
@@ -145,40 +140,20 @@ int irc::irc_char_traits::compare(const char* str1, const char* str2, size_t n)
        for(unsigned int i = 0; i < n; i++)
        {
                if(lowermap[(unsigned char)*str1] > lowermap[(unsigned char)*str2])
-                               return 1;
+                       return 1;
 
                if(lowermap[(unsigned char)*str1] < lowermap[(unsigned char)*str2])
-                       return -1;
+                       return -1;
 
                if(*str1 == 0 || *str2 == 0)
-                       return 0;
+                       return 0;
 
-               str1++;
+               str1++;
                str2++;
        }
        return 0;
 }
 
-std::string operator+ (std::string& leftval, irc::string& rightval)
-{
-       return leftval + std::string(rightval.c_str());
-}
-
-irc::string operator+ (irc::string& leftval, std::string& rightval)
-{
-       return leftval + irc::string(rightval.c_str());
-}
-
-bool operator== (std::string& leftval, irc::string& rightval)
-{
-       return (leftval == std::string(rightval.c_str()));
-}
-
-bool operator== (irc::string& leftval, std::string& rightval)
-{
-       return (rightval == std::string(leftval.c_str()));
-}
-
 const char* irc::irc_char_traits::find(const char* s1, int  n, char c)
 {
        while(n-- > 0 && lowermap[(unsigned char)*s1] != lowermap[(unsigned char)c])
@@ -186,20 +161,6 @@ const char* irc::irc_char_traits::find(const char* s1, int  n, char c)
        return s1;
 }
 
-/* See hashcomp.h if you care about these... */
-std::ostream& operator<<(std::ostream &os, const irc::string &str)
-{
-       return os << str.c_str();
-}
-
-std::istream& operator>>(std::istream &is, irc::string &str)
-{
-       std::string tmp;
-       is >> tmp;
-       str = tmp.c_str();
-       return is;
-}
-
 irc::tokenstream::tokenstream(const std::string &source) : tokens(source), last_pushed(false)
 {
        /* Record starting position and current position */
@@ -211,7 +172,7 @@ irc::tokenstream::~tokenstream()
 {
 }
 
-const std::string irc::tokenstream::GetToken()
+bool irc::tokenstream::GetToken(std::string &token)
 {
        std::string::iterator lsp = last_starting_position;
 
@@ -229,7 +190,8 @@ const std::string irc::tokenstream::GetToken()
                         */
                        std::string::iterator curr = ++n;
                        n = tokens.end();
-                       return std::string(curr, tokens.end());
+                       token = std::string(curr, tokens.end());
+                       return true;
                }
 
                last_pushed = false;
@@ -245,12 +207,38 @@ const std::string irc::tokenstream::GetToken()
                        while ((strip.length()) && (strip.find_last_of(' ') == strip.length() - 1))
                                strip.erase(strip.end() - 1);
 
-                       return strip;
+                       token = strip;
+                       return !token.empty();
                }
 
                n++;
        }
-       return "";
+       token.clear();
+       return false;
+}
+
+bool irc::tokenstream::GetToken(irc::string &token)
+{
+       std::string stdstring;
+       bool returnval = GetToken(stdstring);
+       token = assign(stdstring);
+       return returnval;
+}
+
+bool irc::tokenstream::GetToken(int &token)
+{
+       std::string tok;
+       bool returnval = GetToken(tok);
+       token = ConvToInt(tok);
+       return returnval;
+}
+
+bool irc::tokenstream::GetToken(long &token)
+{
+       std::string tok;
+       bool returnval = GetToken(tok);
+       token = ConvToInt(tok);
+       return returnval;
 }
 
 irc::sepstream::sepstream(const std::string &source, char seperator) : tokens(source), sep(seperator)
@@ -259,7 +247,7 @@ irc::sepstream::sepstream(const std::string &source, char seperator) : tokens(so
        n = tokens.begin();
 }
 
-const std::string irc::sepstream::GetToken()
+bool irc::sepstream::GetToken(std::string &token)
 {
        std::string::iterator lsp = last_starting_position;
 
@@ -268,18 +256,32 @@ const std::string irc::sepstream::GetToken()
                if ((*n == sep) || (n+1 == tokens.end()))
                {
                        last_starting_position = n+1;
-                       std::string strip = std::string(lsp, n+1 == tokens.end() ? n+1  : n++);
+                       token = std::string(lsp, n+1 == tokens.end() ? n+1  : n++);
 
-                       while ((strip.length()) && (strip.find_last_of(sep) == strip.length() - 1))
-                               strip.erase(strip.end() - 1);
+                       while ((token.length()) && (token.find_last_of(sep) == token.length() - 1))
+                               token.erase(token.end() - 1);
+
+                       if (token.empty())
+                               n++;
 
-                       return strip;
+                       return n == tokens.end() ? false : true;
                }
 
                n++;
        }
 
-       return "";
+       token = "";
+       return false;
+}
+
+const std::string irc::sepstream::GetRemaining()
+{
+       return std::string(n, tokens.end());
+}
+
+bool irc::sepstream::StreamEnd()
+{
+       return ((n + 1) == tokens.end());
 }
 
 irc::sepstream::~sepstream()
@@ -291,19 +293,23 @@ std::string irc::hex(const unsigned char *raw, size_t rawsz)
        if (!rawsz)
                return "";
 
-       char buf[rawsz*2+1];
-       size_t i;
+       /* EWW! This used to be using sprintf, which is WAY inefficient. -Special */
+       
+       const char *hex = "0123456789abcdef";
+       static char hexbuf[MAXBUF];
 
-       for (i = 0; i < rawsz; i++)
+       size_t i, j;
+       for (i = 0, j = 0; j < rawsz; ++j)
        {
-               sprintf (&(buf[i*2]), "%02x", raw[i]);
+               hexbuf[i++] = hex[raw[j] / 16];
+               hexbuf[i++] = hex[raw[j] % 16];
        }
-       buf[i*2] = 0;
+       hexbuf[i] = 0;
 
-       return buf;
+       return hexbuf;
 }
 
-const char* irc::Spacify(char* n)
+CoreExport const char* irc::Spacify(const char* n)
 {
        static char x[MAXBUF];
        strlcpy(x,n,MAXBUF);
@@ -341,19 +347,37 @@ void irc::modestacker::PushMinus()
        this->Push('-',"");
 }
 
-int irc::modestacker::GetStackedLine(std::deque<std::string> &result)
+int irc::modestacker::GetStackedLine(std::deque<std::string> &result, int max_line_size)
 {
+       if (sequence.empty())
+       {
+               result.clear();
+               return 0;
+       }
+
        int n = 0;
+       int size = 1; /* Account for initial +/- char */
+       int nextsize = 0;
        result.clear();
        result.push_back(adding ? "+" : "-");
 
-       while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < MAXMODES+1))
+       if (sequence.size() > 1)
+               nextsize = sequence[1].length() + 2;
+
+       while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < MAXMODES) && ((size + nextsize) < max_line_size))
        {
                result[0] += *(sequence[0].begin());
                if (!sequence[1].empty())
+               {
                        result.push_back(sequence[1]);
+                       size += nextsize; /* Account for mode character and whitespace */
+               }
                sequence[0].erase(sequence[0].begin());
                sequence.erase(sequence.begin() + 1);
+
+               if (sequence.size() > 1)
+                       nextsize = sequence[1].length() + 2;
+
                n++;
        }
 
@@ -386,9 +410,10 @@ std::string& irc::stringjoiner::GetJoined()
        return joined;
 }
 
-irc::portparser::portparser(const std::string &source) : in_range(0), range_begin(0), range_end(0)
+irc::portparser::portparser(const std::string &source, bool allow_overlapped) : in_range(0), range_begin(0), range_end(0), overlapped(allow_overlapped)
 {
        sep = new irc::commasepstream(source);
+       overlap_set.clear();
 }
 
 irc::portparser::~portparser()
@@ -396,22 +421,56 @@ irc::portparser::~portparser()
        delete sep;
 }
 
+bool irc::portparser::Overlaps(long val)
+{
+       if (!overlapped)
+               return false;
+
+       if (overlap_set.find(val) == overlap_set.end())
+       {
+               overlap_set[val] = true;
+               return false;
+       }
+       else
+               return true;
+}
+
 long irc::portparser::GetToken()
 {
        if (in_range > 0)
        {
                in_range++;
                if (in_range <= range_end)
-                       return in_range;
+               {
+                       if (!Overlaps(in_range))
+                       {
+                               return in_range;
+                       }
+                       else
+                       {
+                               while (((Overlaps(in_range)) && (in_range <= range_end)))
+                                       in_range++;
+                               
+                               if (in_range <= range_end)
+                                       return in_range;
+                       }
+               }
                else
                        in_range = 0;
        }
 
-       std::string x = sep->GetToken();
+       std::string x;
+       sep->GetToken(x);
 
-       if (x == "")
+       if (x.empty())
                return 0;
 
+       while (Overlaps(atoi(x.c_str())))
+       {
+               if (!sep->GetToken(x))
+                       return 0;
+       }
+
        std::string::size_type dash = x.rfind('-');
        if (dash != std::string::npos)
        {
@@ -437,3 +496,129 @@ long irc::portparser::GetToken()
        }
 }
 
+irc::dynamicbitmask::dynamicbitmask() : bits_size(4)
+{
+       /* We start with 4 bytes allocated which is room
+        * for 4 items. Something makes me doubt its worth
+        * allocating less than 4 bytes.
+        */
+       bits = new unsigned char[bits_size];
+       memset(bits, 0, bits_size);
+}
+
+irc::dynamicbitmask::~dynamicbitmask()
+{
+       /* Tidy up the entire used memory on delete */
+       delete[] bits;
+}
+
+irc::bitfield irc::dynamicbitmask::Allocate()
+{
+       /* Yeah, this isnt too efficient, however a module or the core
+        * should only be allocating bitfields on load, the Toggle and
+        * Get methods are O(1) as these are called much more often.
+        */
+       unsigned char* freebits = this->GetFreeBits();
+       for (unsigned char i = 0; i < bits_size; i++)
+       {
+               /* Yes, this is right. You'll notice we terminate the  loop when !current_pos,
+                * this is because we logic shift our bit off the end of unsigned char, and its
+                * lost, making the loop counter 0 when we're done.
+                */
+               for (unsigned char current_pos = 1; current_pos; current_pos = current_pos << 1)
+               {
+                       if (!(freebits[i] & current_pos))
+                       {
+                               freebits[i] |= current_pos;
+                               return std::make_pair(i, current_pos);
+                       }
+               }
+       }
+       /* We dont have any free space left, increase by one */
+
+       if (bits_size == 255)
+               /* Oh dear, cant grow it any further */
+               throw std::bad_alloc();
+
+       unsigned char old_bits_size = bits_size;
+       bits_size++;
+       /* Allocate new bitfield space */
+       unsigned char* temp_bits = new unsigned char[bits_size];
+       unsigned char* temp_freebits = new unsigned char[bits_size];
+       /* Copy the old data in */
+       memcpy(temp_bits, bits, old_bits_size);
+       memcpy(temp_freebits, freebits, old_bits_size);
+       /* Delete the old data pointers */
+       delete[] bits;
+       delete[] freebits;
+       /* Swap the pointers over so now the new 
+        * pointers point to our member values
+        */
+       bits = temp_bits;
+       freebits = temp_freebits;
+       this->SetFreeBits(freebits);
+       /* Initialize the new byte on the end of
+        * the bitfields, pre-allocate the one bit
+        * for this allocation
+        */
+       bits[old_bits_size] = 0;
+       freebits[old_bits_size] = 1;
+       /* We already know where we just allocated
+        * the bitfield, so no loop needed
+        */
+       return std::make_pair(old_bits_size, 1);
+}
+
+bool irc::dynamicbitmask::Deallocate(irc::bitfield &pos)
+{
+       /* We dont bother to shrink the bitfield
+        * on deallocation, the most we could do
+        * is save one byte (!) and this would cost
+        * us a loop (ugly O(n) stuff) so we just
+        * clear the bit and leave the memory
+        * claimed -- nobody will care about one
+        * byte.
+        */
+       if (pos.first < bits_size)
+       {
+               this->GetFreeBits()[pos.first] &= ~pos.second;
+               return true;
+       }
+       /* They gave a bitfield outside of the
+        * length of our array. BAD programmer.
+        */
+       return false;
+}
+
+void irc::dynamicbitmask::Toggle(irc::bitfield &pos, bool state)
+{
+       /* Range check the value */
+       if (pos.first < bits_size)
+       {
+               if (state)
+                       /* Set state, OR the state in */
+                       bits[pos.first] |= pos.second;
+               else
+                       /* Clear state, AND the !state out */
+                       bits[pos.first] &= ~pos.second;
+       }
+}
+
+bool irc::dynamicbitmask::Get(irc::bitfield &pos)
+{
+       /* Range check the value */
+       if (pos.first < bits_size)
+               return (bits[pos.first] & pos.second);
+       else
+               /* We can't return false, otherwise we can't
+                * distinguish between failure and a cleared bit!
+                * Our only sensible choice is to throw (ew).
+                */
+               throw ModuleException("irc::dynamicbitmask::Get(): Invalid bitfield, out of range");
+}
+
+unsigned char irc::dynamicbitmask::GetSize()
+{
+       return bits_size;
+}
+