* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- * E-mail:
- * <brain@chatspike.net>
- * <Craig@chatspike.net>
- *
- * Written by Craig Edwards, Craig McLure, and others.
+ * InspIRCd: (C) 2002-2007 InspIRCd Development Team
+ * See: http://www.inspircd.org/wiki/index.php/Credits
+ *
* This program is free but copyrighted software; see
- * the file COPYING for details.
+ * the file COPYING for details.
*
* ---------------------------------------------------
*/
return tmp.str();
}
+template<typename T> inline long ConvToInt(const T &in)
+{
+ std::stringstream tmp;
+ if (!(tmp << in)) return 0;
+ return atoi(tmp.str().c_str());
+}
+
/** This class contains various STATS counters
* It is used by the InspIRCd class, which internally
* has an instance of it.
*/
unsigned long BoundPortCount;
+ /** Cpu usage at last sample
+ */
+ timeval LastCPU;
+
+ /** Time last sample was read
+ */
+ timeval LastSampled;
+
/** The constructor initializes all the counts to zero
*/
serverstats()
/** A list of failed port bindings, used for informational purposes on startup */
typedef std::vector<std::pair<std::string, long> > FailedPortList;
+/** A list of ip addresses cross referenced against clone counts */
+typedef std::map<irc::string, unsigned int> clonemap;
+
class XLineManager;
/** The main class of the irc server.
*/
featurelist Features;
+ /** The interface names published by various modules
+ */
+ interfacelist Interfaces;
+
/** The current time, updated in the mainloop
*/
time_t TIME;
*/
std::vector<userrec*> all_opers;
+ clonemap local_clones;
+
+ clonemap global_clones;
+
/** Whowas container, contains a map of vectors of users tracked by WHOWAS
*/
irc::whowas::whowas_users whowas;
+ /** Whowas container, contains a map of time_t to users tracked by WHOWAS
+ */
+ irc::whowas::whowas_users_fifo whowas_fifo;
+
/** DNS class, provides resolver facilities to the core and modules
*/
DNS* Res;
*/
int SetTimeDelta(int delta);
+ void AddLocalClone(userrec* user);
+
+ void AddGlobalClone(userrec* user);
+
+ /** Get the time offset in seconds
+ * @return The current time delta (in seconds)
+ */
+ int GetTimeDelta();
+
/** Process a user whos socket has been flagged as active
* @param cu The user to process
* @return There is no actual return value, however upon exit, the user 'cu' may have been deleted
/** Send an error notice to all local users, opered and unopered
* @param s The error string to send
*/
- void SendError(const char *s);
+ void SendError(const std::string &s);
/** For use with Module::Prioritize().
* When the return value of this function is returned from
*/
bool PublishFeature(const std::string &FeatureName, Module* Mod);
+ /** Publish a module to an 'interface'.
+ * Modules which implement the same interface (the same way of communicating
+ * with other modules) can publish themselves to an interface, using this
+ * method. When they do so, they become part of a list of related or
+ * compatible modules, and a third module may then query for that list
+ * and know that all modules within that list offer the same API.
+ * A prime example of this is the hashing modules, which all accept the
+ * same types of Request class. Consider this to be similar to PublishFeature,
+ * except for that multiple modules may publish the same 'feature'.
+ * @param InterfaceName The case sensitive interface name to make available
+ * @param Mod a pointer to your module class
+ * @returns True on success, false on failure (there are currently no failure
+ * cases)
+ */
+ bool PublishInterface(const std::string &InterfaceName, Module* Mod);
+
+ /** Return a pair saying how many other modules are currently using the
+ * interfaces provided by module m.
+ * @param m The module to count usage for
+ * @return A pair, where the first value is the number of uses of the interface,
+ * and the second value is the interface name being used.
+ */
+ std::pair<int,std::string> GetInterfaceInstanceCount(Module* m);
+
+ /** Mark your module as using an interface.
+ * If you mark your module as using an interface, then that interface
+ * module may not unload until your module has unloaded first.
+ * This can be used to prevent crashes by ensuring code you depend on
+ * is always in memory while your module is active.
+ * @param InterfaceName The interface to use
+ */
+ void UseInterface(const std::string &InterfaceName);
+
+ /** Mark your module as finished with an interface.
+ * If you used UseInterface() above, you should use this method when
+ * your module is finished with the interface (usually in its destructor)
+ * to allow the modules which implement the given interface to be unloaded.
+ * @param InterfaceName The interface you are finished with using.
+ */
+ void DoneWithInterface(const std::string &InterfaceName);
+
/** Unpublish a 'feature'.
* When your module exits, it must call this method for every feature it
* is providing so that the feature table is cleaned up.
*/
bool UnpublishFeature(const std::string &FeatureName);
+ /** Unpublish your module from an interface
+ * When your module exits, it must call this method for every interface
+ * it is part of so that the interfaces table is cleaned up. Only when
+ * the last item is deleted from an interface does the interface get
+ * removed.
+ * @param InterfaceName the interface to be removed from
+ * @param Mod The module to remove from the interface list
+ */
+ bool UnpublishInterface(const std::string &InterfaceName, Module* Mod);
+
/** Find a 'feature'.
* There are two ways for a module to find another module it depends on.
* Either by name, using InspIRCd::FindModule, or by feature, using the
*/
Module* FindFeature(const std::string &FeatureName);
+ /** Find an 'interface'.
+ * An interface is a list of modules which all implement the same API.
+ * @param InterfaceName The Interface you wish to obtain the module
+ * list of.
+ * @return A pointer to a deque of Module*, or NULL if the interface
+ * does not exist.
+ */
+ modulelist* FindInterface(const std::string &InterfaceName);
+
/** Given a pointer to a Module, return its filename
* @param m The module pointer to identify
* @return The module name or an empty string
* against possible hashed equivalents in the input string.
* @param data The data from the config file
* @param input The data input by the oper
+ * @param tagnum the tag number of the oper's tag in the config file
* @return 0 if the strings match, 1 or -1 if they do not
*/
- int OperPassCompare(const char* data,const char* input);
+ int OperPassCompare(const char* data,const char* input, int tagnum);
/** Check if a given server is a uline.
* An empty string returns true, this is by design.
void SendWhoisLine(userrec* user, userrec* dest, int numeric, const char* format, ...);
+ /** Restart the server.
+ * This function will not return. If an error occurs,
+ * it will throw an instance of CoreException.
+ * @param reason The restart reason to show to all clients
+ * @throw CoreException An instance of CoreException indicating the error from execv().
+ */
+ void Restart(const std::string &reason);
+
/** Begin execution of the server.
* NOTE: this function NEVER returns. Internally,
* after performing some initialisation routines,