* 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.
*
* ---------------------------------------------------
*/
#ifndef __INSPIRCD_H__
#define __INSPIRCD_H__
+#ifndef WIN32
+#define DllExport
+#define CoreExport
+#define printf_c printf
+#else
+#include "inspircd_win32wrapper.h"
+/** Windows defines these already */
+#undef DELETE
+#undef ERROR
+#endif
+
#include <time.h>
#include <string>
#include <sstream>
#include "command_parse.h"
#include "snomasks.h"
#include "cull_list.h"
+#include "filelogger.h"
+
+/**
+ * Used to define the maximum number of parameters a command may have.
+ */
+#define MAXPARAMETERS 127
/** Returned by some functions to indicate failure.
*/
*/
#define ETIREDHAMSTERS EAGAIN
-/** Debug levels for use with InspIRCd::Log()
- */
-enum DebugLevel
-{
- DEBUG = 10,
- VERBOSE = 20,
- DEFAULT = 30,
- SPARSE = 40,
- NONE = 50,
-};
-
/**
* This define is used in place of strcmp when we
* want to check if a char* string contains only one
x = NULL;
}
-/** Template functions to convert any input type to std::string
+/** Template function to convert any input type to std::string
*/
template<typename T> inline std::string ConvNumeric(const T &in)
{
return res;
}
+/** Template function to convert any input type to std::string
+ */
inline std::string ConvToStr(const int in)
{
return ConvNumeric(in);
}
+/** Template function to convert any input type to std::string
+ */
inline std::string ConvToStr(const long in)
{
return ConvNumeric(in);
}
+/** Template function to convert any input type to std::string
+ */
inline std::string ConvToStr(const unsigned long in)
{
return ConvNumeric(in);
}
+/** Template function to convert any input type to std::string
+ */
inline std::string ConvToStr(const char* in)
{
return in;
}
+/** Template function to convert any input type to std::string
+ */
inline std::string ConvToStr(const bool in)
{
return (in ? "1" : "0");
}
+/** Template function to convert any input type to std::string
+ */
inline std::string ConvToStr(char in)
{
return std::string(in,1);
}
+/** Template function to convert any input type to std::string
+ */
template <class T> inline std::string ConvToStr(const T &in)
{
std::stringstream tmp;
return tmp.str();
}
+/** Template function to convert any input type to any other type
+ * (usually an integer or numeric type)
+ */
template<typename T> inline long ConvToInt(const T &in)
{
std::stringstream tmp;
/** Template function to convert integer to char, storing result in *res and
* also returning the pointer to res. Based on Stuart Lowe's C/C++ Pages.
+ * @param T input value
+ * @param V result value
+ * @param R base to convert to
*/
template<typename T, typename V, typename R> inline char* itoa(const T &in, V *res, R base)
{
/** Total bytes of data received
*/
double statsRecv;
- /** Number of bound listening ports
- */
- 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()
: statsAccept(0), statsRefused(0), statsUnknown(0), statsCollisions(0), statsDns(0),
- statsDnsGood(0), statsDnsBad(0), statsConnects(0), statsSent(0.0), statsRecv(0.0),
- BoundPortCount(0)
+ statsDnsGood(0), statsDnsBad(0), statsConnects(0), statsSent(0.0), statsRecv(0.0)
{
}
};
-class InspIRCd;
-
-/** This class implements a nonblocking log-writer.
- * Most people writing an ircd give little thought to their disk
- * i/o. On a congested system, disk writes can block for long
- * periods of time (e.g. if the system is busy and/or swapping
- * a lot). If we just use a blocking fprintf() call, this could
- * block for undesirable amounts of time (half of a second through
- * to whole seconds). We DO NOT want this, so we make our logfile
- * nonblocking and hook it into the SocketEngine.
- * NB: If the operating system does not support nonblocking file
- * I/O (linux seems to, as does freebsd) this will default to
- * blocking behaviour.
- */
-class FileLogger : public EventHandler
-{
- protected:
- /** The creator/owner of this object
- */
- InspIRCd* ServerInstance;
- /** The log file (fd is inside this somewhere,
- * we get it out with fileno())
- */
- FILE* log;
- /** Buffer of pending log lines to be written
- */
- std::string buffer;
- /** Number of write operations that have occured
- */
- int writeops;
- public:
- /** The constructor takes an already opened logfile.
- */
- FileLogger(InspIRCd* Instance, FILE* logfile);
- /** This returns false, logfiles are writeable.
- */
- virtual bool Readable();
- /** Handle pending write events.
- * This will flush any waiting data to disk.
- * If any data remains after the fprintf call,
- * another write event is scheduled to write
- * the rest of the data when possible.
- */
- virtual void HandleEvent(EventType et, int errornum = 0);
- /** Write one or more preformatted log lines.
- * If the data cannot be written immediately,
- * this class will insert itself into the
- * SocketEngine, and register a write event,
- * and when the write event occurs it will
- * attempt again to write the data.
- */
- void WriteLogLine(const std::string &line);
- /** Close the log file and cancel any events.
- */
- virtual void Close();
- /** Close the log file and cancel any events.
- * (indirectly call Close()
- */
- virtual ~FileLogger();
-};
-
/** 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;
+/* Forward declaration - required */
class XLineManager;
/** The main class of the irc server.
* program in terms of ram usage (basically, you could create
* an obese forkbomb built from recursively spawning irc servers!)
*/
-class InspIRCd : public classbase
+class CoreExport InspIRCd : public classbase
{
private:
/** Holds a string describing the last module error to occur
*/
void MoveTo(std::string modulename,int slot);
- /** Display the startup banner
- */
- void Start();
-
/** Set up the signal handlers
*/
void SetSignals();
*/
char ReadBuffer[65535];
- /** Number of seconds in a minute
- */
- const long duration_m;
-
- /** Number of seconds in an hour
- */
- const long duration_h;
-
- /** Number of seconds in a day
- */
- const long duration_d;
-
- /** Number of seconds in a week
- */
- const long duration_w;
-
- /** Number of seconds in a year
- */
- const long duration_y;
-
/** Used when connecting clients
*/
insp_sockaddr client, server;
public:
+ /** InspSocket classes pending deletion after being closed.
+ * We don't delete these immediately as this may cause a segmentation fault.
+ */
+ std::map<InspSocket*,InspSocket*> SocketCull;
+
/** Build the ISUPPORT string by triggering all modules On005Numeric events
*/
void BuildISupport();
*/
int unregistered_count;
- /** List of server names we've seen.
+ /** List of server names we've seen.
*/
servernamelist servernames;
*/
time_t startup_time;
+ /** Config file pathname specified on the commandline or via ./configure
+ */
+ char ConfigFileName[MAXBUF];
+
/** Mode handler, handles mode setting and removal
*/
ModeParser* Modes;
*/
std::vector<userrec*> all_opers;
+ /** Map of local ip addresses for clone counting
+ */
clonemap local_clones;
+ /** Map of global ip addresses for clone counting
+ */
clonemap global_clones;
/** DNS class, provides resolver facilities to the core and modules
*/
int SetTimeDelta(int delta);
+ /** Add a user to the local clone map
+ * @param user The user to add
+ */
void AddLocalClone(userrec* user);
+ /** Add a user to the global clone map
+ * @param user The user to add
+ */
void AddGlobalClone(userrec* user);
/** Number of users with a certain mode set on them
/** 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
+ * @return There is no actual return value, however upon exit, the user 'cu' may have been
+ * marked for deletion in the global CullList.
*/
void ProcessUser(userrec* cu);
*/
int BindPorts(bool bail, int &found_ports, FailedPortList &failed_ports);
- /** Returns true if this server has the given port bound to the given address
- * @param port The port number
- * @param addr The address
- * @return True if we have a port listening on this address
- */
- bool HasPort(int port, char* addr);
-
/** Binds a socket on an already open file descriptor
* @param sockfd A valid file descriptor of an open socket
* @param port The port number to bind to
*/
void OpenLog(char** argv, int argc);
- void CloseLog();
-
- /** Convert a user to a pseudoclient, disconnecting the real user
- * @param user The user to convert
- * @param message The quit message to display when exiting the user
- * @return True if the operation succeeded
+ /** Close the currently open log file
*/
- bool UserToPseudo(userrec* user, const std::string &message);
-
- /** Convert a pseudoclient to a real user, discarding the pseudoclient
- * @param alive A live client
- * @param zombie A pseudoclient
- * @param message The message to display when quitting the pseudoclient
- * @return True if the operation succeeded
- */
- bool PseudoToUser(userrec* alive, userrec* zombie, const std::string &message);
+ void CloseLog();
/** Send a server notice to all local users
* @param text The text format string to send
*/
static void Rehash(int status);
- /** Causes the server to exit immediately
+ /** Causes the server to exit after unloading modules and
+ * closing all open file descriptors.
+ *
* @param The exit code to give to the operating system
* (See the ExitStatus enum for valid values)
*/
static void Exit(int status);
+ /** Causes the server to exit immediately with exit code 0.
+ * The status code is required for signal handlers, and ignored.
+ */
+ static void QuickExit(int status);
+
/** Return a count of users, unknown and known connections
* @return The number of users
*/
* @param socket The file descriptor of a user
* @return A pointer to the user if the user exists locally on this descriptor
*/
- userrec* FindDescriptor(int socket);
+ userrec* FindDescriptor(int socket);
/** Add a new mode to this server's mode parser
* @param mh The modehandler to add
* @param modechar The mode character this modehandler handles
* @return True if the mode handler was added
*/
- bool AddMode(ModeHandler* mh, const unsigned char modechar);
+ bool AddMode(ModeHandler* mh, const unsigned char modechar);
/** Add a new mode watcher to this server's mode parser
* @param mw The modewatcher to add
* @return True if the modewatcher was added
*/
- bool AddModeWatcher(ModeWatcher* mw);
+ bool AddModeWatcher(ModeWatcher* mw);
/** Delete a mode watcher from this server's mode parser
* @param mw The modewatcher to delete
* @return True if the modewatcher was deleted
*/
- bool DelModeWatcher(ModeWatcher* mw);
+ bool DelModeWatcher(ModeWatcher* mw);
/** Add a dns Resolver class to this server's active set
* @param r The resolver to add
* the resolver class you pass it after this call, as depending upon
* the request given, the object may be deleted!
*/
- bool AddResolver(Resolver* r, bool cached);
+ bool AddResolver(Resolver* r, bool cached);
/** Add a command to this server's command parser
* @param f A command_t command handler object to add
* @throw ModuleException Will throw ModuleExcption if the command already exists
*/
- void AddCommand(command_t *f);
+ void AddCommand(command_t *f);
/** Send a modechange.
* The parameters provided are identical to that sent to the
* @param pcnt The number of items you have given in the first parameter
* @param user The user to send error messages to
*/
- void SendMode(const char **parameters, int pcnt, userrec *user);
+ void SendMode(const char **parameters, int pcnt, userrec *user);
/** Match two strings using pattern matching.
* This operates identically to the global function match(),
* @param sliteral The literal string to match against
* @param spattern The pattern to match against. CIDR and globs are supported.
*/
- bool MatchText(const std::string &sliteral, const std::string &spattern);
+ bool MatchText(const std::string &sliteral, const std::string &spattern);
/** Call the handler for a given command.
* @param commandname The command whos handler you wish to call
* @param user The user to execute the command as
* @return True if the command handler was called successfully
*/
- bool CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, userrec* user);
+ CmdResult CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, userrec* user);
/** Return true if the command is a module-implemented command and the given parameters are valid for it
* @param parameters The mode parameters
* @param user The user to test-execute the command as
* @return True if the command handler is a module command, and there are enough parameters and the user has permission to the command
*/
- bool IsValidModuleCommand(const std::string &commandname, int pcnt, userrec* user);
+ bool IsValidModuleCommand(const std::string &commandname, int pcnt, userrec* user);
/** Add a gline and apply it
* @param duration How long the line should last
* @param reason The reason for the line
* @param hostmask The hostmask to set the line against
*/
- void AddGLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
+ void AddGLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
/** Add a qline and apply it
* @param duration How long the line should last
* @param reason The reason for the line
* @param nickname The nickmask to set the line against
*/
- void AddQLine(long duration, const std::string &source, const std::string &reason, const std::string &nickname);
+ void AddQLine(long duration, const std::string &source, const std::string &reason, const std::string &nickname);
/** Add a zline and apply it
* @param duration How long the line should last
* @param reason The reason for the line
* @param ipaddr The ip-mask to set the line against
*/
- void AddZLine(long duration, const std::string &source, const std::string &reason, const std::string &ipaddr);
+ void AddZLine(long duration, const std::string &source, const std::string &reason, const std::string &ipaddr);
/** Add a kline and apply it
* @param duration How long the line should last
* @param reason The reason for the line
* @param hostmask The hostmask to set the line against
*/
- void AddKLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
+ void AddKLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
/** Add an eline
* @param duration How long the line should last
* @param reason The reason for the line
* @param hostmask The hostmask to set the line against
*/
- void AddELine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
+ void AddELine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
/** Delete a gline
* @param hostmask The gline to delete
* @return True if the item was removed
*/
- bool DelGLine(const std::string &hostmask);
+ bool DelGLine(const std::string &hostmask);
/** Delete a qline
* @param nickname The qline to delete
* @return True if the item was removed
*/
- bool DelQLine(const std::string &nickname);
+ bool DelQLine(const std::string &nickname);
/** Delete a zline
* @param ipaddr The zline to delete
* @return True if the item was removed
*/
- bool DelZLine(const std::string &ipaddr);
+ bool DelZLine(const std::string &ipaddr);
/** Delete a kline
* @param hostmask The kline to delete
* @return True if the item was removed
*/
- bool DelKLine(const std::string &hostmask);
+ bool DelKLine(const std::string &hostmask);
/** Delete an eline
* @param hostmask The kline to delete
* @return True if the item was removed
*/
- bool DelELine(const std::string &hostmask);
+ bool DelELine(const std::string &hostmask);
/** Return true if the given parameter is a valid nick!user\@host mask
* @param mask A nick!user\@host masak to match against
* @return True i the mask is valid
*/
- bool IsValidMask(const std::string &mask);
+ bool IsValidMask(const std::string &mask);
/** Rehash the local server
*/
- void RehashServer();
+ void RehashServer();
/** Return the channel whos index number matches that provided
* @param The index number of the channel to fetch
* @return A channel record, or NUll if index < 0 or index >= InspIRCd::ChannelCount()
*/
- chanrec* GetChannelIndex(long index);
+ chanrec* GetChannelIndex(long index);
/** Dump text to a user target, splitting it appropriately to fit
* @param User the user to dump the text to
* @param LinePrefix text to prefix each complete line with
* @param TextStream the text to send to the user
*/
- void DumpText(userrec* User, const std::string &LinePrefix, stringstream &TextStream);
+ void DumpText(userrec* User, const std::string &LinePrefix, stringstream &TextStream);
/** Check if the given nickmask matches too many users, send errors to the given user
* @param nick A nickmask to match against
* (one year, two weeks, three days, four hours, six minutes and five seconds)
* @return The total number of seconds
*/
- long Duration(const char* str);
+ long Duration(const std::string &str);
/** Attempt to compare an oper password to a string from the config file.
* This will be passed to handling modules which will compare the data
*/
bool ULine(const char* server);
+ /** Returns true if the uline is 'silent' (doesnt generate
+ * remote connect notices etc).
+ */
+ bool SilentULine(const char* server);
+
/** Returns the subversion revision ID of this ircd
* @return The revision ID or an empty string
*/
*/
void Log(int level, const std::string &text);
+ /** Send a line of WHOIS data to a user.
+ * @param user user to send the line to
+ * @param dest user being WHOISed
+ * @param numeric Numeric to send
+ * @param text Text of the numeric
+ */
void SendWhoisLine(userrec* user, userrec* dest, int numeric, const std::string &text);
+ /** Send a line of WHOIS data to a user.
+ * @param user user to send the line to
+ * @param dest user being WHOISed
+ * @param numeric Numeric to send
+ * @param format Format string for the numeric
+ * @param ... Parameters for the format string
+ */
void SendWhoisLine(userrec* user, userrec* dest, int numeric, const char* format, ...);
+ /** Quit a user for excess flood, and if they are not
+ * fully registered yet, temporarily zline their IP.
+ * @param current user to quit
+ */
+ void FloodQuitUser(userrec* current);
+
/** Restart the server.
* This function will not return. If an error occurs,
* it will throw an instance of CoreException.
*/
void ResetMaxBans();
+ /** Return a time_t as a human-readable string.
+ */
+ std::string TimeString(time_t curtime);
+
/** Begin execution of the server.
* NOTE: this function NEVER returns. Internally,
* after performing some initialisation routines,
* @return The return value for this function is undefined.
*/
int Run();
+
+ /** Force all InspSockets to be removed which are due to
+ * be culled.
+ */
+ void InspSocketCull();
};
#endif
projects / user / henk / code / inspircd.git / blobdiff