*
* MyNewFunction replaceme(ServerInstance);
*
- * someclass->MyFunction = &replaceme;
+ * someclass->MyFunction = \&replaceme;
*
* After this point, calls to someclass->MyFunction will call the new code in your
* replacement functor.
/** Sets or unsets a custom mode in the channels info
* @param mode The mode character to set or unset
- * @param mode_on True if you want to set the mode or false if you want to remove it
+ * @param value True if you want to set the mode or false if you want to remove it
*/
void SetMode(ModeHandler* mode, bool value);
void SetMode(char mode,bool mode_on);
* @param mode The mode character you wish to query
*
* For example if "+L #foo" is set, and you pass this method
- * 'L', it will return '#foo'. If the mode is not set on the
+ * 'L', it will return '\#foo'. If the mode is not set on the
* channel, or the mode has no parameters associated with it,
* it will return an empty string.
*
const UserMembList* GetUsers();
/** Returns true if the user given is on the given channel.
- * @param The user to look for
+ * @param user The user to look for
* @return True if the user is on this channel
*/
bool HasUser(User* user);
* Internally, this calls WriteAllExcept().
* @param user User whos details to prefix the line with, and to omit from receipt of the message
* @param serversource If this parameter is true, use the local server name as the source of the text, otherwise,
- * use the nick!user@host of the user.
+ * use the nick!user\@host of the user.
* @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone
* @param text A printf-style format string which builds the output line without prefix
* @param ... Zero or more POD type
/** Write to all users on a channel except a list of users, using va_args for text
* @param user User whos details to prefix the line with, and to omit from receipt of the message
* @param serversource If this parameter is true, use the local server name as the source of the text, otherwise,
- * use the nick!user@host of the user.
+ * use the nick!user\@host of the user.
* @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone
* @param except_list A list of users NOT to send the text to
* @param text A printf-style format string which builds the output line without prefix
* Internally, this calls WriteAllExcept().
* @param user User whos details to prefix the line with, and to omit from receipt of the message
* @param serversource If this parameter is true, use the local server name as the source of the text, otherwise,
- * use the nick!user@host of the user.
+ * use the nick!user\@host of the user.
* @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone
* @param text A std::string containing the output line without prefix
*/
/** Write to all users on a channel except a list of users, using std::string for text
* @param user User whos details to prefix the line with, and to omit from receipt of the message
* @param serversource If this parameter is true, use the local server name as the source of the text, otherwise,
- * use the nick!user@host of the user.
+ * use the nick!user\@host of the user.
* @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone
* @param except_list A list of users NOT to send the text to
* @param text A std::string containing the output line without prefix
Commandtable cmdlist;
/** Default constructor.
- * @param Instance The creator of this class
*/
CommandParser();
* We need a version which takes two potential lists for JOIN, because a JOIN may contain two lists of items at once,
* the channel names and their keys as follows:
*
- * JOIN #chan1,#chan2,#chan3 key1,,key3
+ * JOIN \#chan1,\#chan2,\#chan3 key1,,key3
*
* Therefore, we need to deal with both lists concurrently. The first instance of this method does that by creating
* two instances of irc::commasepstream and reading them both together until the first runs out of tokens.
* @param user The user who sent the command
* @param CommandObj the command object to call for each parameter in the list
* @param parameters Parameter list as an array of array of char (that's not a typo).
- * @param The number of items in the parameters list
* @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
* @param usemax Limit the command to MaxTargets targets
#include "socketengine.h"
#include "socket.h"
-/** Structure representing a single <tag> in config */
+/** Structure representing a single \<tag> in config */
class CoreExport ConfigTag : public refcountbase
{
std::vector<KeyVal> items;
/** Allowed channel modes from oper classes. */
std::bitset<64> AllowedChanModes;
- /** <oper> block used for this oper-up. May be NULL. */
+ /** \<oper> block used for this oper-up. May be NULL. */
reference<ConfigTag> oper_block;
- /** <type> block used for this oper-up. Valid for local users, may be NULL on remote */
+ /** \<type> block used for this oper-up. Valid for local users, may be NULL on remote */
reference<ConfigTag> type_block;
- /** <class> blocks referenced from the <type> block. These define individual permissions */
+ /** \<class> blocks referenced from the \<type> block. These define individual permissions */
std::vector<reference<ConfigTag> > class_blocks;
/** Name of the oper type; i.e. the one shown in WHOIS */
std::string name;
/** Get a configuration tag
* @param tag The name of the tag to get
- * @param offset get the Nth occurance of the tag
*/
ConfigTag* ConfValue(const std::string& tag);
/** The full path to the modules directory.
* This is either set at compile time, or
* overridden in the configuration file via
- * the <path> tag.
*/
std::string ModPath;
bool RestrictBannedUsers;
/** If this is set to true, then mode lists (e.g
- * MODE #chan b) are hidden from unprivileged
+ * MODE \#chan b) are hidden from unprivileged
* users.
*/
bool HideModeLists[256];
*/
bool UndernetMsgPrefix;
- /** If set to true, the full nick!user@host will be shown in the TOPIC command
+ /** If set to true, the full nick!user\@host will be shown in the TOPIC command
* for who set the topic last. If false, only the nick is shown.
*/
bool FullHostInTopic;
int Penalty;
/** Create a new command.
- * @param Instance Pointer to creator class
+ * @param me The module which created this command.
* @param cmd Command name. This must be UPPER CASE.
- * @param flags User mode required to execute the command. May ONLY be one mode - it's a string to give warnings if people mix params up.
- * For oper only commands, set this to 'o', otherwise use 0.
* @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.
- * @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).
+ * @param maxpara Maximum number of parameters this command may have - extra parameters
+ * will be tossed into one last space-seperated param.
*/
Command(Module* me, const std::string &cmd, int minpara = 0, int maxpara = 0) :
ServiceProvider(me, cmd, SERVICE_COMMAND), flags_needed(0), min_params(minpara), max_params(maxpara),
/** Compose a hex string from raw data.
* @param raw The raw data to compose hex from
- * @pram rawsz The size of the raw data buffer
+ * @param rawsz The size of the raw data buffer
* @return The hex string.
*/
CoreExport std::string hex(const unsigned char *raw, size_t rawsz);
}
/** Hashing stuff is totally different on vc++'s hash_map implementation, so to save a buttload of
- * #ifdefs we'll just do it all at once. Except, of course, with TR1, when it's the same as GCC.
+ * \#ifdefs we'll just do it all at once. Except, of course, with TR1, when it's the same as GCC.
*/
BEGIN_HASHMAP_NAMESPACE
static const char LogHeader[];
/** Find a user in the UUID hash
- * @param nick The nickname to find
+ * @param uid The UUID to find
* @return A pointer to the user, or NULL if the user does not exist
*/
- User* FindUUID(const std::string &);
+ User* FindUUID(const std::string &uid);
/** Find a user in the UUID hash
- * @param nick The nickname to find
+ * @param uid The UUID to find
* @return A pointer to the user, or NULL if the user does not exist
*/
- User* FindUUID(const char *);
+ User* FindUUID(const char *uid);
/** Build the ISUPPORT string by triggering all modules On005Numeric events
*/
* @param sockfd A valid file descriptor of an open socket
* @param port The port number to bind to
* @param addr The address to bind to (IP only)
+ * @param dolisten Should this port be listened on?
* @return True if the port was bound successfully
*/
bool BindSocket(int sockfd, int port, const char* addr, bool dolisten = true);
/** Causes the server to exit after unloading modules and
* closing all open file descriptors.
*
- * @param The exit code to give to the operating system
+ * @param status The exit code to give to the operating system
* (See the ExitStatus enum for valid values)
*/
void Exit(int status);
* to check case against (may be NULL). If map is null, match will be case insensitive.
* @param str The literal string to match against
* @param mask The glob pattern to match against.
+ * @param map The character map to use when matching.
*/
static bool Match(const std::string &str, const std::string &mask, unsigned const char *map = NULL);
static bool Match(const char *str, const char *mask, unsigned const char *map = NULL);
* Supports CIDR patterns as well as globs.
* @param str The literal string to match against
* @param mask The glob or CIDR pattern to match against.
+ * @param map The character map to use when matching.
*/
static bool MatchCIDR(const std::string &str, const std::string &mask, unsigned const char *map = NULL);
static bool MatchCIDR(const char *str, const char *mask, unsigned const char *map = NULL);
/** Call the handler for a given command.
* @param commandname The command whos handler you wish to call
* @param parameters The mode parameters
- * @param pcnt The number of items you have given in the first parameter
* @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 std::vector<std::string>& parameters, 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 pcnt The number of items you have given in the first parameter
+ * @param commandname The command name to check
+ * @param pcnt The parameter count
* @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
*/
public:
/** Create a socket timeout class
* @param fd File descriptor of BufferedSocket
- * @pram Instance server instance to attach to
* @param thesock BufferedSocket to attach to
* @param secs_from_now Seconds from now to time out
* @param now The current time
* This will create a socket, register with socket engine, and start the asynchronous
* connection process. If an error is detected at this point (such as out of file descriptors),
* OnError will be called; otherwise, the state will become CONNECTING.
- * @param dest Address to connect to
- * @param bind Address to bind to (if NULL, no bind will be done)
- * @param timeout Time to wait for connection
+ * @param ipaddr Address to connect to
+ * @param aport Port to connect on
+ * @param maxtime Time to wait for connection
+ * @param connectbindip Address to bind to (if NULL, no bind will be done)
*/
void DoConnect(const std::string &ipaddr, int aport, unsigned long maxtime, const std::string &connectbindip);
}
}
- /** Opens all logfiles defined in the configuration file using <log method="file">.
+ /** Opens all logfiles defined in the configuration file using \<log method="file">.
*/
void OpenFileLogs();
/** Logs an event, sending it to all LogStreams registered for the type.
* @param type Log message type (ex: "USERINPUT", "MODULE", ...)
* @param loglevel Log message level (DEBUG, VERBOSE, DEFAULT, SPARSE, NONE)
- * @param msg The format of the message to be logged. See your C manual on printf() for details.
+ * @param fmt The format of the message to be logged. See your C manual on printf() for details.
*/
void Log(const std::string &type, int loglevel, const char *fmt, ...) CUSTOM_PRINTF(4, 5);
};
* The constructor for ModeHandler initalizes 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
* @param name A one-word name for the mode
* @param modeletter The mode letter you wish to handle
* @param params Parameters taken by the mode
*/
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding); /* Can change the mode parameter as its a ref */
/**
- * If your mode is a listmode, then this method will be called for displaying an item list, e.g. on MODE #channel +modechar
+ * If your mode is a listmode, then this method will be called for displaying an item list, e.g. on MODE \#channel +modechar
* without any parameter or other modes in the command.
* @param user The user issuing the command
* @param channel The channel they're requesting an item list of (e.g. a banlist, or an exception list etc)
* and can be used when your mode is of this type, otherwise you must implement a more advanced version of it to remove
* your mode properly from each user.
* @param user The user which the server wants to remove your mode from
+ * @param stack The mode stack to add the mode change to
*/
virtual void RemoveMode(User* user, irc::modestacker* stack = NULL);
* and can be used when your mode is of this type, otherwise you must implement a more advanced version of it to remove
* your mode properly from each channel. Note that in the case of listmodes, you should remove the entire list of items.
* @param channel The channel which the server wants to remove your mode from
+ * @param stack The mode stack to add the mode change to
*/
virtual void RemoveMode(Channel* channel, irc::modestacker* stack = NULL);
*/
char mode;
/**
- * The mode type being watched (user or channel)
+ * The mode type being watched (user or channel)
*/
ModeType m_type;
* If you alter the parameter you are given, the mode handler will see your atered version
* when it handles the mode.
* @param adding True if the mode is being added and false if it is being removed
- * @type The mode type, either MODETYPE_USER or MODETYPE_CHANNEL
+ * @param type The mode type, either MODETYPE_USER or MODETYPE_CHANNEL
* @return True to allow the mode change to go ahead, false to abort it. If you abort the
* change, the mode handler (and ModeWatcher::AfterMode()) will never see the mode change.
*/
* @param parameter The parameter of the mode, if the mode is supposed to have a parameter.
* You cannot alter the parameter here, as the mode handler has already processed it.
* @param adding True if the mode is being added and false if it is being removed
- * @type The mode type, either MODETYPE_USER or MODETYPE_CHANNEL
+ * @param type The mode type, either MODETYPE_USER or MODETYPE_CHANNEL
*/
virtual void AfterMode(User* source, User* dest, Channel* channel, const std::string ¶meter, bool adding, ModeType type);
};
*
* nick!ident -> nick!ident@*
*
- * host.name -> *!*@host.name
+ * host.name -> *!*\@host.name
*
- * ident@host.name -> *!ident@host.name
+ * ident@host.name -> *!ident\@host.name
*
* This method can be used on both IPV4 and IPV6 user masks.
*/
* @param parameters The parameters of the mode change, in the format
* they would be from a MODE command.
* @param user The user setting or removing the modes. When the modes are set
- * by a server, an 'uninitialized' User is used, where *user::nick == NULL
+ * by a server, an 'uninitialized' User is used, where *user\::nick == NULL
* and *user->server == NULL.
+ * @param merge Should the mode parameters be merged?
*/
void Process(const std::vector<std::string>& parameters, User *user, bool merge = false);
/** Find the mode handler for a given mode and type.
* @param modeletter mode letter to search for
- * @param type of mode to search for, user or channel
+ * @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
*/
ModeHandler* FindMode(unsigned const char modeletter, ModeType mt);
* @param sync This is set to true if the JOIN is the result of a network sync and the remote user is being introduced
* to a channel due to the network sync.
* @param created This is true if the join created the channel
+ * @param except_list A list of users not to send to.
*/
virtual void OnUserJoin(Membership* memb, bool sync, bool created, CUList& except_list);
* seen the join.
* @param memb The channel membership created
*/
- virtual void OnPostJoin(Membership*);
+ virtual void OnPostJoin(Membership* memb);
/** Called when a user parts a channel.
* The details of the leaving user are available to you in the parameter User *user,
* and the details of the channel they have left is available in the variable Channel *channel
* @param memb The channel membership being destroyed
* @param partmessage The part message, or an empty string (may be modified)
+ * @param except_list A list of users to not send to.
*/
virtual void OnUserPart(Membership* memb, std::string &partmessage, CUList& except_list);
* output to be sent to the user by the core. If you do this you must produce your own numerics,
* notices etc.
* @param source The user issuing the kick
- * @param user The user being kicked
- * @param chan The channel the user is being kicked from
+ * @param memb The channel membership of the user who is being kicked.
* @param reason The kick reason
* @return 1 to prevent the kick, 0 to continue normally, -1 to explicitly allow the kick regardless of normal operation
*/
* If this method is called, the kick is already underway and cannot be prevented, so
* to prevent a kick, please use Module::OnUserPreKick instead of this method.
* @param source The user issuing the kick
- * @param user The user being kicked
- * @param chan The channel the user is being kicked from
+ * @param memb The channel membership of the user who was kicked.
* @param reason The kick reason
+ * @param except_list A list of users to not send to.
*/
virtual void OnUserKick(User* source, Membership* memb, const std::string &reason, CUList& except_list);
* @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
* @param text the text being sent by the user
* @param status The status being used, e.g. PRIVMSG @#chan has status== '@', 0 to send to everyone.
+ * @param exempt_list A list of users to not send to.
*/
virtual void OnUserMessage(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list);
* @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
* @param text the text being sent by the user
* @param status The status being used, e.g. NOTICE @#chan has status== '@', 0 to send to everyone.
+ * @param exempt_list A list of users to not send to.
*/
virtual void OnUserNotice(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list);
* @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
* @param text the text being sent by the user
* @param status The status being used, e.g. NOTICE @#chan has status== '@', 0 to send to everyone.
+ * @param exempt_list A list of users not to send to. For channel messages, this will usually contain just the sender.
*/
virtual void OnText(User* user, void* dest, int target_type, const std::string &text, char status, CUList &exempt_list);
/** Allows module data, sent via ProtoSendMetaData, to be decoded again by a receiving module.
* Please see src/modules/m_swhois.cpp for a working example of how to use this method call.
- * @param target_type The type of item to decode data for, TYPE_USER or TYPE_CHANNEL
* @param target The Channel* or User* that data should be added to
* @param extname The extension name which is being sent
* @param extdata The extension data, encoded at the other end by an identical module through OnSyncChannelMetaData or OnSyncUserMetaData
* More documentation to follow soon. Please see src/modules/m_swhois.cpp for example of
* how to use this function.
* @param opaque An opaque pointer set by the protocol module, should not be modified!
- * @param target_type The type of item to decode data for, TYPE_USER or TYPE_CHANNEL
* @param target The Channel* or User* that metadata should be sent for
* @param extname The extension name to send metadata for
* @param extdata Encoded data for this extension name, which will be encoded at the oppsite end by an identical module using OnDecodeMetaData
/** Called whenever a user's IDENT is changed.
* This event triggers after the name has been set.
* @param user The user who's IDENT is being changed
- * @param gecos The new IDENT being set on the user
+ * @param ident The new IDENT being set on the user
*/
virtual void OnChangeIdent(User* user, const std::string &ident);
* @param source The user sending the KILL
* @param dest The user being killed
* @param reason The kill reason
+ * @param operreason The oper kill reason
*/
virtual void OnRemoteKill(User* source, User* dest, const std::string &reason, const std::string &operreason);
* absolutely neccessary (e.g. a module that extends the features of another
* module).
* @param mod Pointer to the module being unloaded (still valid)
- * @param name The filename of the module being unloaded
*/
virtual void OnUnloadModule(Module* mod);
* method returns, it will be passed an invalid pointer to the user object and crash!)
* @param command The command being executed
* @param parameters An array of array of characters containing the parameters for the command
- * @param pcnt The nuimber of parameters passed to the command
* @param user the user issuing the command
* @param validated True if the command has passed all checks, e.g. it is recognised, has enough parameters, the user has permission to execute it, etc.
* You should only change the parameter list and command string if validated == false (e.g. before the command lookup occurs).
* provided.
* @param command The command being executed
* @param parameters An array of array of characters containing the parameters for the command
- * @param pcnt The nuimber of parameters passed to the command
* @param user the user issuing the command
* @param result The return code given by the command handler, one of CMD_SUCCESS or CMD_FAILURE
* @param original_line The entire original line as passed to the parser from the user
* return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
* @param user The user joining the channel
* @param chan The channel being joined
+ * @param keygiven The key given on joining the channel.
* @return 1 to explicitly allow the join, 0 to proceed as normal
*/
virtual ModResult OnCheckKey(User* user, Channel* chan, const std::string &keygiven);
* @param user The user changing the topic
* @param chan The channels who's topic is being changed
* @param topic The actual topic text
- * @param 1 to block the topic change, 0 to allow
+ * @return 1 to block the topic change, 0 to allow
*/
virtual ModResult OnPreTopicChange(User* user, Channel* chan, const std::string &topic);
* The password field (from the config file) is in 'password' and is to be compared against
* 'input'. This method allows for encryption of passwords (oper, connect:allow, die/restart, etc).
* You should return a nonzero value to override the normal comparison, or zero to pass it on.
- * @param ex The object that's causing the authentication (User* for <oper> <connect:allow> etc, Server* for <link>).
+ * @param ex The object that's causing the authentication (User* for \<oper> \<connect:allow> etc, Server* for \<link>).
* @param password The password from the configuration file (the password="" value).
* @param input The password entered by the user or whoever.
* @param hashtype The hash value from the config
virtual ModResult OnDelBan(User* source, Channel* channel,const std::string &banmask);
/** Called to install an I/O hook on an event handler
- * @param user The item to possibly install the I/O hook on
- * @param via The port that <user> connected on
+ * @param user The socket to possibly install the I/O hook on
+ * @param via The port that the user connected on
*/
- virtual void OnHookIO(StreamSocket*, ListenSocket* via);
+ virtual void OnHookIO(StreamSocket* user, ListenSocket* via);
/** Called when a port accepts a connection
* Return MOD_RES_ACCEPT if you have used the file descriptor.
* @param fd The file descriptor returned from accept()
- * @param from The local port the user connected to
+ * @param sock The socket connection for the new user
* @param client The client IP address and port
* @param server The server IP address and port
*/
- virtual ModResult OnAcceptConnection(int fd, ListenSocket* from, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
+ virtual ModResult OnAcceptConnection(int fd, ListenSocket* sock, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
/** Called immediately after any connection is accepted. This is intended for raw socket
* processing (e.g. modules which wrap the tcp connection within another library) and provides
* no information relating to a user record as the connection has not been assigned yet.
* There are no return values from this call as all modules get an opportunity if required to
* process the connection.
- * @param fd The file descriptor returned from accept()
+ * @param sock The socket in question
* @param client The client IP address and port
* @param server The server IP address and port
- * @param localport The local port number the user connected to
*/
- virtual void OnStreamSocketAccept(StreamSocket*, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
+ virtual void OnStreamSocketAccept(StreamSocket* sock, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
/**
* Called when a hooked stream has data to write, or when the socket
* engine returns it as writable
- * @param socket The socket in question
+ * @param sock The socket in question
* @param sendq Data to send to the socket
* @return 1 if the sendq has been completely emptied, 0 if there is
* still data to send, and -1 if there was an error
*/
- virtual int OnStreamSocketWrite(StreamSocket*, std::string& sendq);
+ virtual int OnStreamSocketWrite(StreamSocket* sock, std::string& sendq);
/** Called immediately before any socket is closed. When this event is called, shutdown()
* has not yet been called on the socket.
- * @param fd The file descriptor of the socket prior to close()
+ * @param sock The socket in question
*/
- virtual void OnStreamSocketClose(StreamSocket*);
+ virtual void OnStreamSocketClose(StreamSocket* sock);
/** Called immediately upon connection of an outbound BufferedSocket which has been hooked
* by a module.
- * @param fd The file descriptor of the socket immediately after connect()
+ * @param sock The socket in question
*/
- virtual void OnStreamSocketConnect(StreamSocket*);
+ virtual void OnStreamSocketConnect(StreamSocket* sock);
/**
* Called when the stream socket has data to read
- * @param socket The socket that is ready
+ * @param sock The socket that is ready
* @param recvq The receive queue that new data should be appended to
* @return 1 if new data has been read, 0 if no new data is ready (but the
* socket is still connected), -1 if there was an error or close
*/
- virtual int OnStreamSocketRead(StreamSocket*, std::string& recvq);
+ virtual int OnStreamSocketRead(StreamSocket* sock, std::string& recvq);
/** Called whenever a user sets away or returns from being away.
* The away message is available as a parameter, but should not be modified.
* automatically detatch your module from all events it is attached to.
* @param i Event type to detach
* @param mod Module to detach event from
- * @param Detach true if the event was detached
+ * @return True if the event was detached
*/
bool Detach(Implementation i, Module* mod);
/** Attach an array of events to a module
* @param i Event types (array) to attach
* @param mod Module to attach events to
+ * @param sz The size of the implementation array
*/
void Attach(Implementation* i, Module* mod, size_t sz);
/** Send mode changes for an object.
* @param target The channel name or user to send mode changes for.
- * @param The mode changes to send.
+ * @param modedata The mode changes to send.
+ * @param translate A list of translation types
*/
virtual void SendMode(const std::string &target, const parameterlist &modedata, const std::vector<TranslateType> &translate) { }
* IPV6 addresses.
* @param address The human readable address, e.g. fred\@1.2.3.4
* @param cidr_mask The human readable mask, e.g. *\@1.2.0.0/16
+ * @param match_with_username Does the mask include a nickname segment?
* @return True if the mask matches the address
*/
CoreExport bool MatchCIDR(const std::string &address, const std::string &cidr_mask, bool match_with_username);
* class, and it will be called whenever read or write
* events are received.
* @param et either one of EVENT_READ for read events,
- * and EVENT_WRITE for write events.
+ * EVENT_WRITE for write events and EVENT_ERROR for
+ * error events.
+ * @param errornum The error code which goes with an EVENT_ERROR.
*/
virtual void HandleEvent(EventType et, int errornum = 0) = 0;
/** Abstraction for BSD sockets accept(2).
* This function should emulate its namesake system call exactly.
* @param fd This version of the call takes an EventHandler instead of a bare file descriptor.
+ * @param addr The client IP address and port
+ * @param addrlen The size of the sockaddr parameter.
* @return This method should return exactly the same values as the system call it emulates.
*/
int Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen);
/** Abstraction for BSD sockets send(2).
* This function should emulate its namesake system call exactly.
* @param fd This version of the call takes an EventHandler instead of a bare file descriptor.
+ * @param buf The buffer in which the data that is sent is stored.
+ * @param len The size of the buffer.
+ * @param flags A flag value that controls the sending of the data.
* @return This method should return exactly the same values as the system call it emulates.
*/
int Send(EventHandler* fd, const void *buf, size_t len, int flags);
/** Abstraction for BSD sockets recv(2).
* This function should emulate its namesake system call exactly.
* @param fd This version of the call takes an EventHandler instead of a bare file descriptor.
+ * @param buf The buffer in which the data that is read is stored.
+ * @param len The size of the buffer.
+ * @param flags A flag value that controls the reception of the data.
* @return This method should return exactly the same values as the system call it emulates.
*/
int Recv(EventHandler* fd, void *buf, size_t len, int flags);
/** Abstraction for BSD sockets recvfrom(2).
* This function should emulate its namesake system call exactly.
* @param fd This version of the call takes an EventHandler instead of a bare file descriptor.
+ * @param buf The buffer in which the data that is read is stored.
+ * @param len The size of the buffer.
+ * @param flags A flag value that controls the reception of the data.
+ * @param from The remote IP address and port.
+ * @param fromlen The size of the from parameter.
* @return This method should return exactly the same values as the system call it emulates.
*/
int RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen);
/** Abstraction for BSD sockets sendto(2).
* This function should emulate its namesake system call exactly.
* @param fd This version of the call takes an EventHandler instead of a bare file descriptor.
+ * @param buf The buffer in which the data that is sent is stored.
+ * @param len The size of the buffer.
+ * @param flags A flag value that controls the sending of the data.
+ * @param to The remote IP address and port.
+ * @param tolen The size of the to parameter.
* @return This method should return exactly the same values as the system call it emulates.
*/
int SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen);
/** Abstraction for BSD sockets connect(2).
* This function should emulate its namesake system call exactly.
* @param fd This version of the call takes an EventHandler instead of a bare file descriptor.
+ * @param serv_addr The server IP address and port.
+ * @param addrlen The size of the sockaddr parameter.
* @return This method should return exactly the same values as the system call it emulates.
*/
int Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen);
/** Abstraction for BSD sockets shutdown(2).
* This function should emulate its namesake system call exactly.
* @param fd This version of the call takes an EventHandler instead of a bare file descriptor.
+ * @param how What part of the socket to shut down
* @return This method should return exactly the same values as the system call it emulates.
*/
int Shutdown(EventHandler* fd, int how);
public:
/** Constructor.
- * @param Instance Creator object
*/
ThreadEngine();
/** Add an Timer
* @param T an Timer derived class to add
- * @param secs_from_now You may set this to the number of seconds
- * from the current time when the timer will tick, or you may just
- * leave this unset and the values set by the Timers constructor
- * will be used. This is used internally for re-triggering repeating
- * timers.
*/
void AddTimer(Timer *T);
/** Add a client to the system.
* This will create a new User, insert it into the user_hash,
* initialize it as not yet registered, and add it to the socket engine.
- * @param Instance a pointer to the server instance
* @param socket The socket id (file descriptor) this user is on
* @param via The socket that this user connected using
* @param client The IP address and client port of the user
/** Disconnect a user gracefully
* @param user The user to remove
- * @param r The quit reason to show to normal users
- * @param oreason The quit reason to show to opers
+ * @param quitreason The quit reason to show to normal users
+ * @param operreason The quit reason to show to opers
* @return Although this function has no return type, on exit the user provided will no longer exist.
*/
void QuitUser(User *user, const std::string &quitreason, const char* operreason = "");
/** Returns the full displayed host of the user
* This member function returns the hostname of the user as seen by other users
- * on the server, in nick!ident&at;host form.
+ * on the server, in nick!ident\@host form.
* @return The full masked host of the user
*/
virtual const std::string& GetFullHost();
/** Returns the full real host of the user
* This member function returns the hostname of the user as seen by other users
- * on the server, in nick!ident&at;host form. If any form of hostname cloaking is in operation,
+ * on the server, in nick!ident\@host form. If any form of hostname cloaking is in operation,
* e.g. through a module, then this method will ignore it and return the true hostname.
* @return The full real host of the user
*/
void SetNoticeMask(unsigned char sm, bool value);
/** Create a displayable mode string for this users umodes
- * @param The mode string
+ * @param showparameters The mode string
*/
const char* FormatModes(bool showparameters = false);
virtual bool HasModePermission(unsigned char mode, ModeType type);
/** Creates a wildcard host.
- * Takes a buffer to use and fills the given buffer with the host in the format *!*@hostname
- * @return The wildcarded hostname in *!*@host form
+ * Takes a buffer to use and fills the given buffer with the host in the format *!*\@hostname
+ * @return The wildcarded hostname in *!*\@host form
*/
char* MakeWildHost();
/** Creates a usermask with real host.
- * Takes a buffer to use and fills the given buffer with the hostmask in the format user@host
- * @return the usermask in the format user@host
+ * Takes a buffer to use and fills the given buffer with the hostmask in the format user\@host
+ * @return the usermask in the format user\@host
*/
const std::string& MakeHost();
/** Creates a usermask with real ip.
- * Takes a buffer to use and fills the given buffer with the ipmask in the format user@ip
- * @return the usermask in the format user@ip
+ * Takes a buffer to use and fills the given buffer with the ipmask in the format user\@ip
+ * @return the usermask in the format user\@ip
*/
const std::string& MakeHostIP();
void WriteNumeric(unsigned int numeric, const std::string &text);
- /** Write text to this user, appending CR/LF and prepending :nick!user@host of the user provided in the first parameter.
- * @param user The user to prepend the :nick!user@host of
+ /** Write text to this user, appending CR/LF and prepending :nick!user\@host of the user provided in the first parameter.
+ * @param user The user to prepend the :nick!user\@host of
* @param text A std::string to send to the user
*/
void WriteFrom(User *user, const std::string &text);
- /** Write text to this user, appending CR/LF and prepending :nick!user@host of the user provided in the first parameter.
- * @param user The user to prepend the :nick!user@host of
+ /** Write text to this user, appending CR/LF and prepending :nick!user\@host of the user provided in the first parameter.
+ * @param user The user to prepend the :nick!user\@host of
* @param text The format string for text to send to the user
* @param ... POD-type format arguments
*/
void WriteFrom(User *user, const char* text, ...) CUSTOM_PRINTF(3, 4);
- /** Write text to the user provided in the first parameter, appending CR/LF, and prepending THIS user's :nick!user@host.
+ /** Write text to the user provided in the first parameter, appending CR/LF, and prepending THIS user's :nick!user\@host.
* @param dest The user to route the message to
- * @param text A std::string to send to the user
+ * @param data A std::string to send to the user
*/
void WriteTo(User *dest, const std::string &data);
- /** Write text to the user provided in the first parameter, appending CR/LF, and prepending THIS user's :nick!user@host.
+ /** Write text to the user provided in the first parameter, appending CR/LF, and prepending THIS user's :nick!user\@host.
* @param dest The user to route the message to
- * @param text The format string for text to send to the user
+ * @param data The format string for text to send to the user
* @param ... POD-type format arguments
*/
void WriteTo(User *dest, const char *data, ...) CUSTOM_PRINTF(3, 4);
- /** Write to all users that can see this user (including this user in the list), appending CR/LF
- * @param text A std::string to send to the users
+ /** Write to all users that can see this user (including this user in the list if include_self is true), appending CR/LF
+ * @param line A std::string to send to the users
+ * @param include_self Should the message be sent back to the author?
*/
void WriteCommonRaw(const std::string &line, bool include_self = true);
* Run this after the item in question has changed.
* You should not need to use this function, call ChangeDisplayedHost instead
*
- * @param The entire QUIT line, including the source using the old value
+ * @param quitline The entire QUIT line, including the source using the old value
*/
void DoHostCycle(const std::string &quitline);
* ALWAYS use this function, rather than writing User::ident directly,
* as this correctly causes the user to seem to quit (where configured)
* before setting their ident field.
- * @param host The new ident to set
+ * @param newident The new ident to set
* @return True if the change succeeded, false if it didn't
*/
bool ChangeIdent(const char* newident);
int cmds_out;
/** Password specified by the user when they registered (if any).
- * This is stored even if the <connect> block doesnt need a password, so that
+ * This is stored even if the \<connect> block doesnt need a password, so that
* modules may check it.
*/
std::string password;
ConnectClass* GetClass();
- /** Call this method to find the matching <connect> for a user, and to check them against it.
+ /** Call this method to find the matching \<connect> for a user, and to check them against it.
*/
void CheckClass();
void FullConnect();
/** Set the connect class to which this user belongs to.
- * @param explicit_name Set this string to tie the user to a specific class name. Otherwise, the class is fitted by checking <connect> tags from the configuration file.
+ * @param explicit_name Set this string to tie the user to a specific class name. Otherwise, the class is fitted by checking \<connect> tags from the configuration file.
* @return A reference to this user's current connect class.
*/
void SetClass(const std::string &explicit_name = "");
bool fwd;
public:
/** Create a resolver.
- * @param Instance The creating instance
* @param user The user to begin lookup on
* @param to_resolve The IP or host to resolve
* @param qt The query type
virtual void DisplayExpiry() = 0;
/** Returns the displayable form of the pattern for this xline,
- * e.g. '*@foo' or '*baz*'. This must always return the full pattern
+ * e.g. '*\@foo' or '*baz*'. This must always return the full pattern
* in a form which can be used to construct an entire derived xline,
* even if it is stored differently internally (e.g. GLine stores the
- * ident and host parts seperately but will still return ident@host
+ * ident and host parts seperately but will still return ident\@host
* for its Displayable() method)
*/
virtual const char* Displayable() = 0;
public:
/** Create an XLine factory
- * @param Instance creator
* @param t Type of XLine this factory generates
*/
XLineFactory(const std::string &t) : type(t) { }
public:
/** Constructor
- * @param Instance A pointer to the creator object
*/
XLineManager();
/** Get all lines of a certain type to an XLineLookup (std::map<std::string, XLine*>).
* NOTE: When this function runs any expired items are removed from the list before it
* is returned to the caller.
- * @param The type to look up
+ * @param type The type to look up
* @return A list of all XLines of the given type.
*/
XLineLookup* GetAll(const std::string &type);
/** Handle /STATS for a given type.
* NOTE: Any items in the list for this particular line type which have expired
* will be expired and removed before the list is displayed.
+ * @param type The type of stats to show
* @param numeric The numeric to give to each result line
* @param user The username making the query
* @param results The string_list to receive the results
port_event_t* events;
public:
/** Create a new PortsEngine
- * @param Instance The creator of this object
*/
PortsEngine();
/** Delete a PortsEngine
projects / user / henk / code / inspircd.git / commitdiff