#define printf_c printf
#else
#include "inspircd_win32wrapper.h"
+/** Windows defines these already */
#undef DELETE
#undef ERROR
#endif
#include "command_parse.h"
#include "snomasks.h"
#include "cull_list.h"
+#include "filelogger.h"
+#include "caller.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)
{
}
};
-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 CoreExport 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;
+class InspIRCd;
+
+DEFINE_HANDLER1(ProcessUserHandler, void, userrec*);
+DEFINE_HANDLER1(IsNickHandler, bool, const char*);
+DEFINE_HANDLER1(IsIdentHandler, bool, const char*);
+DEFINE_HANDLER1(FindDescriptorHandler, userrec*, int);
+DEFINE_HANDLER1(FloodQuitUserHandler, void, userrec*);
+
+/* Forward declaration - required */
class XLineManager;
/** The main class of the irc server.
*/
void MoveTo(std::string modulename,int slot);
- /** Display the startup banner
- */
- void Start();
-
/** Set up the signal handlers
*/
void SetSignals();
*/
int time_delta;
+#ifdef WIN32
+ IPC* WindowsIPC;
+#endif
+
public:
+ /** Global cull list, will be processed on next iteration
+ */
+ CullList GlobalCulls;
+
+
+ /**** Functors ****/
+
+ ProcessUserHandler HandleProcessUser;
+ IsNickHandler HandleIsNick;
+ IsIdentHandler HandleIsIdent;
+ FindDescriptorHandler HandleFindDescriptor;
+ FloodQuitUserHandler HandleFloodQuitUser;
+
+ /** 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
*/
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
*/
time_t next_call;
- /** Global cull list, will be processed on next iteration
+ /** Set to the current signal recieved
*/
- CullList GlobalCulls;
+ int s_signal;
/** Get the current time
* Because this only calls time() once every time around the mainloop,
*/
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);
+ caller1<void, userrec*> ProcessUser;
/** Get the total number of currently loaded modules
* @return The number of loaded modules
*/
void OpenLog(char** argv, int argc);
+ /** Close the currently open log file
+ */
void CloseLog();
/** Send a server notice to all local users
bool IsChannel(const char *chname);
/** Rehash the local server
- * @param status This value is unused, and required for signal handler functions
*/
- static void Rehash(int status);
+ void Rehash();
+
+ /** Handles incoming signals after being set
+ * @param signal the signal recieved
+ */
+ void SignalHandler(int signal);
+
+ /** Sets the signal recieved
+ * @param signal the signal recieved
+ */
+ static void SetSignal(int signal);
/** 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);
+ void Exit(int status);
/** Causes the server to exit immediately with exit code 0.
* The status code is required for signal handlers, and ignored.
* @param n A nickname to verify
* @return True if the nick is valid
*/
- bool IsNick(const char* n);
+ caller1<bool, const char*> IsNick;
/** Return true if an ident is valid
* @param An ident to verify
* @return True if the ident is valid
*/
- bool IsIdent(const char* n);
+ caller1<bool, const char*> IsIdent;
/** Find a username by their file descriptor.
* It is preferred to use this over directly accessing the fd_ref_table array.
* @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);
+ caller1<userrec*, int> FindDescriptor;
/** Add a new mode to this server's mode parser
* @param mh The modehandler to add
*/
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);
+ caller1<void, userrec*> FloodQuitUser;
/** Restart the server.
* This function will not return. If an error occurs,
* @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();
+
+ char* GetReadBuffer()
+ {
+ return this->ReadBuffer;
+ }
};
#endif
projects / user / henk / code / inspircd.git / blobdiff