* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * InspIRCd: (C) 2002-2007 InspIRCd Development Team
+ * InspIRCd: (C) 2002-2008 InspIRCd Development Team
* See: http://www.inspircd.org/wiki/index.php/Credits
*
* This program is free but copyrighted software; see
#include <time.h>
#include <string>
#include <sstream>
+#include <list>
#include "inspircd_config.h"
#include "uid.h"
#include "users.h"
+#include "usermanager.h"
#include "channels.h"
#include "socket.h"
#include "mode.h"
*/
#define ETIREDHAMSTERS EAGAIN
-/** Delete a pointer, and NULL its value
- */
-template<typename T> inline void DELETE(T* x)
-{
- delete x;
- x = NULL;
-}
-
/** Template function to convert any input type to std::string
*/
template<typename T> inline std::string ConvNumeric(const T &in)
++out;
quotient /= 10;
}
- if ( in < 0)
+ if (in < 0)
*out++ = '-';
*out = 0;
std::reverse(res,out);
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)
/** 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(ProcessUserHandler, void, User*);
DEFINE_HANDLER1(IsNickHandler, bool, const char*);
DEFINE_HANDLER1(IsIdentHandler, bool, const char*);
-DEFINE_HANDLER1(FindDescriptorHandler, userrec*, int);
-DEFINE_HANDLER1(FloodQuitUserHandler, void, userrec*);
+DEFINE_HANDLER1(FindDescriptorHandler, User*, int);
+DEFINE_HANDLER1(FloodQuitUserHandler, void, User*);
/* Forward declaration - required */
class XLineManager;
+class BanCacheManager;
/** The main class of the irc server.
* This class contains instances of all the other classes
*/
bool DaemonSeed();
- /** Iterate the list of InspSocket objects, removing ones which have timed out
+ /** Iterate the list of BufferedSocket objects, removing ones which have timed out
* @param TIME the current time
*/
void DoSocketTimeouts(time_t TIME);
void InitialiseUID();
/** Perform background user events such as PING checks
- * @param TIME the current time
*/
- void DoBackgroundUserStuff(time_t TIME);
+ void DoBackgroundUserStuff();
/** Returns true when all modules have done pre-registration checks on a user
* @param user The user to verify
* @return True if all modules have finished checking this user
*/
- bool AllModulesReportReady(userrec* user);
+ bool AllModulesReportReady(User* user);
/** Logfile pathname specified on the commandline, or empty string
*/
FindDescriptorHandler HandleFindDescriptor;
FloodQuitUserHandler HandleFloodQuitUser;
- /** InspSocket classes pending deletion after being closed.
+ /** BufferedSocket classes pending deletion after being closed.
* We don't delete these immediately as this may cause a segmentation fault.
*/
- std::map<InspSocket*,InspSocket*> SocketCull;
+ std::map<BufferedSocket*,BufferedSocket*> SocketCull;
/** Globally accessible fake user record. This is used to force mode changes etc across s2s, etc.. bit ugly, but.. better than how this was done in 1.1
* Reason for it:
* kludge alert!
- * SendMode expects a userrec* to send the numeric replies
+ * SendMode expects a User* to send the numeric replies
* back to, so we create it a fake user that isnt in the user
* hash and set its descriptor to FD_MAGIC_NUMBER so the data
* falls into the abyss :p
*/
- userrec *FakeClient;
+ User *FakeClient;
/** Returns the next available UID for this server.
*/
* @param nick The nickname to find
* @return A pointer to the user, or NULL if the user does not exist
*/
- userrec *FindUUID(const std::string &);
+ User *FindUUID(const std::string &);
/** Find a user in the UUID hash
* @param nick The nickname to find
* @return A pointer to the user, or NULL if the user does not exist
*/
- userrec *FindUUID(const char *);
+ User *FindUUID(const char *);
/** Build the ISUPPORT string by triggering all modules On005Numeric events
*/
*/
ModuleManager* Modules;
+ /** BanCacheManager is used to speed up checking of restrictions on connection
+ * to the IRCd.
+ */
+ BanCacheManager *BanCache;
+
/** Stats class, holds miscellaneous stats counters
*/
serverstats* stats;
user_hash* clientlist;
/** Client list stored by UUID. Contains all clients, and is updated
- * automatically by the constructor and destructor of userrec.
+ * automatically by the constructor and destructor of User.
*/
user_hash* uuidlist;
/** Local client list, a vector containing only local clients
*/
- std::vector<userrec*> local_users;
+ std::vector<User*> local_users;
/** Oper list, a vector containing all local and remote opered users
*/
- 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;
+ std::list<User*> all_opers;
/** DNS class, provides resolver facilities to the core and modules
*/
DNS* Res;
- /** Timer manager class, triggers InspTimer timer events
+ /** Timer manager class, triggers Timer timer events
*/
TimerManager* Timers;
*/
XLineManager* XLines;
- /** The time we next call our ping timeout and reg timeout checks
+ /** User manager. Various methods and data associated with users.
*/
- time_t next_call;
+ UserManager *Users;
/** Set to the current signal recieved
*/
* @return The old time delta
*/
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
*/
* @return There is no actual return value, however upon exit, the user 'cu' may have been
* marked for deletion in the global CullList.
*/
- caller1<void, userrec*> ProcessUser;
+ caller1<void, User*> ProcessUser;
/** Bind all ports specified in the configuration file.
* @param bail True if the function should bail back to the shell on failure
void AddServerName(const std::string &servername);
/** Finds a cached char* pointer of a server name,
- * This is used to optimize userrec by storing only the pointer to the name
+ * This is used to optimize User by storing only the pointer to the name
* @param The servername to find
* @return A pointer to this name, gauranteed to never become invalid
*/
*/
std::string GetServerDescription(const char* servername);
- /** Write text to all opers connected to this server
- * @param text The text format string
- * @param ... Format args
- */
- void WriteOpers(const char* text, ...);
-
- /** Write text to all opers connected to this server
- * @param text The text to send
- */
- void WriteOpers(const std::string &text);
-
/** Find a user in the nick hash.
* If the user cant be found in the nick hash check the uuid hash
* @param nick The nickname to find
* @return A pointer to the user, or NULL if the user does not exist
*/
- userrec* FindNick(const std::string &nick);
+ User* FindNick(const std::string &nick);
/** Find a user in the nick hash.
* If the user cant be found in the nick hash check the uuid hash
* @param nick The nickname to find
* @return A pointer to the user, or NULL if the user does not exist
*/
- userrec* FindNick(const char* nick);
+ User* FindNick(const char* nick);
/** Find a user in the nick hash ONLY
*/
- userrec* FindNickOnly(const char* nick);
+ User* FindNickOnly(const char* nick);
/** Find a user in the nick hash ONLY
*/
- userrec* FindNickOnly(const std::string &nick);
+ User* FindNickOnly(const std::string &nick);
/** Find a channel in the channels hash
* @param chan The channel to find
* @return A pointer to the channel, or NULL if the channel does not exist
*/
- chanrec* FindChan(const std::string &chan);
+ Channel* FindChan(const std::string &chan);
/** Find a channel in the channels hash
* @param chan The channel to find
* @return A pointer to the channel, or NULL if the channel does not exist
*/
- chanrec* FindChan(const char* chan);
+ Channel* FindChan(const char* chan);
/** Check for a 'die' tag in the config file, and abort if found
* @return Depending on the configuration, this function may never return
*/
bool IsChannel(const char *chname);
+ /** Return true if str looks like a server ID
+ * @param string to check against
+ */
+ bool IsSID(const std::string &str);
+
/** Rehash the local server
*/
void Rehash();
*/
static void QuickExit(int status);
- /** Return a count of users, unknown and known connections
- * @return The number of users
- */
- int UserCount();
-
- /** Return a count of fully registered connections only
- * @return The number of registered users
- */
- int RegisteredUserCount();
-
- /** Return a count of invisible (umode +i) users only
- * @return The number of invisible users
- */
- int InvisibleUserCount();
-
- /** Return a count of opered (umode +o) users only
- * @return The number of opers
- */
- int OperCount();
-
- /** Return a count of unregistered (before NICK/USER) users only
- * @return The number of unregistered (unknown) connections
- */
- int UnregisteredUserCount();
-
/** Return a count of channels on the network
* @return The number of channels
*/
long ChannelCount();
- /** Return a count of local users on this server only
- * @return The number of local users
- */
- long LocalUserCount();
-
/** Send an error notice to all local users, opered and unopered
* @param s The error string to send
*/
* @param socket The file descriptor of a user
* @return A pointer to the user if the user exists locally on this descriptor
*/
- caller1<userrec*, int> FindDescriptor;
-
- /** 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);
-
- /** 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);
-
- /** 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);
+ caller1<User*, int> FindDescriptor;
/** Add a dns Resolver class to this server's active set
* @param r The resolver to add
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
+ * @param f A Command command handler object to add
* @throw ModuleException Will throw ModuleExcption if the command already exists
*/
- void AddCommand(command_t *f);
+ void AddCommand(Command *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, User *user);
/** Match two strings using pattern matching.
* This operates identically to the global function match(),
* @param user The user to execute the command as
* @return True if the command handler was called successfully
*/
- CmdResult CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, userrec* user);
+ CmdResult CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, User* 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);
-
- /** Add a gline and apply it
- * @param duration How long the line should last
- * @param source Who set the line
- * @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);
-
- /** Add a qline and apply it
- * @param duration How long the line should last
- * @param source Who set the line
- * @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);
-
- /** Add a zline and apply it
- * @param duration How long the line should last
- * @param source Who set the line
- * @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);
-
- /** Add a kline and apply it
- * @param duration How long the line should last
- * @param source Who set the line
- * @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);
-
- /** Add an eline
- * @param duration How long the line should last
- * @param source Who set the line
- * @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);
-
- /** Delete a gline
- * @param hostmask The gline to delete
- * @return True if the item was removed
- */
- 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);
-
- /** Delete a zline
- * @param ipaddr The zline to delete
- * @return True if the item was removed
- */
- 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);
-
- /** Delete an eline
- * @param hostmask The kline to delete
- * @return True if the item was removed
- */
- bool DelELine(const std::string &hostmask);
+ bool IsValidModuleCommand(const std::string &commandname, int pcnt, User* user);
/** Return true if the given parameter is a valid nick!user\@host mask
* @param mask A nick!user\@host masak to match against
* @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);
+ Channel* 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(User* 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
* @param user A user to send error text to
* @return True if the nick matches too many users
*/
- bool NickMatchesEveryone(const std::string &nick, userrec* user);
+ bool NickMatchesEveryone(const std::string &nick, User* user);
/** Check if the given IP mask matches too many users, send errors to the given user
* @param ip An ipmask to match against
* @param user A user to send error text to
* @return True if the ip matches too many users
*/
- bool IPMatchesEveryone(const std::string &ip, userrec* user);
+ bool IPMatchesEveryone(const std::string &ip, User* user);
/** Check if the given hostmask matches too many users, send errors to the given user
* @param mask A hostmask to match against
* @param user A user to send error text to
* @return True if the host matches too many users
*/
- bool HostMatchesEveryone(const std::string &mask, userrec* user);
+ bool HostMatchesEveryone(const std::string &mask, User* user);
/** Calculate a duration in seconds from a string in the form 1y2w3d4h6m5s
* @param str A string containing a time in the form 1y2w3d4h6m5s
*/
InspIRCd(int argc, char** argv);
- /** Do one iteration of the mainloop
- * @param process_module_sockets True if module sockets are to be processed
- * this time around the event loop. The is the default.
- */
- void DoOneIteration(bool process_module_sockets = true);
-
/** Output a log message to the ircd.log file
* The text will only be output if the current loglevel
* is less than or equal to the level you provide
* @param numeric Numeric to send
* @param text Text of the numeric
*/
- void SendWhoisLine(userrec* user, userrec* dest, int numeric, const std::string &text);
+ void SendWhoisLine(User* user, User* 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 format Format string for the numeric
* @param ... Parameters for the format string
*/
- void SendWhoisLine(userrec* user, userrec* dest, int numeric, const char* format, ...);
+ void SendWhoisLine(User* user, User* 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
*/
- caller1<void, userrec*> FloodQuitUser;
+ caller1<void, User*> FloodQuitUser;
/** Restart the server.
* This function will not return. If an error occurs,
/** Begin execution of the server.
* NOTE: this function NEVER returns. Internally,
- * after performing some initialisation routines,
- * it will repeatedly call DoOneIteration in a loop.
+ * it will repeatedly loop.
* @return The return value for this function is undefined.
*/
int Run();
- /** Force all InspSockets to be removed which are due to
+ /** Force all BufferedSockets to be removed which are due to
* be culled.
*/
- void InspSocketCull();
+ void BufferedSocketCull();
char* GetReadBuffer()
{
projects / user / henk / code / inspircd.git / blobdiff