# This can be useful where your main class is more restrictive
# than some other class a user can be assigned after DNS lookup is complete.
# Turning this option off will make the server spend more time on users we may
- # potentially not want. Normally this should be neglible, though.
+ # potentially not want. Normally this should be negligible, though.
# Default value is true
clonesonconnect="yes"
# There are many different types which may be used, and modules may
# generate their own. A list of useful types:
# - USERS - information relating to user connection and disconnection
-# - OPER - succesful and failed oper attempts
+# - OPER - successful and failed oper attempts
# - KILL - kill related messages
# - FILTER - messages related to filter matches (filter module)
# - CONFIG - configuration related messages
# repeated to whitelist multiple CIDRs. #
# #
# ldaprequire allows further filtering on the LDAP user, by requiring #
-# certain LDAP attibutes to have a given value. It can be repeated, #
+# certain LDAP attributes to have a given value. It can be repeated, #
# in which case the list will act as an OR list, that is, the #
# authentication will succeed if any of the requirements in the list #
# is satisfied. #
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
# SAMODE module: Adds the /SAMODE command which allows server operators
# to change modes on a channel without requiring them to have any
-# channel priviliges. Also allows changing user modes for any user.
+# channel privileges. Also allows changing user modes for any user.
# This module is oper-only.
# To use, SAMODE must be in one of your oper class blocks.
#<module name="samode">
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
# SATOPIC module: Adds the /SATOPIC command which allows changing the
-# topic on a channel without requiring any channel priviliges.
+# topic on a channel without requiring any channel privileges.
# This module is oper-only.
# To use, SATOPIC must be in one of your oper class blocks.
#<module name="satopic">
Windows isn't a virus, viruses do something
PANIC! buffer = :NickServ WRITE_DB(3). <-- JUST KIDDING!
It just keeps going and going and going and going and goi <BANG>
-All that I know is that nukes are comming from 127.0.0.1
+All that I know is that nukes are coming from 127.0.0.1
I know all about the irc and the mirc cops.
M re ink n ed d, ple s r fil
Please refrain from feeding the server operators. Thank you.
Backup not found: (A)bort (R)etry (P)anic
WinErr 653: Multitasking attempted - system confused.
Cannot join #real_life (invite only)
-"Unfortunatly, no one can be told what the Matrix is. You have to see it for yourself." - Matrix
+"Unfortunately, no one can be told what the Matrix is. You have to see it for yourself." - Matrix
"Reality is a thing of the past" - Matrix
"The future will not be user friendly" - Matrix
"The general idea in chat is to make yourself understandable... ..." - Peer
* This class contains a single element in a channel list, such as a banlist.
*/
-/** Holds all relevent information for a channel.
+/** Holds all relevant information for a channel.
* This class represents a channel, and contains its name, modes, topic, topic set time,
* etc, and an instance of the BanList type.
*/
* @param user The user to add
*
* The data inserted into the reference list is a table as it is
- * an arbitary pointer compared to other users by its memory address,
+ * an arbitrary pointer compared to other users by its memory address,
* as this is a very fast 32 or 64 bit integer comparison.
*/
Membership* AddUser(User* user);
/** Join a user to an existing channel, without doing any permission checks
* @param user The user to join to the channel
- * @param privs Priviliges (prefix mode letters) to give to this user, may be NULL
+ * @param privs Privileges (prefix mode letters) to give to this user, may be NULL
* @param bursting True if this join is the result of a netburst (passed to modules in the OnUserJoin hook)
* @param created_by_local True if this channel was just created by a local user (passed to modules in the OnUserJoin hook)
* @return A newly created Membership object, or NULL if the user was already inside the channel or if the user is a server user
* @param tagname Name of the tag.
* @param tagvalue Tag value, may be empty.
* @param tags TagMap to place the tag into, if it gets accepted.
- * @return True if no error occured, false if the tag name is invalid or if this tag already exists.
+ * @return True if no error occurred, false if the tag name is invalid or if this tag already exists.
*/
bool HandleTag(LocalUser* user, const std::string& tagname, std::string& tagvalue, TagMap& tags) const;
/** This class handles command management and parsing.
* It allows you to add and remove commands from the map,
- * call command handlers by name, and chop up comma seperated
+ * call command handlers by name, and chop up comma separated
* parameters into multiple calls.
*/
class CoreExport CommandParser
*/
Command* GetHandler(const std::string &commandname);
- /** LoopCall is used to call a command handler repeatedly based on the contents of a comma seperated list.
+ /** LoopCall is used to call a command handler repeatedly based on the contents of a comma separated list.
* There are two ways to call this method, either with one potential list or with two potential lists.
* We need to handle two potential lists for JOIN, because a JOIN may contain two lists of items at once:
* the channel names and their keys as follows:
* If there are two lists and the second list runs out of tokens before the first list then parameters[extra]
* will be an EMPTY string when Handle() is called for the remaining tokens in the first list, even if it is
* in the middle of parameters[]! Moreover, empty tokens in the second list are allowed, and those will also
- * result in the appropiate entry being empty in parameters[].
+ * result in the appropriate entry being empty in parameters[].
* This is different than what command handlers usually expect; the command parser only allows an empty param
* as the last item in the vector.
*
* @param user The user who sent the command
* @param handler The command handler to call for each parameter in the list
* @param parameters Parameter list as a vector of strings
- * @param splithere The first parameter index to split as a comma seperated list
- * @param extra The second parameter index to split as a comma seperated list, or -1 (the default) if there is only one list
+ * @param splithere The first parameter index to split as a comma separated list
+ * @param extra The second parameter index to split as a comma separated list, or -1 (the default) if there is only one list
* @param usemax True to limit the command to MaxTargets targets (default), or false to process all tokens
* @return This function returns true when it identified a list in the given parameter and finished calling the
* command handler for each entry on the list. When this occurs, the caller should return without doing anything,
CommandLineConf cmdline;
/** Clones CIDR range for ipv4 (0-32)
- * Defaults to 32 (checks clones on all IPs seperately)
+ * Defaults to 32 (checks clones on all IPs separately)
*/
unsigned char c_ipv4_range;
/** Clones CIDR range for ipv6 (0-128)
- * Defaults to 128 (checks on all IPs seperately)
+ * Defaults to 128 (checks on all IPs separately)
*/
unsigned char c_ipv6_range;
std::string XLineMessage;
/* Holds the network name the local server
- * belongs to. This is an arbitary field defined
+ * belongs to. This is an arbitrary field defined
* by the administrator.
*/
std::string Network;
* @param cmd Command name. This must be UPPER CASE.
* @param minpara Minimum parameters required for the command.
* @param maxpara Maximum number of parameters this command may have - extra parameters
- * will be tossed into one last space-seperated param.
+ * will be tossed into one last space-separated param.
*/
CommandBase(Module* me, const std::string& cmd, unsigned int minpara = 0, unsigned int maxpara = 0);
* a map associated with the object. In this way modules can store their own custom information within user
* objects, channel objects and server objects, without breaking other modules (this is more sensible than using
* a flags variable, and each module defining bits within the flag as 'theirs' as it is less prone to conflict and
- * supports arbitary data storage).
+ * supports arbitrary data storage).
*/
class CoreExport Extensible
: public classbase
* mapping arrays internally.
*******************************************************/
-/** Seperate from the other casemap tables so that code *can* still exclusively rely on RFC casemapping
+/** Separate from the other casemap tables so that code *can* still exclusively rely on RFC casemapping
* if it must.
*
* This is provided as a pointer so that modules can change it to their custom mapping tables,
bool CoreExport operator()(const std::string& a, const std::string& b) const;
};
- /** irc::sepstream allows for splitting token seperated lists.
+ /** irc::sepstream allows for splitting token separated lists.
* Each successive call to sepstream::GetToken() returns
* the next token, until none remain, at which point the method returns
* false.
bool Contains(const std::string& value);
};
- /** A derived form of sepstream, which seperates on commas
+ /** A derived form of sepstream, which separates on commas
*/
class CoreExport commasepstream : public sepstream
{
}
};
- /** A derived form of sepstream, which seperates on spaces
+ /** A derived form of sepstream, which separates on spaces
*/
class CoreExport spacesepstream : public sepstream
{
bool GetTrailing(std::string& token);
};
- /** The portparser class seperates out a port range into integers.
+ /** The portparser class separates out a port range into integers.
* A port range may be specified in the input string in the form
* "6660,6661,6662-6669,7020". The end of the stream is indicated by
* a return value of 0 from portparser::GetToken(). If you attempt
* Reason for it:
* kludge alert!
* SendMode expects a User* to send the numeric replies
- * back to, so we create it a fake user that isnt in the user
+ * back to, so we create it a fake user that isn't in the user
* hash and set its descriptor to FD_MAGIC_NUMBER so the data
* falls into the abyss :p
*/
#include "config.h"
#include <cstring>
-/** Sets ret to the formated string. last is the last parameter before ..., and format is the format in printf-style */
+/** Sets ret to the formatted string. last is the last parameter before ..., and format is the format in printf-style */
#define VAFORMAT(ret, last, format) \
do { \
va_list _vaList; \
*/
unsigned int flush;
- /** Number of write operations that have occured
+ /** Number of write operations that have occurred
*/
unsigned int writeops;
class CoreExport LogManager : public fakederef<LogManager>
{
private:
- /** Lock variable, set to true when a log is in progress, which prevents further loggging from happening and creating a loop.
+ /** Lock variable, set to true when a log is in progress, which prevents further logging from happening and creating a loop.
*/
bool Logging;
* inside the mode parser as in the 1.0 api,
* so the only use of this value (along with
* IsListMode()) is for the core to determine
- * wether your module can produce 'lists' or not
+ * whether your module can produce 'lists' or not
* (e.g. banlists, etc)
*/
bool list;
public:
/**
- * The constructor for ModeHandler initalizes the mode handler.
+ * The constructor for ModeHandler initializes the mode handler.
* The constructor of any class you derive from ModeHandler should
* probably call this constructor with the parameters set correctly.
* @param me The module which created this mode
/**
* If your mode is a listmode, this method will be called to display an empty list (just the end of list numeric)
* @param user The user issuing the command
- * @param channel The channel tehy're requesting an item list of (e.g. a banlist, or an exception list etc)
+ * @param channel The channel they're requesting an item list of (e.g. a banlist, or an exception list etc)
*/
virtual void DisplayEmptyList(User* user, Channel* channel);
/**
* When a MODETYPE_USER mode handler is being removed, the core will call this method for every user on the server.
- * The usermode will be removed using the appropiate server mode using InspIRCd::SendMode().
+ * The usermode will be removed using the appropriate server mode using InspIRCd::SendMode().
* @param user The user which the server wants to remove your mode from
*/
void RemoveMode(User* user);
/** Find the mode handler for a given mode and type.
* @param modeletter mode letter to search for
* @param mt type of mode to search for, user or channel
- * @returns a pointer to a ModeHandler class, or NULL of there isnt a handler for the given mode
+ * @returns a pointer to a ModeHandler class, or NULL of there isn't a handler for the given mode
*/
ModeHandler* FindMode(unsigned const char modeletter, ModeType mt);
*/
PrefixMode* FindPrefix(unsigned const char pfxletter);
- /** Generates a list of modes, comma seperated by type:
+ /** Generates a list of modes, comma separated by type:
* 1; Listmodes EXCEPT those with a prefix
* 2; Modes that take a param when adding or removing
* 3; Modes that only take a param when adding
/** Simple module version */
Version(const std::string &desc, int flags = VF_NONE);
- /** Complex version information, including linking compatability data */
+ /** Complex version information, including linking compatibility data */
Version(const std::string &desc, int flags, const std::string& linkdata);
};
/** Base class for all InspIRCd modules
* This class is the base class for InspIRCd modules. All modules must inherit from this class,
* its methods will be called when irc server events occur. class inherited from module must be
- * instantiated by the ModuleFactory class (see relevent section) for the module to be initialised.
+ * instantiated by the ModuleFactory class (see relevant section) for the module to be initialised.
*/
class CoreExport Module : public classbase, public usecountbase
{
/** Called after a user opers locally.
* This is identical to Module::OnOper(), except it is called after OnOper so that other modules
- * can be gauranteed to already have processed the oper-up, for example m_spanningtree has sent
+ * can be guaranteed to already have processed the oper-up, for example m_spanningtree has sent
* out the OPERTYPE, etc.
* @param user The user who is opering up
* @param opername The name of the oper that the user is opering up to. Only valid locally. Empty string otherwise.
virtual ModResult OnUserPreInvite(User* source,User* dest,Channel* channel, time_t timeout);
/** Called after a user has been successfully invited to a channel.
- * You cannot prevent the invite from occuring using this function, to do that,
+ * You cannot prevent the invite from occurring using this function, to do that,
* use OnUserPreInvite instead.
* @param source The user who is issuing the INVITE
* @param dest The user being invited
/** Called when a 005 numeric is about to be output.
* The module should modify the 005 numeric if needed to indicate its features.
- * @param tokens The 005 map to be modified if neccessary.
+ * @param tokens The 005 map to be modified if necessary.
*/
virtual void On005Numeric(std::map<std::string, std::string>& tokens);
* for example loaded "m_killwidgets.so" with "m_makewidgets.so". It is highly
* recommended that modules do *NOT* bail if they cannot satisfy dependencies,
* but instead operate under reduced functionality, unless the dependency is
- * absolutely neccessary (e.g. a module that extends the features of another
+ * absolutely necessary (e.g. a module that extends the features of another
* module).
* @param mod A pointer to the new module
*/
* for example loaded "m_killwidgets.so" with "m_makewidgets.so". It is highly
* recommended that modules do *NOT* bail if they cannot satisfy dependencies,
* but instead operate under reduced functionality, unless the dependency is
- * absolutely neccessary (e.g. a module that extends the features of another
+ * absolutely necessary (e.g. a module that extends the features of another
* module).
* @param mod Pointer to the module being unloaded (still valid)
*/
/** Called once every five seconds for background processing.
* This timer can be used to control timed features. Its period is not accurate
- * enough to be used as a clock, but it is gauranteed to be called at least once in
+ * enough to be used as a clock, but it is guaranteed to be called at least once in
* any five second period, directly from the main loop of the server.
* @param curtime The current timer derived from time(2)
*/
virtual void OnBackgroundTimer(time_t curtime);
/** Called whenever any command is about to be executed.
- * This event occurs for all registered commands, wether they are registered in the core,
+ * This event occurs for all registered commands, whether they are registered in the core,
* or another module, and for invalid commands. Invalid commands may only be sent to this
* function when the value of validated is false. By returning 1 from this method you may prevent the
* command being executed. If you do this, no output is created by the core, and it is
- * down to your module to produce any output neccessary.
+ * down to your module to produce any output necessary.
* Note that unless you return 1, you should not destroy any structures (e.g. by using
* InspIRCd::QuitUser) otherwise when the command's handler function executes after your
* method returns, it will be passed an invalid pointer to the user object and crash!)
virtual ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated);
/** Called after any command has been executed.
- * This event occurs for all registered commands, wether they are registered in the core,
+ * This event occurs for all registered commands, whether they are registered in the core,
* or another module, but it will not occur for invalid commands (e.g. ones which do not
* exist within the command table). The result code returned by the command handler is
* provided.
virtual ModResult OnUserRegister(LocalUser* user);
/** Called whenever a user joins a channel, to determine if invite checks should go ahead or not.
- * This method will always be called for each join, wether or not the channel is actually +i, and
+ * This method will always be called for each join, whether or not the channel is actually +i, and
* determines the outcome of an if statement around the whole section of invite checking code.
* return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
* @param user The user joining the channel
virtual ModResult OnRawMode(User* user, Channel* chan, ModeHandler* mh, const std::string& param, bool adding);
/** Called whenever a user joins a channel, to determine if key checks should go ahead or not.
- * This method will always be called for each join, wether or not the channel is actually +k, and
+ * This method will always be called for each join, whether or not the channel is actually +k, and
* determines the outcome of an if statement around the whole section of key checking code.
* if the user specified no key, the keygiven string will be a valid but empty value.
* return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
virtual ModResult OnCheckKey(User* user, Channel* chan, const std::string &keygiven);
/** Called whenever a user joins a channel, to determine if channel limit checks should go ahead or not.
- * This method will always be called for each join, wether or not the channel is actually +l, and
+ * This method will always be called for each join, whether or not the channel is actually +l, and
* determines the outcome of an if statement around the whole section of channel limit checking code.
* return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
* @param user The user joining the channel
void SetPriority(Module* mod, Priority s);
/** Attach an event to a module.
- * You may later detatch the event with ModuleManager::Detach().
- * If your module is unloaded, all events are automatically detatched.
+ * You may later detach the event with ModuleManager::Detach().
+ * If your module is unloaded, all events are automatically detached.
* @param i Event type to attach
* @param mod Module to attach event to
* @return True if the event was attached
*/
bool Attach(Implementation i, Module* mod);
- /** Detatch an event from a module.
+ /** Detach an event from a module.
* This is not required when your module unloads, as the core will
- * automatically detatch your module from all events it is attached to.
+ * automatically detach your module from all events it is attached to.
* @param i Event type to detach
* @param mod Module to detach event from
* @return True if the event was detached
/**
* Return the number of rows in the result.
*
- * Note that if you have perfomed an INSERT or UPDATE query or other
+ * Note that if you have performed an INSERT or UPDATE query or other
* query which will not return rows, this will return the number of
* affected rows. In this case you SHOULD NEVER access any of the result
* set rows, as there aren't any!
return issuer;
}
- /** Get error string if an error has occured
+ /** Get error string if an error has occurred
* @return The error associated with this users certificate,
* or an empty string if there is no error.
*/
}
};
-/** API implemented by m_sslinfo that allows modules to retrive the TLS (SSL) certificate
+/** API implemented by m_sslinfo that allows modules to retrieve the TLS (SSL) certificate
* information of local and remote users. It can also be used to find out whether a
* user is using TLS (SSL) or not.
*/
* See the protocol documentation for the purpose of ENCAP.
* @param targetmask The target server mask (can contain wildcards)
* @param cmd The ENCAP subcommand
- * @param params List of string parameters which are dependant on the subcommand
+ * @param params List of string parameters which are dependent on the subcommand
* @param source The source of the message (prefix), must be a local user or NULL which means use local server
* @return Always true if the target mask contains wildcards; otherwise true if the server name was found,
* and the message was sent, false if it was not found.
/** Send an ENCAP message to all servers.
* See the protocol documentation for the purpose of ENCAP.
* @param cmd The ENCAP subcommand
- * @param params List of string parameters which are dependant on the subcommand
+ * @param params List of string parameters which are dependent on the subcommand
* @param source The source of the message (prefix), must be a local user or a user behind 'omit'
* or NULL which is equivalent to the local server
* @param omit If non-NULL the message won't be sent in the direction of this server, useful for forwarding messages
inline int GetEventMask() const { return event_mask; }
- /** Set a new file desciptor
+ /** Set a new file descriptor
* @param FD The new file descriptor. Do not call this method without
* first deleting the object from the SocketEngine if you have
* added it to a SocketEngine instance.
static bool HasFd(int fd);
/** Returns the EventHandler attached to a specific fd.
- * If the fd isnt in the socketengine, returns NULL.
+ * If the fd isn't in the socketengine, returns NULL.
* @param fd The event handler to look for
* @return A pointer to the event handler, or NULL
*/
* number of events which occurred during this call. This method will
* dispatch events to their handlers by calling their
* EventHandler::OnEventHandler*() methods.
- * @return The number of events which have occured.
+ * @return The number of events which have occurred.
*/
static int DispatchEvents();
/** The Mutex class represents a mutex, which can be used to keep threads
* properly synchronised. Use mutexes sparingly, as they are a good source
* of thread deadlocks etc, and should be avoided except where absolutely
- * neccessary. Note that the internal behaviour of the mutex varies from OS
+ * necessary. Note that the internal behaviour of the mutex varies from OS
* to OS depending on the thread engine, for example in windows a Mutex
* in InspIRCd uses critical sections, as they are faster and simpler to
* manage.
/** The Mutex class represents a mutex, which can be used to keep threads
* properly synchronised. Use mutexes sparingly, as they are a good source
* of thread deadlocks etc, and should be avoided except where absolutely
- * neccessary. Note that the internal behaviour of the mutex varies from OS
+ * necessary. Note that the internal behaviour of the mutex varies from OS
* to OS depending on the thread engine, for example in windows a Mutex
* in InspIRCd uses critical sections, as they are faster and simpler to
* manage.
*/
typedef XLineContainer::iterator ContainerIter;
-/** An interator in an XLineLookup
+/** An iterator in an XLineLookup
*/
typedef XLineLookup::iterator LookupIter;
*/
const CloneCounts& GetCloneCounts(User* user) const;
- /** Return a map containg IP addresses and their clone counts
+ /** Return a map containing IP addresses and their clone counts
* @return The clone count map
*/
const CloneMap& GetCloneMap() const { return clonemap; }
USERTYPE_SERVER = 3
};
-/** Holds information relevent to <connect allow> and <connect deny> tags in the config file.
+/** Holds information relevant to <connect allow> and <connect deny> tags in the config file.
*/
struct CoreExport ConnectClass : public refcountbase
{
/** If this is set to true, then all socket operations for the user
* are dropped into the bit-bucket.
- * This value is set by QuitUser, and is not needed seperately from that call.
+ * This value is set by QuitUser, and is not needed separately from that call.
* Please note that setting this value alone will NOT cause the user to quit.
*/
unsigned int quitting:1;
/** XLine is the base class for ban lines such as G-lines and K-lines.
* Modules may derive from this, and their xlines will automatically be
* handled as expected by any protocol modules (e.g. m_spanningtree will
- * propogate them using AddLine). The process of translating a type+pattern
+ * propagate them using AddLine). The process of translating a type+pattern
* to a known line type is done by means of an XLineFactory object (see
* below).
*/
*/
time_t set_time;
- /** The duration of the ban, or 0 if permenant
+ /** The duration of the ban, or 0 if permanent
*/
unsigned long duration;
*/
~XLineManager();
- /** Split an ident and host into two seperate strings.
+ /** Split an ident and host into two separate strings.
* This allows for faster matching.
*/
IdentHostPair IdentSplit(const std::string &ident_and_host);
3: List of additional characters that should be treated as upper-case
4: 255 characters table - to-lower case conversion table.
-Can be usefull for example for comparing nicknames that contains similar-looking characters with different codes.
+Can be useful for example for comparing nicknames that contains similar-looking characters with different codes.
5: 255 characters table - to-upper case conversion table.
-Can be usefull for example for comparing nicknames that contains similar-looking characters with different codes.
+Can be useful for example for comparing nicknames that contains similar-looking characters with different codes.
6: List of additional UTF-8 allowed characters
/* The caller is trying to match ident@<mask>/bits.
* Chop off the ident@ portion, use match() on it
- * seperately.
+ * separately.
*/
if (match_with_username)
{
// Iterator to the first excess parameter
const CommandBase::Params::iterator firstexcess = lastkeep + 1;
- // Append all excess parameter(s) to the last parameter, seperated by spaces
+ // Append all excess parameter(s) to the last parameter, separated by spaces
for (CommandBase::Params::const_iterator i = firstexcess; i != command_p.end(); ++i)
{
lastkeep->push_back(' ');
}
/*
- * We call OnPreCommand here seperately if the command exists, so the magic above can
+ * We call OnPreCommand here separately if the command exists, so the magic above can
* truncate to max_params if necessary. -- w00t
*/
ModResult MOD_RESULT;
return MODEACTION_DENY;
if (exists && (parameter != *key))
{
- /* Key is currently set and the correct key wasnt given */
+ /* Key is currently set and the correct key wasn't given */
return MODEACTION_DENY;
}
} else {
*/
CmdResult CommandKill::Handle(User* user, const Params& parameters)
{
- /* Allow comma seperated lists of users for /KILL (thanks w00t) */
+ /* Allow comma separated lists of users for /KILL (thanks w00t) */
if (CommandParser::LoopCall(user, this, parameters, 0))
{
// If we got a colon delimited list of nicks then the handler ran for each nick,
while (ss.GetToken(token))
{
// Two or more tags with the same key must not be sent, but if a client violates that we accept
- // the first occurence of duplicate tags and ignore all later occurences.
+ // the first occurrence of duplicate tags and ignore all later occurrences.
//
// Another option is to reject the message entirely but there is no standard way of doing that.
const std::string::size_type p = token.find('=');
return CMD_SUCCESS;
/*
- * If 2 paramters are specified (/whois nick nick), ignore the first one like spanningtree
- * does, and use the second one, otherwise, use the only paramter. -- djGrrr
+ * If 2 parameters are specified (/whois nick nick), ignore the first one like spanningtree
+ * does, and use the second one, otherwise, use the only parameter. -- djGrrr
*/
if (parameters.size() > 1)
userindex = 1;
}
else
{
- /* Found something thats not a number, find out how much
+ /* Found something that's not a number, find out how much
* it multiplies the built up number by, multiply the total
* and reset the built up number.
*/
InspIRCd* ServerInstance = NULL;
-/** Seperate from the other casemap tables so that code *can* still exclusively rely on RFC casemapping
+/** Separate from the other casemap tables so that code *can* still exclusively rely on RFC casemapping
* if it must.
*
* This is provided as a pointer so that modules can change it to their custom mapping tables,
std::cout << "InspIRCd Process ID: " << con_green << getpid() << con_reset << std::endl;
/* During startup we read the configuration now, not in
- * a seperate thread
+ * a separate thread
*/
this->Config->Read();
this->Config->Apply(NULL, "");
UpdateTime();
/* Run background module timers every few seconds
- * (the docs say modules shouldnt rely on accurate
+ * (the docs say modules should not rely on accurate
* timing using this event, so we dont have to
* time this exactly).
*/
}
/* Eh? this module doesnt exist, probably trying to set priority on an event
- * theyre not attached to.
+ * they're not attached to.
*/
return false;
bool ModuleManager::PrioritizeHooks()
{
/* We give every module a chance to re-prioritize when we introduce a new one,
- * not just the one thats loading, as the new module could affect the preference
+ * not just the one that's loading, as the new module could affect the preference
* of others
*/
for (int tries = 0; tries < 20; tries++)
* worker thread wakes up, and checks if there is a request at the head of its queue.
* If there is, it processes this request, blocking the worker thread but leaving the ircd
* thread to go about its business as usual. During this period, the ircd thread is able
- * to insert futher pending requests into the queue.
+ * to insert further pending requests into the queue.
*
* Once the processing of a request is complete, it is removed from the incoming queue to
* an outgoing queue, and initialized as a 'response'. The worker thread then signals the
* one the module was originally instantiated upon, there is a chance of all hell breaking loose
* if a module is ever put in a re-enterant state (stack corruption could occur, crashes, data
* corruption, and worse, so DONT think about it until the day comes when InspIRCd is 100%
- * gauranteed threadsafe!)
+ * guaranteed threadsafe!)
*/
class SQLConnection;
/* Parse the command string and dispatch it to mysql */
if (CheckConnection() && !mysql_real_query(connection, query.data(), query.length()))
{
- /* Successfull query */
+ /* Successful query */
MYSQL_RES* res = mysql_use_result(connection);
unsigned long rows = mysql_affected_rows(connection);
return new MySQLresult(res, rows);
if(PQsetnonblocking(sql, 1) == -1)
return false;
- /* OK, we've initalised the connection, now to get it hooked into the socket engine
+ /* OK, we've initialised the connection, now to get it hooked into the socket engine
* and then start polling it.
*/
this->fd = PQsocket(sql);
ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) CXX11_OVERRIDE
{
- /* If theyre not registered yet, we dont want
+ /* If they're not registered yet, we dont want
* to know.
*/
if (user->registered != REG_ALL)
parameter = (action.second ? "" : "-") + action.first->uuid;
}
- /** Will take any number of nicks (up to MaxTargets), which can be seperated by commas.
+ /** Will take any number of nicks (up to MaxTargets), which can be separated by commas.
* - in front of any nick removes, and an * lists. This effectively means you can do:
* /accept nick1,nick2,nick3,*
* to add 3 nicks and then show your list
RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
// There is a list in parameters[0] in two cases:
- // Either when the source is remote, this happens because 2.0 servers send comma seperated uuid lists,
+ // Either when the source is remote, this happens because 2.0 servers send comma separated uuid lists,
// we don't split those but broadcast them, as before.
//
// Or if the source is local then LoopCall() runs OnPostCommand() after each entry in the list,
// meaning the linking module has sent an ACCEPT already for each entry in the list to the
- // appropiate server and the ACCEPT with the list of nicks (this) doesn't need to be sent anywhere.
+ // appropriate server and the ACCEPT with the list of nicks (this) doesn't need to be sent anywhere.
if ((!IS_LOCAL(user)) && (parameters[0].find(',') != std::string::npos))
return ROUTE_BROADCAST;
, ext(Ext)
{
syntax = "[(+|-)<nick> [<time>]]|[LIST|HELP]";
- /* XXX we need to fix this so it can work with translation stuff (i.e. move +- into a seperate param */
+ /* XXX we need to fix this so it can work with translation stuff (i.e. move +- into a separate param */
}
CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
/* We cant block a part or quit, so instead we change the reason to 'Reason filtered' */
parameters[parting ? 1 : 0] = "Reason filtered";
- /* We're warning or blocking, OR theyre quitting and its a KILL action
+ /* We're warning or blocking, OR they're quitting and its a KILL action
* (we cant kill someone whos already quitting, so filter them anyway)
*/
if ((f->action == FA_WARN) || (f->action == FA_BLOCK) || (((!parting) && (f->action == FA_KILL))) || (f->action == FA_SILENT))
else
rheaders.RemoveHeader("Content-Type");
- /* Supporting Connection: keep-alive causes a whole world of hurt syncronizing timeouts,
+ /* Supporting Connection: keep-alive causes a whole world of hurt synchronizing timeouts,
* so remove it, its not essential for what we need.
*/
rheaders.SetHeader("Connection", "Close");
* our ident lookup class that is outside of this module, or out-
* side of the control of the class. There are no timers, internal
* events, or such, which will cause the socket to be deleted,
- * queued for deletion, etc. In fact, theres not even any queueing!
+ * queued for deletion, etc. In fact, there's not even any queueing!
*
* Using this framework we have a much more stable module.
*
void Close()
{
- /* Remove ident socket from engine, and close it, but dont detatch it
+ /* Remove ident socket from engine, and close it, but dont detach it
* from its parent user class, or attempt to delete its memory.
*/
if (HasFd())
void OnReloadModuleRestore(Module* mod, void* data) CXX11_OVERRIDE
{
- // Reloading can change the set of caps provided by a module so assuming that if the reload succeded all
+ // Reloading can change the set of caps provided by a module so assuming that if the reload succeeded all
// caps that the module previously provided are available or all were lost if the reload failed is wrong.
// Instead, we verify the availability of each cap individually.
dynamic_reference_nocheck<Cap::Manager> capmanager(this, "capmanager");
}
};
-// Not in a class due to circular dependancy hell.
+// Not in a class due to circular dependency hell.
static std::string permchannelsconf;
static bool WriteDatabase(PermChannel& permchanmode, Module* mod, bool save_listmodes)
{
#ifdef _WIN32
remove(permchannelsconf.c_str());
#endif
- // Use rename to move temporary to new db - this is guarenteed not to fuck up, even in case of a crash.
+ // Use rename to move temporary to new db - this is guaranteed not to fuck up, even in case of a crash.
if (rename(permchannelsnewconf.c_str(), permchannelsconf.c_str()) < 0)
{
ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Cannot replace old database \"%s\" with new database \"%s\"! %s (%d)", permchannelsconf.c_str(), permchannelsnewconf.c_str(), strerror(errno), errno);
this->WriteLine("CAPAB END");
}
-/* Isolate and return the elements that are different between two comma seperated lists */
+/* Isolate and return the elements that are different between two comma separated lists */
void TreeSocket::ListDifference(const std::string &one, const std::string &two, char sep,
std::string& mleft, std::string& mright)
{
class CommandFJoin : public ServerCommand
{
/** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes.
- * This does not update the timestamp of the target channel, this must be done seperately.
+ * This does not update the timestamp of the target channel, this must be done separately.
*/
static void RemoveStatus(Channel* c);
/*
* If the topics were updated at the exact same second, accept
* the remote only when it's "bigger" than ours as defined by
- * string comparision, so non-empty topics always overridde
+ * string comparison, so non-empty topics always overridde
* empty topics if their timestamps are equal
*
* Similarly, if the topic texts are equal too, keep one topic
ShowLinks(server, user, hops+1);
}
}
- /* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */
+ /* Don't display the line if its a uline, hide ulines is on, and the user isn't an oper */
if ((Utils->HideULines) && (Current->IsULine()) && (!user->IsOper()))
return;
/* Or if the server is hidden and they're not an oper */
*/
void DoConnectTimeout(time_t curtime);
- /** Handle remote VERSON
+ /** Handle remote VERSION
*/
ModResult HandleVersion(const CommandBase::Params& parameters, User* user);
if (j != child_map.begin())
{
// If this child is not my last child, then add |
- // to be able to "link" the next server in my list to me, and to indent this childs servers
+ // to be able to "link" the next server in my list to me, and to indent this children servers
if (!last)
prefix = "| ";
- // Otherwise this is my last child, so just use a space as theres nothing else linked to me below this
+ // Otherwise this is my last child, so just use a space as there's nothing else linked to me below this
else
prefix = " ";
}
#include "treesocket.h"
/** This class is used to resolve server hostnames during /connect and autoconnect.
- * As of 1.1, the resolver system is seperated out from BufferedSocket, so we must do this
+ * As of 1.1, the resolver system is separated out from BufferedSocket, so we must do this
* resolver step first ourselves if we need it. This is totally nonblocking, and will
* callback to OnLookupComplete or OnError when completed. Once it has completed we
* will have an IP address which we can then use to continue our connection.
};
/** This class is used to resolve server hostnames during /connect and autoconnect.
- * As of 1.1, the resolver system is seperated out from BufferedSocket, so we must do this
+ * As of 1.1, the resolver system is separated out from BufferedSocket, so we must do this
* resolver step first ourselves if we need it. This is totally nonblocking, and will
* callback to OnLookupComplete or OnError when completed. Once it has completed we
* will have an IP address which we can then use to continue our connection.
* be referenced by its server name. The AddHashEntry()
* call below automatically inserts each TreeServer class
* into the hash_map as it is created. There is a similar
- * maintainance call in the destructor to tidy up deleted
+ * maintenance call in the destructor to tidy up deleted
* servers.
*/
// Connection closed.
// If the connection is fully up (state CONNECTED)
- // then propogate a netsplit to all peers.
+ // then propagate a netsplit to all peers.
if (MyRoot)
MyRoot->SQuit(getError(), true);
if (*v == '+')
continue;
- /* For each mode thats set, find the mode handler and set it on the new user */
+ /* For each mode that's set, find the mode handler and set it on the new user */
ModeHandler* mh = ServerInstance->Modes->FindMode(*v, MODETYPE_USER);
if (!mh)
throw ProtocolException("Unrecognised mode '" + std::string(1, *v) + "'");
User* target = msgtarget.Get<User>();
- /* If one or more of the parties involved is a ulined service, we wont stop it. */
+ /* If one or more of the parties involved is a ulined service, we won't stop it. */
if (user->server->IsULine() || target->server->IsULine())
return MOD_RES_PASSTHRU;
{
if (!checked_privs)
{
- // Do not trigger the insufficient priviliges message more than once
+ // Do not trigger the insufficient privileges message more than once
checked_privs = true;
has_privs = user->HasPrivPermission("users/auspex");
if (!has_privs)
#ifdef _WIN32
remove(xlinedbpath.c_str());
#endif
- // Use rename to move temporary to new db - this is guarenteed not to fuck up, even in case of a crash.
+ // Use rename to move temporary to new db - this is guaranteed not to fuck up, even in case of a crash.
if (rename(xlinenewdbpath.c_str(), xlinedbpath.c_str()) < 0)
{
ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Cannot replace old database \"%s\" with new database \"%s\"! %s (%d)", xlinedbpath.c_str(), xlinenewdbpath.c_str(), strerror(errno), errno);
for (UserManager::OperList::const_iterator i = opers.begin(); i != opers.end(); ++i)
{
User* user = *i;
- // IsNoticeMaskSet() returns false for opers who aren't +s, no need to check for it seperately
+ // IsNoticeMaskSet() returns false for opers who aren't +s, no need to check for it separately
if (IS_LOCAL(user) && user->IsNoticeMaskSet(letter))
user->WriteNotice(finalmsg);
}
/*
* You may be thinking "wtf, we checked this in User::AddClient!" - and yes, we did, BUT.
* At the time AddClient is called, we don't have a resolved host, by here we probably do - which
- * may put the user into a totally seperate class with different restrictions! so we *must* check again.
+ * may put the user into a totally separate class with different restrictions! so we *must* check again.
* Don't remove this! -- w00t
*/
MyClass = NULL;
* was added, it iterated every existing line for every existing user. Ow. Expiry was also
* expensive, as the lists were NOT sorted.
*
- * Version 2 moved permanent lines into a seperate list from non-permanent to help optimize
+ * Version 2 moved permanent lines into a separate list from non-permanent to help optimize
* matching speed, but matched in the same way.
* Expiry was also sped up by sorting the list by expiry (meaning just remove the items at the
* head of the list that are outdated.)
* than it could have been, something which we address here.
*
* VERSION 3:
- * All lines are (as in v1) stored together -- no seperation of perm and non-perm. They are stored in
+ * All lines are (as in v1) stored together -- no separation of perm and non-perm. They are stored in
* a map of maps (first map is line type, second map is for quick lookup on add/delete/etc).
*
* Expiry is *no longer* performed on a timer, and no longer uses a sorted list of any variety. This
* whereas on POSIX systems, shared objects loaded into an executable share
* the executable's heap. This means that if we pass an arbitrary pointer to
* a windows DLL which is not allocated in that dll, without some form of
- * marshalling, we get a page fault. To fix this, these overrided operators
+ * marshalling, we get a page fault. To fix this, these overridden operators
* new and delete use the windows HeapAlloc and HeapFree functions to claim
* memory from the windows global heap. This makes windows 'act like' POSIX
* when it comes to memory usage between dlls and exes.
#define VC_EXTRALEAN
#define WIN32_LEAN_AND_MEAN
-/* Macros for exporting symbols - dependant on what is being compiled */
+/* Macros for exporting symbols - dependent on what is being compiled */
#ifdef DLL_BUILD
#define CoreExport __declspec(dllimport)
static Service_Data g_ServiceData;
/** The main part of inspircd runs within this thread function. This allows the service part to run
- * seperately on its own and to be able to kill the worker thread when its time to quit.
+ * separately on its own and to be able to kill the worker thread when its time to quit.
*/
DWORD WINAPI WorkerThread(LPVOID param)
{
projects / user / henk / code / inspircd.git / commitdiff