Add <gecos> field to <server> in XML stats output, also add to ProtoServer. Fixes...

[user/henk/code/inspircd.git] / src / hashcomp.cpp

diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp
index 0a72645769ef880c9ab9ccd4b3485c339cdae666..1bcb538f6f499e37ba71788be1a9e9b7164f4cb7 100644 (file)
--- a/src/hashcomp.cpp
+++ b/src/hashcomp.cpp
@@ -2,7 +2,7 @@
  *       | Inspire Internet Relay Chat Daemon |
  *       +------------------------------------+
  *
- *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
+ *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
  * See: http://www.inspircd.org/wiki/index.php/Credits
  *
  * This program is free but copyrighted software; see
@@ -11,16 +11,11 @@
  * ---------------------------------------------------
  */
 
+/* $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
+#include "hash_map.h"
 
 /******************************************************
  *
@@ -47,8 +42,6 @@ using stdext::hash_map;
  *
  ******************************************************/
 
-using namespace irc::sockets;
-
 /* convert a string to lowercase. Note following special circumstances
  * taken from RFC 1459. Many "official" server branches still hold to this
  * rule so i will too;
@@ -68,9 +61,13 @@ void nspace::strlower(char *n)
 }
 
 #ifndef WIN32
-size_t nspace::hash<string>::operator()(const string &s) const
+       #ifdef HASHMAP_DEPRECATED
+               size_t nspace::insensitive::operator()(const std::string &s) const
+       #else
+               size_t nspace::hash<std::string>::operator()(const std::string &s) const
+       #endif
 #else
-size_t nspace::hash_compare<string, std::less<string> >::operator()(const string &s) const
+       size_t nspace::hash_compare<std::string, std::less<std::string> >::operator()(const std::string &s) const
 #endif
 {
        /* XXX: NO DATA COPIES! :)
@@ -85,6 +82,7 @@ size_t nspace::hash_compare<string, std::less<string> >::operator()(const string
        return t;
 }
 
+
 #ifndef WIN32
 size_t nspace::hash<irc::string>::operator()(const irc::string &s) const
 #else
@@ -99,8 +97,8 @@ size_t nspace::hash_compare<irc::string, std::less<irc::string> >::operator()(co
 
 bool irc::StrHashComp::operator()(const std::string& s1, const std::string& s2) const
 {
-       unsigned char* n1 = (unsigned char*)s1.c_str();
-       unsigned char* n2 = (unsigned char*)s2.c_str();
+       const unsigned char* n1 = (const unsigned char*)s1.c_str();
+       const unsigned char* n2 = (const unsigned char*)s2.c_str();
        for (; *n1 && *n2; n1++, n2++)
                if (lowermap[*n1] != lowermap[*n2])
                        return false;
@@ -215,13 +213,37 @@ bool irc::tokenstream::GetToken(std::string &token)
        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)
 {
        last_starting_position = tokens.begin();
        n = tokens.begin();
 }
 
-const std::string irc::sepstream::GetToken()
+bool irc::sepstream::GetToken(std::string &token)
 {
        std::string::iterator lsp = last_starting_position;
 
@@ -230,18 +252,22 @@ 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()
@@ -266,19 +292,17 @@ std::string irc::hex(const unsigned char *raw, size_t rawsz)
        /* EWW! This used to be using sprintf, which is WAY inefficient. -Special */
        
        const char *hex = "0123456789abcdef";
-
-       std::string buf;
-       buf.reserve(rawsz * 2 + 1);
+       static char hexbuf[MAXBUF];
 
        size_t i, j;
        for (i = 0, j = 0; j < rawsz; ++j)
        {
-               buf[i++] = hex[raw[j] / 16];
-               buf[i++] = hex[raw[j] % 16];
+               hexbuf[i++] = hex[raw[j] / 16];
+               hexbuf[i++] = hex[raw[j] % 16];
        }
-       buf[i] = '\0';
+       hexbuf[i] = 0;
 
-       return buf;
+       return hexbuf;
 }
 
 CoreExport const char* irc::Spacify(const char* n)
@@ -292,7 +316,7 @@ CoreExport const char* irc::Spacify(const char* n)
 }
 
 
-irc::modestacker::modestacker(bool add) : adding(add)
+irc::modestacker::modestacker(InspIRCd* Instance, bool add) : ServerInstance(Instance), adding(add)
 {
        sequence.clear();
        sequence.push_back("");
@@ -336,7 +360,7 @@ int irc::modestacker::GetStackedLine(std::deque<std::string> &result, int max_li
        if (sequence.size() > 1)
                nextsize = sequence[1].length() + 2;
 
-       while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < MAXMODES+1) && ((size + nextsize) < max_line_size))
+       while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < ServerInstance->Config->Limits.MaxModes) && ((size + nextsize) < max_line_size))
        {
                result[0] += *(sequence[0].begin());
                if (!sequence[1].empty())
@@ -370,7 +394,7 @@ irc::stringjoiner::stringjoiner(const std::string &seperator, const std::deque<s
        joined.append(sequence[end]);
 }
 
-irc::stringjoiner::stringjoiner(const std::string &seperator, const char** sequence, int begin, int end)
+irc::stringjoiner::stringjoiner(const std::string &seperator, const char* const* sequence, int begin, int end)
 {
        for (int v = begin; v < end; v++)
                joined.append(sequence[v]).append(seperator);
@@ -431,16 +455,15 @@ long irc::portparser::GetToken()
                        in_range = 0;
        }
 
-       std::string x = sep->GetToken();
+       std::string x;
+       sep->GetToken(x);
 
        if (x.empty())
                return 0;
 
        while (Overlaps(atoi(x.c_str())))
        {
-               x = sep->GetToken();
-
-               if (x.empty())
+               if (!sep->GetToken(x))
                        return 0;
        }