There is absolutely no need to cache connect timeout.

[user/henk/code/inspircd.git] / include / inspircd.h

diff --git a/include/inspircd.h b/include/inspircd.h
index 61bc3c33f018ddf2b64dce2645a3ccfe323c9b8a..566550376d21a79cbec98fb999011587ffbb6fba 100644 (file)
--- a/include/inspircd.h
+++ b/include/inspircd.h
@@ -39,7 +39,36 @@
 #include <cstring>
 #include <climits>
 
+#include <sstream>
+#include <string>
+#include <vector>
+#include <deque>
+#include <map>
+#include <bitset>
+
+
+/** A list of failed port bindings, used for informational purposes on startup */
+typedef std::vector<std::pair<std::string, std::string> > FailedPortList;
+
+/** A cached text file stored with its contents as lines
+ */
+typedef std::deque< std::string > file_cache;
+
+/** A configuration key and value pair
+ */
+typedef std::pair< std::string, std::string > KeyVal;
+
+/** A list of related configuration keys and values
+ */
+typedef std::vector< KeyVal > KeyValList;
+
+/** An entire config file, built up of KeyValLists
+ */
+typedef std::multimap< std::string, KeyValList > ConfigDataHash;
+
+
 #include "inspircd_config.h"
+#include "numerics.h"
 #include "uid.h"
 #include "users.h"
 #include "channels.h"
@@ -233,9 +262,6 @@ class serverstats : public classbase
        }
 };
 
-/** A list of failed port bindings, used for informational purposes on startup */
-typedef std::vector<std::pair<std::string, long> > FailedPortList;
-
 class InspIRCd;
 
 DEFINE_HANDLER1(ProcessUserHandler, void, User*);
@@ -274,12 +300,7 @@ class CoreExport ConfigReaderThread : public Thread
  * classbase. Amongst other things, it contains a ModeParser,
  * a DNS object, a CommandParser object, and a list of active
  * Module objects, and facilities for Module objects to
- * interact with the core system it implements. You should
- * NEVER attempt to instantiate a class of type InspIRCd
- * yourself. If you do, this is equivalent to spawning a second
- * IRC server, and could have catastrophic consequences for the
- * program in terms of ram usage (basically, you could create
- * an obese forkbomb built from recursively spawning irc servers!)
+ * interact with the core system it implements.
  */
 class CoreExport InspIRCd : public classbase
 {
@@ -328,7 +349,8 @@ class CoreExport InspIRCd : public classbase
         */
        time_t OLDTIME;
 
-       /** A 64k buffer used to read client lines into
+       /** A 64k buffer used to read socket data into
+        * NOTE: update ValidateNetBufferSize if you change this
         */
        char ReadBuffer[65535];
 
@@ -424,6 +446,10 @@ class CoreExport InspIRCd : public classbase
         */
        ThreadEngine* Threads;
 
+       /** Mutex engine, handles mutexes for threading where required
+        */
+       MutexFactory* Mutexes;
+
        /** The thread/class used to read config files in REHASH and on startup
         */
        ConfigReaderThread* ConfigThread;
@@ -690,14 +716,22 @@ class CoreExport InspIRCd : public classbase
         */
        void SendMode(const std::vector<std::string>& parameters, User *user);
 
-       /** Match two strings using pattern matching.
-        * This operates identically to the global function match(),
-        * except for that it takes std::string arguments rather than
-        * const char* ones.
-        * @param sliteral The literal string to match against
-        * @param spattern The pattern to match against. CIDR and globs are supported.
+       /** Match two strings using pattern matching, optionally, with a map
+        * to check case against (may be NULL). If map is null, match will be case insensitive.
+        * @param str The literal string to match against
+        * @param mask The glob pattern to match against.
         */
-       bool MatchText(const std::string &sliteral, const std::string &spattern);
+       static bool Match(const std::string &str, const std::string &mask, unsigned const char *map = NULL);
+       static bool Match(const  char *str, const char *mask, unsigned const char *map = NULL);
+
+       /** Match two strings using pattern matching, optionally, with a map
+        * to check case against (may be NULL). If map is null, match will be case insensitive.
+        * Supports CIDR patterns as well as globs.
+        * @param str The literal string to match against
+        * @param mask The glob or CIDR pattern to match against.
+        */
+       static bool MatchCIDR(const std::string &str, const std::string &mask, unsigned const char *map = NULL);
+       static bool MatchCIDR(const  char *str, const char *mask, unsigned const char *map = NULL);
 
        /** Call the handler for a given command.
         * @param commandname The command whos handler you wish to call
@@ -879,10 +913,16 @@ class CoreExport InspIRCd : public classbase
         */
        void BufferedSocketCull();
 
+       /** Adds an extban char to the 005 token.
+        */
+       void AddExtBanChar(char c);
+
        char* GetReadBuffer()
        {
                return this->ReadBuffer;
        }
 };
 
+ENTRYPOINT;
+
 #endif