#define CMD_LOCALONLY CMD_FAILURE
-/** A structure that defines a command
+/** A structure that defines a command. Every command available
+ * in InspIRCd must be defined as derived from command_t.
*/
class command_t : public Extensible
{
protected:
+ /** Owner/Creator object
+ */
InspIRCd* ServerInstance;
public:
/** Command name
*/
std::string syntax;
+ /** Create a new command.
+ * @param Instance Pointer to creator class
+ * @param cmd Command name. This must be UPPER CASE.
+ * @param flags User modes required to execute the command.
+ * For oper only commands, set this to 'o', otherwise use 0.
+ * @param minpara Minimum parameters required for the command.
+ * @param before_reg If this is set to true, the command will
+ * be allowed before the user is 'registered' (has sent USER,
+ * NICK, optionally PASS, and been resolved).
+ */
command_t(InspIRCd* Instance, const std::string &cmd, char flags, int minpara, int before_reg = false) : ServerInstance(Instance), command(cmd), flags_needed(flags), min_params(minpara), disabled(false), works_before_reg(before_reg)
{
use_count = total_bytes = 0;
syntax = "";
}
+ /** Handle the command from a user.
+ * @param parameters The parameters for the command.
+ * @param pcnt The number of parameters available in 'parameters'
+ * @param user The user who issued the command.
+ * @return Return CMD_SUCCESS on success, or CMD_FAILURE on failure.
+ * If the command succeeds but should remain local to this server,
+ * return CMD_LOCALONLY.
+ */
virtual CmdResult Handle(const char** parameters, int pcnt, userrec* user) = 0;
+ /** Handle an internal request from another command, the core, or a module
+ * @param Command ID
+ * @param Zero or more parameters, whos form is specified by the command ID.
+ * @return Return CMD_SUCCESS on success, or CMD_FAILURE on failure.
+ * If the command succeeds but should remain local to this server,
+ * return CMD_LOCALONLY.
+ */
virtual CmdResult HandleInternal(const unsigned int id, const std::deque<classbase*> ¶ms)
{
return CMD_INVALID;
}
+ /** Handle the command from a server.
+ * Not currently used in this version of InspIRCd.
+ * @param parameters The parameters given
+ * @param pcnt The number of parameters available
+ * @param servername The server name which issued the command
+ * @return Return CMD_SUCCESS on success, or CMD_FAILURE on failure.
+ * If the command succeeds but should remain local to this server,
+ * return CMD_LOCALONLY.
+ */
virtual CmdResult HandleServer(const char** parameters, int pcnt, const std::string &servername)
{
return CMD_INVALID;
}
+ /** Disable or enable this command.
+ * @param setting True to disable the command.
+ */
void Disable(bool setting)
{
disabled = setting;
}
+ /** Obtain this command's disable state.
+ * @return true if the command is currently disabled
+ * (disabled commands can be used only by operators)
+ */
bool IsDisabled()
{
return disabled;
}
+ /** @return true if the command works before registration.
+ */
bool WorksBeforeReg()
{
return works_before_reg;
}
+ /** Standard constructor gubbins
+ */
virtual ~command_t() {}
};
+/** A hash of commands used by the core
+ */
typedef nspace::hash_map<std::string,command_t*> command_table;
#endif
+
class DNSResult : public classbase
{
public:
+ /** Result ID
+ */
int id;
+ /** Result body, a hostname or IP address
+ */
std::string result;
+ /** Time-to-live value of the result
+ */
unsigned long ttl;
+ /** The original request, a hostname or IP address
+ */
std::string original;
+ /** Build a DNS result.
+ * @param i The request ID
+ * @param res The request result, a hostname or IP
+ * @param timetolive The request time-to-live
+ * @param orig The original request, a hostname or IP
+ */
DNSResult(int i, const std::string &res, unsigned long timetolive, const std::string &orig) : id(i), result(res), ttl(timetolive), original(orig) { }
};
*/
typedef std::pair<unsigned char*, std::string> DNSInfo;
-/** Cached item
+/** Cached item stored in the query cache.
*/
class CachedQuery
{
public:
+ /** The cached result data, an IP or hostname
+ */
std::string data;
+ /** The time when the item is due to expire
+ */
time_t expires;
+ /** Build a cached query
+ * @param res The result data, an IP or hostname
+ * @param ttl The time-to-live value of the query result
+ */
CachedQuery(const std::string &res, unsigned int ttl) : data(res)
{
expires = time(NULL) + ttl;
}
+ /** Returns the number of seconds remaining before this
+ * cache item has expired and should be removed.
+ */
int CalcTTLRemaining()
{
int n = expires - time(NULL);
}
};
-/** DNS cache information
+/** DNS cache information. Holds IPs mapped to hostnames, and hostnames mapped to IPs.
*/
typedef nspace::hash_map<irc::string, CachedQuery, nspace::hash<irc::string> > dnscache;
* this method will return -1.
*/
int GetId();
-
/**
* Returns the creator module, or NULL
*/
Module* GetCreator();
-
+ /**
+ * If the result is a cached result, this triggers the objects
+ * OnLookupComplete. This is done because it is not safe to call
+ * the abstract virtual method from the constructor.
+ */
void TriggerCachedResult();
};
{
private:
+ /**
+ * Creator/Owner object
+ */
InspIRCd* ServerInstance;
/**
*/
dnscache* cache;
+ /** A timer which ticks every hour to remove expired
+ * items from the DNS cache.
+ */
class CacheTimer* PruneTimer;
/**
int MakePayload(const char* name, const QueryType rr, const unsigned short rr_class, unsigned char* payload);
public:
+
/**
* Currently active Resolver classes
*/
Resolver* Classes[MAX_REQUEST_ID];
+
/**
* Requests that are currently 'in flight'
*/
DNSRequest* requests[MAX_REQUEST_ID];
+
/**
* The port number DNS requests are made on,
* and replies have as a source-port number.
* Fill an rr (resource record) with data from input
*/
static void FillResourceRecord(ResourceRecord* rr, const unsigned char* input);
+
/**
* Fill a header with data from input limited by a length
*/
static void FillHeader(DNSHeader *header, const unsigned char *input, const int length);
+
/**
* Empty out a header into a data stream ready for transmission "on the wire"
*/
static void EmptyHeader(unsigned char *output, const DNSHeader *header, const int length);
+
/**
* Start the lookup of an ipv4 from a hostname
*/
*/
void CleanResolvers(Module* module);
+ /** Return the cached value of an IP or hostname
+ * @param source An IP or hostname to find in the cache.
+ * @return A pointer to a CachedQuery if the item exists,
+ * otherwise NULL.
+ */
CachedQuery* GetCache(const std::string &source);
+ /** Delete a cached item from the DNS cache.
+ * @param source An IP or hostname to remove
+ */
void DelCache(const std::string &source);
+ /** Clear all items from the DNS cache immediately.
+ */
int ClearCache();
+
+ /** Prune the DNS cache, e.g. remove all expired
+ * items and rehash the cache buckets, but leave
+ * items in the hash which are still valid.
+ */
int PruneCache();
};
/** The triggering time
*/
time_t trigger;
+ /** Number of seconds between triggers
+ */
long secs;
+ /** True if this is a repeating timer
+ */
bool repeat;
public:
/** Default constructor, initializes the triggering time
secs = secs_from_now;
repeat = repeating;
}
+
/** Default destructor, does nothing.
*/
virtual ~InspTimer() { }
+
/** Retrieve the current triggering time
*/
virtual time_t GetTimer()
{
return trigger;
}
+
/** Called when the timer ticks.
+ * You should override this method with some useful code to
+ * handle the tick event.
*/
virtual void Tick(time_t TIME) = 0;
+ /** Returns true if this timer is set to repeat
+ */
bool GetRepeat()
{
return repeat;
}
+ /** Returns the interval (number of seconds between ticks)
+ * of this timer object.
+ */
long GetSecs()
{
return secs;
}
+ /** Cancels the repeat state of a repeating timer.
+ * If you call this method, then the next time your
+ * timer ticks, it will be removed immediately after.
+ * You should use this method call to remove a recurring
+ * timer if you wish to do so within the timer's Tick
+ * event, as calling TimerManager::DelTimer() from within
+ * the InspTimer::Tick() method is dangerous and may
+ * cause a segmentation fault. Calling CancelRepeat()
+ * is safe in this case.
+ */
void CancelRepeat()
{
repeat = false;
public:
+ /** Create a new connect class with no settings.
+ */
ConnectClass() : type(CC_DENY), registration_timeout(0), flood(0), host(""), pingtime(0), pass(""),
threshold(0), sendqmax(0), recvqmax(0), maxlocal(0), maxglobal(0) { }
+ /** Create a new connect class to ALLOW connections.
+ * @param timeout The registration timeout
+ * @param fld The flood value
+ * @param hst The IP mask to allow
+ * @param ping The ping frequency
+ * @param pas The password to be used
+ * @param thres The flooding threshold
+ * @param sendq The maximum sendq value
+ * @param recvq The maximum recvq value
+ * @param maxl The maximum local sessions
+ * @param maxg The maximum global sessions
+ */
ConnectClass(unsigned int timeout, unsigned int fld, const std::string &hst, unsigned int ping,
const std::string &pas, unsigned int thres, unsigned long sendq, unsigned long recvq,
unsigned long maxl, unsigned long maxg) :
type(CC_ALLOW), registration_timeout(timeout), flood(fld), host(hst), pingtime(ping), pass(pas),
threshold(thres), sendqmax(sendq), recvqmax(recvq), maxlocal(maxl), maxglobal(maxg) { }
+ /** Create a new connect class to DENY connections
+ * @param hst The IP mask to deny
+ */
ConnectClass(const std::string &hst) : type(CC_DENY), registration_timeout(0), flood(0), host(hst), pingtime(0),
pass(""), threshold(0), sendqmax(0), recvqmax(0), maxlocal(0), maxglobal(0) { }
+ /** Returns the type, CC_ALLOW or CC_DENY
+ */
char GetType()
{
return (type == CC_ALLOW ? CC_ALLOW : CC_DENY);
}
+ /** Returns the registration timeout
+ */
unsigned int GetRegTimeout()
{
return (registration_timeout ? registration_timeout : 90);
}
+ /** Returns the flood limit
+ */
unsigned int GetFlood()
{
return (threshold ? flood : 999);
}
+ /** Returns the allowed or denied IP mask
+ */
const std::string& GetHost()
{
return host;
}
+ /** Returns the ping frequency
+ */
unsigned int GetPingTime()
{
return (pingtime ? pingtime : 120);
}
+ /** Returns the password or an empty string
+ */
const std::string& GetPass()
{
return pass;
}
+ /** Returns the flood threshold value
+ */
unsigned int GetThreshold()
{
return (threshold ? threshold : 1);
}
+ /** Returns the maximum sendq value
+ */
unsigned long GetSendqMax()
{
return (sendqmax ? sendqmax : 262114);
}
+ /** Returns the maximum recvq value
+ */
unsigned long GetRecvqMax()
{
return (recvqmax ? recvqmax : 4096);
}
+ /** Returusn the maximum number of local sessions
+ */
unsigned long GetMaxLocal()
{
return (maxlocal ? maxlocal : 1);
}
+ /** Returns the maximum number of global sessions
+ */
unsigned long GetMaxGlobal()
{
return (maxglobal ? maxglobal : 1);
*/
unsigned int ChannelCount;
+ /** Cached nick!ident@host value using the real hostname
+ */
char* cached_fullhost;
+
+ /** Cached nick!ident@ip value using the real IP address
+ */
char* cached_hostip;
+
+ /** Cached nick!ident@host value using the masked hostname
+ */
char* cached_makehost;
char* cached_fullrealhost;
*/
long threshold;
- /** IPV4 or IPV6 ip address
+ /** IPV4 or IPV6 ip address. Use SetSockAddr to set this and GetProtocolFamily/
+ * GetIPString/GetPort to obtain its values.
*/
sockaddr* ip;
*/
std::string WriteError;
- /** Maximum size this user's sendq can become
+ /** Maximum size this user's sendq can become.
+ * Copied from the connect class on connect.
*/
long sendqmax;
- /** Maximum size this user's recvq can become
+ /** Maximum size this user's recvq can become.
+ * Copied from the connect class on connect.
*/
long recvqmax;
/** Handle socket event.
* From EventHandler class.
+ * @param et Event type
+ * @param errornum Error number for EVENT_ERROR events
*/
void HandleEvent(EventType et, int errornum = 0);
projects / user / henk / code / inspircd.git / commitdiff