Convert the ISO 8859-2 nationalchars files to codepage configs.

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

diff --git a/src/inspstring.cpp b/src/inspstring.cpp
index 7fa4762c5b1b873bfe734f4eec2d66dc060716a9..3cbf0660282a5b082b36fd53d1e1e83ba7d4a1d1 100644 (file)
--- a/src/inspstring.cpp
+++ b/src/inspstring.cpp
@@ -1,9 +1,14 @@
 /*
  * InspIRCd -- Internet Relay Chat Daemon
  *
- *   Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org>
+ *   Copyright (C) 2017-2018 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com>
+ *   Copyright (C) 2012 Robby <robby@chatbelgie.be>
+ *   Copyright (C) 2010 Craig Edwards <brain@inspircd.org>
+ *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
+ *   Copyright (C) 2009 Uli Schlachter <psychon@inspircd.org>
+ *   Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net>
  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
- *   Copyright (C) 2005-2007 Craig Edwards <craigedwards@brainbox.cc>
  *
  * This file is part of InspIRCd.  InspIRCd is free software: you can
  * redistribute it and/or modify it under the terms of the GNU General Public
@@ -108,3 +113,124 @@ std::string Base64ToBin(const std::string& data_str, const char* table)
        }
        return rv;
 }
+
+bool InspIRCd::TimingSafeCompare(const std::string& one, const std::string& two)
+{
+       if (one.length() != two.length())
+               return false;
+
+       unsigned int diff = 0;
+       for (std::string::const_iterator i = one.begin(), j = two.begin(); i != one.end(); ++i, ++j)
+       {
+               unsigned char a = static_cast<unsigned char>(*i);
+               unsigned char b = static_cast<unsigned char>(*j);
+               diff |= a ^ b;
+       }
+
+       return (diff == 0);
+}
+
+void TokenList::AddList(const std::string& tokenlist)
+{
+       std::string token;
+       irc::spacesepstream tokenstream(tokenlist);
+       while (tokenstream.GetToken(token))
+       {
+               if (token[0] == '-')
+                       Remove(token.substr(1));
+               else
+                       Add(token);
+       }
+}
+void TokenList::Add(const std::string& token)
+{
+       // If the token is empty or contains just whitespace it is invalid.
+       if (token.empty() || token.find_first_not_of(" \t") == std::string::npos)
+               return;
+
+       // If the token is a wildcard entry then permissive mode has been enabled.
+       if (token == "*")
+       {
+               permissive = true;
+               tokens.clear();
+               return;
+       }
+
+       // If we are in permissive mode then remove the token from the token list.
+       // Otherwise, add it to the token list.
+       if (permissive)
+               tokens.erase(token);
+       else
+               tokens.insert(token);
+}
+
+void TokenList::Clear()
+{
+       permissive = false;
+       tokens.clear();
+}
+
+bool TokenList::Contains(const std::string& token) const
+{
+       // If we are in permissive mode and the token is in the list
+       // then we don't have it.
+       if (permissive && tokens.find(token) != tokens.end())
+               return false;
+
+       // If we are not in permissive mode and the token is not in
+       // the list then we don't have it.
+       if (!permissive && tokens.find(token) == tokens.end())
+               return false;
+
+       // We have the token!
+       return true;
+}
+
+void TokenList::Remove(const std::string& token)
+{
+       // If the token is empty or contains just whitespace it is invalid.
+       if (token.empty() || token.find_first_not_of(" \t") == std::string::npos)
+               return;
+
+       // If the token is a wildcard entry then permissive mode has been disabled.
+       if (token == "*")
+       {
+               permissive = false;
+               tokens.clear();
+               return;
+       }
+
+       // If we are in permissive mode then add the token to the token list.
+       // Otherwise, remove it from the token list.
+       if (permissive)
+               tokens.insert(token);
+       else
+               tokens.erase(token);
+}
+
+std::string TokenList::ToString() const
+{
+       std::string buffer(permissive ? "* " : "-* ");
+       buffer.append(stdalgo::string::join(tokens));
+       return buffer;
+}
+
+bool TokenList::operator==(const TokenList& other) const
+{
+       // Both sets must be in the same mode to be equal.
+       if (permissive != other.permissive)
+               return false;
+
+       // Both sets must be the same size to be equal.
+       if (tokens.size() != other.tokens.size())
+               return false;
+
+       for (insp::flat_set<std::string>::const_iterator iter = tokens.begin(); iter != tokens.end(); ++iter)
+       {
+               // Both sets must contain the same tokens to be equal.
+               if (other.tokens.find(*iter) == other.tokens.end())
+                       return false;
+       }
+
+       return true;
+}