#include "socketengine.h"
#include "command_parse.h"
-/* Some misc defines */
+/** Returned by some functions to indicate failure,
+ * and the exit code of the program if it terminates.
+ */
#define ERROR -1
-#define MAXCOMMAND 32
-/* Crucial defines */
+/** Crucial defines
+ */
#define ETIREDGERBILS EAGAIN
/** Debug levels for use with InspIRCd::Log()
NONE = 50,
};
-/* This define is used in place of strcmp when we
+/**
+ * This define is used in place of strcmp when we
* want to check if a char* string contains only one
* letter. Pretty fast, its just two compares and an
* addition.
*/
#define IS_SINGLE(x,y) ( (*x == y) && (*(x+1) == 0) )
+/** Delete a pointer, and NULL its value
+ */
#define DELETE(x) {if (x) { delete x; x = NULL; }}
+/** Template function to convert any input type to std::string
+ */
template<typename T> inline std::string ConvToStr(const T &in)
{
std::stringstream tmp;
return tmp.str();
}
+/** This class contains various STATS counters
+ * It is used by the InspIRCd class, which internally
+ * has an instance of it.
+ */
class serverstats : public classbase
{
public:
+ /** Number of accepted connections
+ */
unsigned long statsAccept;
+ /** Number of failed accepts
+ */
unsigned long statsRefused;
+ /** Number of unknown commands seen
+ */
unsigned long statsUnknown;
+ /** Number of nickname collisions handled
+ */
unsigned long statsCollisions;
+ /** Number of DNS queries sent out
+ */
unsigned long statsDns;
+ /** Number of good DNS replies received
+ * NOTE: This may not tally to the number sent out,
+ * due to timeouts and other latency issues.
+ */
unsigned long statsDnsGood;
+ /** Number of bad (negative) DNS replies received
+ * NOTE: This may not tally to the number sent out,
+ * due to timeouts and other latency issues.
+ */
unsigned long statsDnsBad;
+ /** Number of inbound connections seen
+ */
unsigned long statsConnects;
+ /** Total bytes of data transmitted
+ */
double statsSent;
+ /** Total bytes of data received
+ */
double statsRecv;
+ /** Number of bound listening ports
+ */
unsigned long BoundPortCount;
+ /** 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)
{
- statsAccept = statsRefused = statsUnknown = 0;
- statsCollisions = statsDns = statsDnsGood = 0;
- statsDnsBad = statsConnects = 0;
- statsSent = statsRecv = 0.0;
- BoundPortCount = 0;
}
};
class XLineManager;
+/** The main singleton class of the irc server.
+ * This class contains instances of all the other classes
+ * in this software, with the exception of the base class,
+ * 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!)
+ */
class InspIRCd : public classbase
{
private:
*/
int BindPorts(bool bail);
+ /** Returns true if this server has the given port bound to the given address
+ */
bool HasPort(int port, char* addr);
+
+ /** Binds a socket on an already open file descriptor
+ */
bool BindSocket(int sockfd, insp_sockaddr client, insp_sockaddr server, int port, char* addr);
+ /** Adds a server name to the list of servers we've seen
+ */
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
+ */
const char* FindServerNamePtr(const std::string &servername);
+
+ /** Returns true if we've seen the given server name before
+ */
bool FindServerName(const std::string &servername);
+ /** Gets the GECOS (description) field of the given server.
+ * If the servername is not that of the local server, the name
+ * is passed to handling modules which will attempt to determine
+ * the GECOS that bleongs to the given servername.
+ */
std::string GetServerDescription(const char* servername);
+ /** Write text to all opers connected to this server
+ */
void WriteOpers(const char* text, ...);
+
+ /** Write text to all opers connected to this server
+ */
void WriteOpers(const std::string &text);
+ /** Find a nickname in the nick hash
+ */
userrec* FindNick(const std::string &nick);
+
+ /** Find a nickname in the nick hash
+ */
userrec* FindNick(const char* nick);
+ /** Find a channel in the channels hash
+ */
chanrec* FindChan(const std::string &chan);
+
+ /** Find a channel in the channels hash
+ */
chanrec* FindChan(const char* chan);
+ /** Called by the constructor to load all modules from the config file.
+ */
void LoadAllModules();
+
+ /** Check for a 'die' tag in the config file, and abort if found
+ */
void CheckDie();
+
+ /** Check we aren't running as root, and exit if we are
+ */
void CheckRoot();
+
+ /** Determine the right path for, and open, the logfile
+ */
void OpenLog(char** argv, int argc);
+ /** Convert a user to a pseudoclient, disconnecting the real user
+ */
bool UserToPseudo(userrec* user, const std::string &message);
+
+ /** Convert a pseudoclient to a real user, discarding the pseudoclient
+ */
bool PseudoToUser(userrec* alive, userrec* zombie, const std::string &message);
+ /** Send a server notice to all local users
+ */
void ServerNoticeAll(char* text, ...);
+
+ /** Send a server message (PRIVMSG) to all local users
+ */
void ServerPrivmsgAll(char* text, ...);
+
+ /** Send text to all users with a specific set of modes
+ */
void WriteMode(const char* modes, int flags, const char* text, ...);
+ /** Return true if a channel name is valid
+ */
bool IsChannel(const char *chname);
+ /** Rehash the local server
+ */
static void Rehash(int status);
+
+ /** Causes the server to exit immediately
+ */
static void Exit(int status);
+ /** Return a count of users, unknown and known connections
+ */
int UserCount();
+
+ /** Return a count of fully registered connections only
+ */
int RegisteredUserCount();
+
+ /** Return a count of invisible (umode +i) users only
+ */
int InvisibleUserCount();
+
+ /** Return a count of opered (umode +o) users only
+ */
int OperCount();
+
+ /** Return a count of unregistered (before NICK/USER) users only
+ */
int UnregisteredUserCount();
+
+ /** Return a count of channels on the network
+ */
long ChannelCount();
+
+ /** Return a count of local users on this server only
+ */
long LocalUserCount();
+ /** Send an error notice to all local users, opered and unopered
+ */
void SendError(const char *s);
/** For use with Module::Prioritize().
*/
Module* FindFeature(const std::string &FeatureName);
+ /** Given a pointer to a Module, return its filename
+ */
const std::string& GetModuleName(Module* m);
+ /** Return true if a nickname is valid
+ */
bool IsNick(const char* n);
+
+ /** Return true if an ident is valid
+ */
bool IsIdent(const char* n);
+ /** Find a username by their file descriptor.
+ * It is preferred to use this over directly accessing the fd_ref_table array.
+ */
userrec* FindDescriptor(int socket);
+ /** Add a new mode to this server's mode parser
+ */
bool AddMode(ModeHandler* mh, const unsigned char modechar);
+ /** Add a new mode watcher to this server's mode parser
+ */
bool AddModeWatcher(ModeWatcher* mw);
+ /** Delete a mode watcher from this server's mode parser
+ */
bool DelModeWatcher(ModeWatcher* mw);
+ /** Add a dns Resolver class to this server's active set
+ */
bool AddResolver(Resolver* r);
+ /** Add a command to this server's command parser
+ */
void AddCommand(command_t *f);
+ /** Send a modechange.
+ * The parameters provided are identical to that sent to the
+ * handler for class cmd_mode.
+ */
void SendMode(const char **parameters, int pcnt, userrec *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.
+ */
bool MatchText(const std::string &sliteral, const std::string &spattern);
+ /** Call the handler for a given command.
+ * @return True if the command handler was called successfully
+ */
bool 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
+ */
bool IsValidModuleCommand(const std::string &commandname, int pcnt, userrec* user);
+ /** Add a gline and apply it
+ */
void AddGLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
+ /** Add a qline and apply it
+ */
void AddQLine(long duration, const std::string &source, const std::string &reason, const std::string &nickname);
+ /** Add a zline and apply it
+ */
void AddZLine(long duration, const std::string &source, const std::string &reason, const std::string &ipaddr);
+ /** Add a kline and apply it
+ */
void AddKLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
+ /** Add an eline
+ */
void AddELine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
+ /** Delete a gline
+ */
bool DelGLine(const std::string &hostmask);
+ /** Delete a qline
+ */
bool DelQLine(const std::string &nickname);
+ /** Delete a zline
+ */
bool DelZLine(const std::string &ipaddr);
+ /** Delete a kline
+ */
bool DelKLine(const std::string &hostmask);
+ /** Delete an eline
+ */
bool DelELine(const std::string &hostmask);
+ /** Return true if the given parameter is a valid nick!user@host mask
+ */
bool IsValidMask(const std::string &mask);
+ /** Add an InspSocket class to the active set
+ */
void AddSocket(InspSocket* sock);
+ /** Remove an InspSocket class from the active set at next time around the loop
+ */
void RemoveSocket(InspSocket* sock);
+ /** Delete a socket immediately without waiting for the next iteration of the mainloop
+ */
void DelSocket(InspSocket* sock);
+ /** Rehash the local server
+ */
void RehashServer();
+ /** Return the channel whos index number matches that provided
+ */
chanrec* GetChannelIndex(long index);
+ /** Dump text to a user target, splitting it appropriately to fit
+ */
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
+ */
bool NickMatchesEveryone(const std::string &nick, userrec* user);
+
+ /** Check if the given IP mask matches too many users, send errors to the given user
+ */
bool IPMatchesEveryone(const std::string &ip, userrec* user);
+
+ /** Check if the given hostmask matches too many users, send errors to the given user
+ */
bool HostMatchesEveryone(const std::string &mask, userrec* user);
+
+ /** Calculate a duration in seconds from a string in the form 1y2w3d4h6m5s
+ */
long Duration(const char* 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
+ * against possible hashed equivalents in the input string.
+ */
int OperPassCompare(const char* data,const char* input);
+
+ /** Check if a given server is a uline.
+ * An empty string returns true, this is by design.
+ */
bool ULine(const char* server);
+ /** Returns the subversion revision ID of this ircd
+ */
std::string GetRevision();
+
+ /** Returns the full version string of this ircd
+ */
std::string GetVersionString();
+
+ /** Attempt to write the process id to a given file
+ */
void WritePID(const std::string &filename);
+
+ /** Returns text describing the last module error
+ */
char* ModuleError();
+
+ /** Load a given module file
+ */
bool LoadModule(const char* filename);
+
+ /** Unload a given module file
+ */
bool UnloadModule(const char* filename);
+
+ /** This constructor initialises all the subsystems and reads the config file.
+ */
InspIRCd(int argc, char** argv);
+
+ /** Do one iteration of the mainloop
+ */
void DoOneIteration(bool process_module_sockets);
+
+ /** Output a log message to the ircd.log file
+ */
void Log(int level, const char* text, ...);
+
+ /** Output a log message to the ircd.log file
+ */
void Log(int level, const std::string &text);
+
+ /** Begin execution of the server.
+ * NOTE: this function NEVER returns. Internally,
+ * after performing some initialisation routines,
+ * it will repeatedly call DoOneIteration in a loop.
+ */
int Run();
};
#endif
+
projects / user / henk / code / inspircd.git / blobdiff