From cabbd084f89908e91b81300a776cbeb5034396b8 Mon Sep 17 00:00:00 2001 From: Till Hoeppner Date: Mon, 20 Apr 2015 20:54:13 +0200 Subject: Something inbetween working and broken --- src/command.rs | 1760 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 3 +- src/message.rs | 1102 ++++------------------------------- src/server.rs | 11 +- 4 files changed, 1880 insertions(+), 996 deletions(-) create mode 100644 src/command.rs (limited to 'src') diff --git a/src/command.rs b/src/command.rs new file mode 100644 index 0000000..828c7a5 --- /dev/null +++ b/src/command.rs @@ -0,0 +1,1760 @@ +use std::borrow::{ ToOwned, Cow }; + +use message::{ Message, MsgType }; + +#[derive(Debug, Hash, PartialEq, Eq)] +pub enum Command<'a> { + /// 3.1.1 Password message + /// + /// Command: PASS + /// Parameters: + /// + /// The PASS command is used to set a 'connection password'. The + /// optional password can and MUST be set before any attempt to register + /// the connection is made. Currently this requires that user send a + /// PASS command before sending the NICK/USER combination. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_ALREADYREGISTRED + /// + /// Example: + /// + /// PASS secretpasswordhere + /// + PASS(&'a str), + + /// 3.1.2 Nick message + /// + /// + /// Command: NICK + /// Parameters: + /// + /// NICK command is used to give user a nickname or change the existing + /// one. + /// + /// Numeric Replies: + /// + /// ERR_NONICKNAMEGIVEN ERR_ERRONEUSNICKNAME + /// ERR_NICKNAMEINUSE ERR_NICKCOLLISION + /// ERR_UNAVAILRESOURCE ERR_RESTRICTED + /// + /// Examples: + /// + /// NICK Wiz ; Introducing new nick "Wiz" if session is + /// still unregistered, or user changing his + /// nickname to "Wiz" + /// + /// :WiZ!jto@tolsun.oulu.fi NICK Kilroy + /// ; Server telling that WiZ changed his + /// nickname to Kilroy. + /// + NICK(&'a str), + + /// 3.1.3 User message + /// + /// Command: USER + /// Parameters: + /// + /// The USER command is used at the beginning of connection to specify + /// the username, hostname and realname of a new user. + /// + /// The parameter should be a numeric, and can be used to + /// automatically set user modes when registering with the server. This + /// parameter is a bitmask, with only 2 bits having any signification: if + /// the bit 2 is set, the user mode 'w' will be set and if the bit 3 is + /// set, the user mode 'i' will be set. (See Section 3.1.5 "User + /// Modes"). + /// + /// The may contain space characters. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_ALREADYREGISTRED + /// + /// Example: + /// + /// USER guest 0 * :Ronnie Reagan ; User registering themselves with a + /// username of "guest" and real name + /// "Ronnie Reagan". + /// + /// USER guest 8 * :Ronnie Reagan ; User registering themselves with a + /// username of "guest" and real name + /// "Ronnie Reagan", and asking to be set + /// invisible. + /// + USER(&'a str, &'a str, &'a str, &'a str), + + /// 3.1.4 Oper message + /// + /// Command: OPER + /// Parameters: + /// + /// A normal user uses the OPER command to obtain operator privileges. + /// The combination of and are REQUIRED to gain + /// Operator privileges. Upon success, the user will receive a MODE + /// message (see section 3.1.5) indicating the new user modes. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS RPL_YOUREOPER + /// ERR_NOOPERHOST ERR_PASSWDMISMATCH + /// + /// Example: + /// + /// OPER foo bar ; Attempt to register as an operator + /// using a username of "foo" and "bar" + /// as the password. + /// + OPER(&'a str, &'a str), + + /// 3.1.5 User mode message + /// + /// Command: UMODE + /// Parameters: + /// *( ( "+" / "-" ) *( "i" / "w" / "o" / "O" / "r" ) ) + /// + /// The user MODE's are typically changes which affect either how the + /// client is seen by others or what 'extra' messages the client is sent. + /// + /// A user MODE command MUST only be accepted if both the sender of the + /// message and the nickname given as a parameter are both the same. If + /// no other parameter is given, then the server will return the current + /// settings for the nick. + /// + /// The available modes are as follows: + /// + /// a - user is flagged as away; + /// i - marks a users as invisible; + /// w - user receives wallops; + /// r - restricted user connection; + /// o - operator flag; + /// O - local operator flag; + /// s - marks a user for receipt of server notices. + /// + /// Additional modes may be available later on. + /// + /// The flag 'a' SHALL NOT be toggled by the user using the MODE command, + /// instead use of the AWAY command is REQUIRED. + /// + /// If a user attempts to make themselves an operator using the "+o" or + /// "+O" flag, the attempt SHOULD be ignored as users could bypass the + /// authentication mechanisms of the OPER command. There is no + /// restriction, however, on anyone `deopping' themselves (using "-o" or + /// "-O"). + /// + /// On the other hand, if a user attempts to make themselves unrestricted + /// using the "-r" flag, the attempt SHOULD be ignored. There is no + /// restriction, however, on anyone `deopping' themselves (using "+r"). + /// This flag is typically set by the server upon connection for + /// administrative reasons. While the restrictions imposed are left up + /// to the implementation, it is typical that a restricted user not be + /// allowed to change nicknames, nor make use of the channel operator + /// status on channels. + /// + /// The flag 's' is obsolete but MAY still be used. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_USERSDONTMATCH + /// ERR_UMODEUNKNOWNFLAG RPL_UMODEIS + /// + /// Examples: + /// + /// MODE WiZ -w ; Command by WiZ to turn off + /// reception of WALLOPS messages. + /// + /// MODE Angel +i ; Command from Angel to make herself + /// invisible. + /// + /// MODE WiZ -o ; WiZ 'deopping' (removing operator + /// status). + /// + UMODE(&'a str), + + /// 3.1.6 Service message + /// + /// Command: SERVICE + /// Parameters: + /// + /// + /// The SERVICE command to register a new service. Command parameters + /// specify the service nickname, distribution, type and info of a new + /// service. + /// + /// The parameter is used to specify the visibility of a + /// service. The service may only be known to servers which have a name + /// matching the distribution. For a matching server to have knowledge + /// of the service, the network path between that server and the server + /// on which the service is connected MUST be composed of servers which + /// names all match the mask. + /// + /// The parameter is currently reserved for future usage. + /// + /// Numeric Replies: + /// + /// ERR_ALREADYREGISTRED ERR_NEEDMOREPARAMS + /// ERR_ERRONEUSNICKNAME + /// RPL_YOURESERVICE RPL_YOURHOST + /// RPL_MYINFO + /// + /// Example: + /// + /// SERVICE dict * *.fr 0 0 :French Dictionary ; Service registering + /// itself with a name of "dict". This + /// service will only be available on + /// servers which name matches "*.fr". + /// + SERVICE(&'a str, &'a str, &'a str, &'a str, &'a str, &'a str), + + /// 3.1.7 Quit + /// + /// Command: QUIT + /// Parameters: [ ] + /// + /// A client session is terminated with a quit message. The server + /// acknowledges this by sending an ERROR message to the client. + /// + /// Numeric Replies: + /// + /// None. + /// + /// Example: + /// + /// QUIT :Gone to have lunch ; Preferred message format. + /// + /// :syrk!kalt@millennium.stealth.net QUIT :Gone to have lunch ; User + /// syrk has quit IRC to have lunch. + /// + QUIT(Option<&'a str>), + + /// 3.1.8 Squit + /// + /// Command: SQUIT + /// Parameters: + /// + /// The SQUIT command is available only to operators. It is used to + /// disconnect server links. Also servers can generate SQUIT messages on + /// error conditions. A SQUIT message may also target a remote server + /// connection. In this case, the SQUIT message will simply be sent to + /// the remote server without affecting the servers in between the + /// operator and the remote server. + /// + /// The SHOULD be supplied by all operators who execute a SQUIT + /// for a remote server. The server ordered to disconnect its peer + /// generates a WALLOPS message with included, so that other + /// users may be aware of the reason of this action. + /// + /// Numeric replies: + /// + /// ERR_NOPRIVILEGES ERR_NOSUCHSERVER + /// ERR_NEEDMOREPARAMS + /// + /// Examples: + /// + /// SQUIT tolsun.oulu.fi :Bad Link ? ; Command to uplink of the server + /// tolson.oulu.fi to terminate its + /// connection with comment "Bad Link". + /// + /// :Trillian SQUIT cm22.eng.umd.edu :Server out of control ; Command + /// from Trillian from to disconnect + /// "cm22.eng.umd.edu" from the net with + /// comment "Server out of control". + /// + SQUIT(&'a str, &'a str), + + /// 3.2.1 Join message + /// + /// Command: JOIN + /// Parameters: ( *( "," ) [ *( "," ) ] ) + /// / "0" + /// + /// The JOIN command is used by a user to request to start listening to + /// the specific channel. Servers MUST be able to parse arguments in the + /// form of a list of target, but SHOULD NOT use lists when sending JOIN + /// messages to clients. + /// + /// Once a user has joined a channel, he receives information about + /// all commands his server receives affecting the channel. This + /// includes JOIN, MODE, KICK, PART, QUIT and of course PRIVMSG/NOTICE. + /// This allows channel members to keep track of the other channel + /// members, as well as channel modes. + /// + /// If a JOIN is successful, the user receives a JOIN message as + /// confirmation and is then sent the channel's topic (using RPL_TOPIC) and + /// the list of users who are on the channel (using RPL_NAMREPLY), which + /// MUST include the user joining. + /// + /// Note that this message accepts a special argument ("0"), which is + /// a special request to leave all channels the user is currently a member + /// of. The server will process this message as if the user had sent + /// a PART command (See Section 3.2.2) for each channel he is a member + /// of. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_BANNEDFROMCHAN + /// ERR_INVITEONLYCHAN ERR_BADCHANNELKEY + /// ERR_CHANNELISFULL ERR_BADCHANMASK + /// ERR_NOSUCHCHANNEL ERR_TOOMANYCHANNELS + /// ERR_TOOMANYTARGETS ERR_UNAVAILRESOURCE + /// RPL_TOPIC + /// + /// Examples: + /// + /// JOIN #foobar ; Command to join channel #foobar. + /// + /// JOIN &foo fubar ; Command to join channel &foo using + /// key "fubar". + /// + /// JOIN #foo,&bar fubar ; Command to join channel #foo using + /// key "fubar" and &bar using no key. + /// + /// JOIN #foo,#bar fubar,foobar ; Command to join channel #foo using + /// key "fubar", and channel #bar using + /// key "foobar". + /// + /// JOIN #foo,#bar ; Command to join channels #foo and + /// #bar. + /// + /// JOIN 0 ; Leave all currently joined + /// channels. + /// + /// :WiZ!jto@tolsun.oulu.fi JOIN #Twilight_zone ; JOIN message from WiZ + /// on channel #Twilight_zone + /// + JOIN(Vec<&'a str>, Vec<&'a str>), + + /// 3.2.2 Part message + /// + /// Command: PART + /// Parameters: *( "," ) [ ] + /// + /// The PART command causes the user sending the message to be removed + /// from the list of active members for all given channels listed in the + /// parameter string. If a "Part Message" is given, this will be sent + /// instead of the default message, the nickname. This request is always + /// granted by the server. + /// + /// Servers MUST be able to parse arguments in the form of a list of + /// target, but SHOULD NOT use lists when sending PART messages to + /// clients. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_NOSUCHCHANNEL + /// ERR_NOTONCHANNEL + /// + /// Examples: + /// + /// PART #twilight_zone ; Command to leave channel + /// "#twilight_zone" + /// + /// PART #oz-ops,&group5 ; Command to leave both channels + /// "&group5" and "#oz-ops". + /// + /// :WiZ!jto@tolsun.oulu.fi PART #playzone :I lost + /// ; User WiZ leaving channel + /// "#playzone" with the message "I + /// lost". + /// + PART(Vec<&'a str>, Option<&'a str>), + + /// 3.2.3 Channel mode message + /// + /// Command: MODE + /// Parameters: *( ( "-" / "+" ) * * ) + /// + /// The MODE command is provided so that users may query and change the + /// characteristics of a channel. For more details on available modes + /// and their uses, see "Internet Relay Chat: Channel Management" [IRC- + /// CHAN]. Note that there is a maximum limit of three (3) changes per + /// command for modes that take a parameter. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_KEYSET + /// ERR_NOCHANMODES ERR_CHANOPRIVSNEEDED + /// ERR_USERNOTINCHANNEL ERR_UNKNOWNMODE + /// RPL_CHANNELMODEIS + /// RPL_BANLIST RPL_ENDOFBANLIST + /// RPL_EXCEPTLIST RPL_ENDOFEXCEPTLIST + /// RPL_INVITELIST RPL_ENDOFINVITELIST + /// RPL_UNIQOPIS + /// + /// The following examples are given to help understanding the syntax of + /// the MODE command, but refer to modes defined in "Internet Relay Chat: + /// Channel Management" [IRC-CHAN]. + /// + /// Examples: + /// + /// MODE #Finnish +imI *!*@*.fi ; Command to make #Finnish channel + /// moderated and 'invite-only' with user + /// with a hostname matching *.fi + /// automatically invited. + /// + /// MODE #Finnish +o Kilroy ; Command to give 'chanop' privileges + /// to Kilroy on channel #Finnish. + /// + /// MODE #Finnish +v Wiz ; Command to allow WiZ to speak on + /// #Finnish. + /// + /// MODE #Fins -s ; Command to remove 'secret' flag + /// from channel #Fins. + /// + /// MODE #42 +k oulu ; Command to set the channel key to + /// "oulu". + /// + /// MODE #42 -k oulu ; Command to remove the "oulu" + /// channel key on channel "#42". + /// + /// MODE #eu-opers +l 10 ; Command to set the limit for the + /// number of users on channel + /// "#eu-opers" to 10. + /// + /// :WiZ!jto@tolsun.oulu.fi MODE #eu-opers -l + /// ; User "WiZ" removing the limit for + /// the number of users on channel "#eu- + /// opers". + /// + /// MODE &oulu +b ; Command to list ban masks set for + /// the channel "&oulu". + /// + /// MODE &oulu +b *!*@* ; Command to prevent all users from + /// joining. + /// + /// MODE &oulu +b *!*@*.edu +e *!*@*.bu.edu + /// ; Command to prevent any user from a + /// hostname matching *.edu from joining, + /// except if matching *.bu.edu + /// + /// MODE #bu +be *!*@*.edu *!*@*.bu.edu + /// ; Comment to prevent any user from a + /// hostname matching *.edu from joining, + /// except if matching *.bu.edu + /// + /// MODE #meditation e ; Command to list exception masks set + /// for the channel "#meditation". + /// + /// MODE #meditation I ; Command to list invitations masks + /// set for the channel "#meditation". + /// + /// MODE !12345ircd O ; Command to ask who the channel + /// creator for "!12345ircd" is + /// + MODE(&'a str, &'a str /* *( ( "-" / "+" ) * * ) */), + + /// 3.2.4 Topic message + /// + /// Command: TOPIC + /// Parameters: [ ] + /// + /// The TOPIC command is used to change or view the topic of a channel. + /// The topic for channel is returned if there is no + /// given. If the parameter is present, the topic for that + /// channel will be changed, if this action is allowed for the user + /// requesting it. If the parameter is an empty string, the + /// topic for that channel will be removed. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_NOTONCHANNEL + /// RPL_NOTOPIC RPL_TOPIC + /// ERR_CHANOPRIVSNEEDED ERR_NOCHANMODES + /// + /// Examples: + /// + /// :WiZ!jto@tolsun.oulu.fi TOPIC #test :New topic ; User Wiz setting the + /// topic. + /// + /// TOPIC #test :another topic ; Command to set the topic on #test + /// to "another topic". + /// + /// TOPIC #test : ; Command to clear the topic on + /// #test. + /// + /// TOPIC #test ; Command to check the topic for + /// #test. + /// + TOPIC(&'a str, Option<&'a str>), + + /// 3.2.5 Names message + /// + /// Command: NAMES + /// Parameters: [ *( "," ) [ ] ] + /// + /// By using the NAMES command, a user can list all nicknames that are + /// visible to him. For more details on what is visible and what is not, + /// see "Internet Relay Chat: Channel Management" [IRC-CHAN]. The + /// parameter specifies which channel(s) to return information + /// about. There is no error reply for bad channel names. + /// + /// If no parameter is given, a list of all channels and their + /// occupants is returned. At the end of this list, a list of users who + /// are visible but either not on any channel or not on a visible channel + /// are listed as being on `channel' "*". + /// + /// If the parameter is specified, the request is forwarded to + /// that server which will generate the reply. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numerics: + /// + /// ERR_TOOMANYMATCHES ERR_NOSUCHSERVER + /// RPL_NAMREPLY RPL_ENDOFNAMES + /// + /// Examples: + /// + /// NAMES #twilight_zone,#42 ; Command to list visible users on + /// #twilight_zone and #42 + /// + /// NAMES ; Command to list all visible + /// channels and users + /// + NAMES(Option<(Vec<&'a str>, Option<&'a str>)>), + + /// 3.2.6 List message + /// + /// Command: LIST + /// Parameters: [ *( "," ) [ ] ] + /// + /// The list command is used to list channels and their topics. If the + /// parameter is used, only the status of that channel is + /// displayed. + /// + /// If the parameter is specified, the request is forwarded to + /// that server which will generate the reply. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// ERR_TOOMANYMATCHES ERR_NOSUCHSERVER + /// RPL_LIST RPL_LISTEND + /// + /// Examples: + /// + /// LIST ; Command to list all channels. + /// + /// LIST #twilight_zone,#42 ; Command to list channels + /// #twilight_zone and #42 + /// + LIST(Option<(Vec<&'a str>, Option<&'a str>)>), + + /// 3.2.7 Invite message + /// + /// Command: INVITE + /// Parameters: + /// + /// The INVITE command is used to invite a user to a channel. The + /// parameter is the nickname of the person to be invited to + /// the target channel . There is no requirement that the + /// channel the target user is being invited to must exist or be a valid + /// channel. However, if the channel exists, only members of the channel + /// are allowed to invite other users. When the channel has invite-only + /// flag set, only channel operators may issue INVITE command. + /// + /// Only the user inviting and the user being invited will receive + /// notification of the invitation. Other channel members are not + /// notified. (This is unlike the MODE changes, and is occasionally the + /// source of trouble for users.) + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_NOSUCHNICK + /// ERR_NOTONCHANNEL ERR_USERONCHANNEL + /// ERR_CHANOPRIVSNEEDED + /// RPL_INVITING RPL_AWAY + /// + /// Examples: + /// + /// :Angel!wings@irc.org INVITE Wiz #Dust + /// + /// ; Message to WiZ when he has been + /// invited by user Angel to channel + /// #Dust + /// + /// INVITE Wiz #Twilight_Zone ; Command to invite WiZ to + /// #Twilight_zone + /// + INVITE(&'a str, &'a str), + + /// 3.2.8 Kick command + /// + /// Command: KICK + /// Parameters: *( "," ) *( "," ) + /// [] + /// + /// The KICK command can be used to request the forced removal of a user + /// from a channel. It causes the to PART from the by + /// force. For the message to be syntactically correct, there MUST be + /// either one channel parameter and multiple user parameter, or as many + /// channel parameters as there are user parameters. If a "comment" is + /// given, this will be sent instead of the default message, the nickname + /// of the user issuing the KICK. + /// + /// The server MUST NOT send KICK messages with multiple channels or + /// users to clients. This is necessarily to maintain backward + /// compatibility with old client software. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS ERR_NOSUCHCHANNEL + /// ERR_BADCHANMASK ERR_CHANOPRIVSNEEDED + /// ERR_USERNOTINCHANNEL ERR_NOTONCHANNEL + /// + /// Examples: + /// + /// KICK &Melbourne Matthew ; Command to kick Matthew from + /// &Melbourne + /// + /// KICK #Finnish John :Speaking English + /// ; Command to kick John from #Finnish + /// using "Speaking English" as the + /// reason (comment). + /// + /// :WiZ!jto@tolsun.oulu.fi KICK #Finnish John + /// ; KICK message on channel #Finnish + /// from WiZ to remove John from channel + /// + KICK(Vec<&'a str>, Vec<&'a str>, Option<&'a str>), + + /// 3.3.1 Private messages + /// + /// Command: PRIVMSG + /// Parameters: + /// + /// PRIVMSG is used to send private messages between users, as well as to + /// send messages to channels. is usually the nickname of + /// the recipient of the message, or a channel name. + /// + /// The parameter may also be a host mask (#) or server + /// mask ($). In both cases the server will only send the PRIVMSG + /// to those who have a server or host matching the mask. The mask MUST + /// have at least 1 (one) "." in it and no wildcards following the last + /// ".". This requirement exists to prevent people sending messages to + /// "#*" or "$*", which would broadcast to all users. Wildcards are the + /// '*' and '?' characters. This extension to the PRIVMSG command is + /// only available to operators. + /// + /// Numeric Replies: + /// + /// ERR_NORECIPIENT ERR_NOTEXTTOSEND + /// ERR_CANNOTSENDTOCHAN ERR_NOTOPLEVEL + /// ERR_WILDTOPLEVEL ERR_TOOMANYTARGETS + /// ERR_NOSUCHNICK + /// RPL_AWAY + /// + /// Examples: + /// + /// :Angel!wings@irc.org PRIVMSG Wiz :Are you receiving this message ? + /// ; Message from Angel to Wiz. + /// + /// PRIVMSG Angel :yes I'm receiving it ! + /// ; Command to send a message to Angel. + /// + /// PRIVMSG jto@tolsun.oulu.fi :Hello ! + /// ; Command to send a message to a user + /// on server tolsun.oulu.fi with + /// username of "jto". + /// + /// PRIVMSG kalt%millennium.stealth.net@irc.stealth.net :Are you a frog? + /// ; Message to a user on server + /// irc.stealth.net with username of + /// "kalt", and connected from the host + /// millennium.stealth.net. + /// + /// PRIVMSG kalt%millennium.stealth.net :Do you like cheese? + /// ; Message to a user on the local + /// server with username of "kalt", and + /// connected from the host + /// millennium.stealth.net. + /// + /// PRIVMSG Wiz!jto@tolsun.oulu.fi :Hello ! + /// ; Message to the user with nickname + /// Wiz who is connected from the host + /// tolsun.oulu.fi and has the username + /// "jto". + /// + /// PRIVMSG $*.fi :Server tolsun.oulu.fi rebooting. + /// ; Message to everyone on a server + /// which has a name matching *.fi. + /// + /// PRIVMSG #*.edu :NSFNet is undergoing work, expect interruptions + /// ; Message to all users who come from + /// a host which has a name matching + /// *.edu. + /// + PRIVMSG(&'a str, &'a str), + + /// 3.3.2 Notice + /// + /// Command: NOTICE + /// Parameters: + /// + /// The NOTICE command is used similarly to PRIVMSG. The difference + /// between NOTICE and PRIVMSG is that automatic replies MUST NEVER be + /// sent in response to a NOTICE message. This rule applies to servers + /// too - they MUST NOT send any error reply back to the client on + /// receipt of a notice. The object of this rule is to avoid loops + /// between clients automatically sending something in response to + /// something it received. + /// + /// This command is available to services as well as users. + /// + /// This is typically used by services, and automatons (clients with + /// either an AI or other interactive program controlling their actions). + /// + /// See PRIVMSG for more details on replies and examples. + /// + NOTICE(&'a str, &'a str), + + /// 3.4.1 Motd message + /// + /// Command: MOTD + /// Parameters: [ ] + /// + /// The MOTD command is used to get the "Message Of The Day" of the given + /// server, or current server if is omitted. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// RPL_MOTDSTART RPL_MOTD + /// RPL_ENDOFMOTD ERR_NOMOTD + /// + MOTD(Option<&'a str>), + + /// 3.4.2 Lusers message + /// + /// Command: LUSERS + /// Parameters: [ [ ] ] + /// + /// The LUSERS command is used to get statistics about the size of the + /// IRC network. If no parameter is given, the reply will be about the + /// whole net. If a is specified, then the reply will only + /// concern the part of the network formed by the servers matching the + /// mask. Finally, if the parameter is specified, the request + /// is forwarded to that server which will generate the reply. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// RPL_LUSERCLIENT RPL_LUSEROP + /// RPL_LUSERUNKOWN RPL_LUSERCHANNELS + /// RPL_LUSERME ERR_NOSUCHSERVER + /// + LUSERS(Option<(&'a str, Option<&'a str>)>), + + /// 3.4.3 Version message + /// + /// Command: VERSION + /// Parameters: [ ] + /// + /// The VERSION command is used to query the version of the server + /// program. An optional parameter is used to query the version + /// of the server program which a client is not directly connected to. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER RPL_VERSION + /// + /// Examples: + /// + /// VERSION tolsun.oulu.fi ; Command to check the version of + /// server "tolsun.oulu.fi". + /// + VERSION(Option<&'a str>), + + /// 3.4.4 Stats message + /// + /// Command: STATS + /// Parameters: [ [ ] ] + /// + /// The stats command is used to query statistics of certain server. If + /// parameter is omitted, only the end of stats reply is sent + /// back. + /// + /// A query may be given for any single letter which is only checked by + /// the destination server and is otherwise passed on by intermediate + /// servers, ignored and unaltered. + /// + /// Wildcards are allowed in the parameter. + /// + /// Except for the ones below, the list of valid queries is + /// implementation dependent. The standard queries below SHOULD be + /// supported by the server: + /// + /// l - returns a list of the server's connections, showing how + /// long each connection has been established and the + /// traffic over that connection in Kbytes and messages for + /// each direction; + /// m - returns the usage count for each of commands supported + /// by the server; commands for which the usage count is + /// zero MAY be omitted; + /// o - returns a list of configured privileged users, + /// operators; + /// u - returns a string showing how long the server has been + /// up. + /// + /// It is also RECOMMENDED that client and server access configuration be + /// published this way. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER + /// RPL_STATSLINKINFO RPL_STATSUPTIME + /// RPL_STATSCOMMANDS RPL_STATSOLINE + /// RPL_ENDOFSTATS + /// + /// Examples: + /// + /// STATS m ; Command to check the command usage + /// for the server you are connected to + /// + STATS(Option<(&'a str, Option<&'a str>)>), + + /// 3.4.5 Links message + /// + /// Command: LINKS + /// Parameters: [ [ ] ] + /// + /// With LINKS, a user can list all servernames, which are known by the + /// server answering the query. The returned list of servers MUST match + /// the mask, or if no mask is given, the full list is returned. + /// + /// If is given in addition to , the LINKS + /// command is forwarded to the first server found that matches that name + /// (if any), and that server is then required to answer the query. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER + /// RPL_LINKS RPL_ENDOFLINKS + /// + /// Examples: + /// + /// LINKS *.au ; Command to list all servers which + /// have a name that matches *.au; + /// + /// LINKS *.edu *.bu.edu ; Command to list servers matching + /// *.bu.edu as seen by the first server + /// matching *.edu. + /// + LINKS(Option<(Option<&'a str>, &'a str)>), + + /// 3.4.6 Time message + /// + /// Command: TIME + /// Parameters: [ ] + /// + /// The time command is used to query local time from the specified + /// server. If the parameter is not given, the server receiving + /// the command must reply to the query. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER RPL_TIME + /// + /// Examples: + /// TIME tolsun.oulu.fi ; check the time on the server + /// "tolson.oulu.fi" + /// + TIME(Option<&'a str>), + + /// 3.4.7 Connect message + /// + /// Command: CONNECT + /// Parameters: [ ] + /// + /// The CONNECT command can be used to request a server to try to + /// establish a new connection to another server immediately. CONNECT is + /// a privileged command and SHOULD be available only to IRC Operators. + /// If a is given and its mask doesn't match name of the + /// parsing server, the CONNECT attempt is sent to the first match of + /// remote server. Otherwise the CONNECT attempt is made by the server + /// processing the request. + /// + /// The server receiving a remote CONNECT command SHOULD generate a + /// WALLOPS message describing the source and target of the request. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER ERR_NOPRIVILEGES + /// ERR_NEEDMOREPARAMS + /// + /// Examples: + /// + /// CONNECT tolsun.oulu.fi 6667 ; Command to attempt to connect local + /// server to tolsun.oulu.fi on port 6667 + /// + CONNECT(&'a str, i16, Option<&'a str>), + + /// 3.4.8 Trace message + /// + /// Command: TRACE + /// Parameters: [ ] + /// + /// TRACE command is used to find the route to specific server and + /// information about its peers. Each server that processes this command + /// MUST report to the sender about it. The replies from pass-through + /// links form a chain, which shows route to destination. After sending + /// this reply back, the query MUST be sent to the next server until + /// given server is reached. + /// + /// TRACE command is used to find the route to specific server. Each + /// server that processes this message MUST tell the sender about it by + /// sending a reply indicating it is a pass-through link, forming a chain + /// of replies. After sending this reply back, it MUST then send the + /// TRACE message to the next server until given server is reached. If + /// the parameter is omitted, it is RECOMMENDED that TRACE + /// command sends a message to the sender telling which servers the local + /// server has direct connection to. + /// + /// If the destination given by is an actual server, the + /// destination server is REQUIRED to report all servers, services and + /// operators which are connected to it; if the command was issued by an + /// operator, the server MAY also report all users which are connected to + /// it. If the destination given by is a nickname, then only a + /// reply for that nickname is given. If the parameter is + /// omitted, it is RECOMMENDED that the TRACE command is parsed as + /// targeted to the processing server. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER + /// + /// If the TRACE message is destined for another server, all + /// intermediate servers must return a RPL_TRACELINK reply to indicate + /// that the TRACE passed through it and where it is going next. + /// + /// RPL_TRACELINK + /// + /// A TRACE reply may be composed of any number of the following + /// numeric replies. + /// + /// RPL_TRACECONNECTING RPL_TRACEHANDSHAKE + /// RPL_TRACEUNKNOWN RPL_TRACEOPERATOR + /// RPL_TRACEUSER RPL_TRACESERVER + /// RPL_TRACESERVICE RPL_TRACENEWTYPE + /// RPL_TRACECLASS RPL_TRACELOG + /// RPL_TRACEEND + /// + /// Examples: + /// + /// TRACE *.oulu.fi ; TRACE to a server matching + /// *.oulu.fi + /// + TRACE(Option<&'a str>), + + /// 3.4.9 Admin command + /// + /// Command: ADMIN + /// Parameters: [ ] + /// + /// The admin command is used to find information about the administrator + /// of the given server, or current server if parameter is + /// omitted. Each server MUST have the ability to forward ADMIN messages + /// to other servers. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER + /// RPL_ADMINME RPL_ADMINLOC1 + /// RPL_ADMINLOC2 RPL_ADMINEMAIL + /// + /// Examples: + /// + /// ADMIN tolsun.oulu.fi ; request an ADMIN reply from + /// tolsun.oulu.fi + /// + /// ADMIN syrk ; ADMIN request for the server to + /// which the user syrk is connected + /// + ADMIN(Option<&'a str>), + + /// 3.4.10 Info command + /// + /// Command: INFO + /// Parameters: [ ] + /// + /// The INFO command is REQUIRED to return information describing the + /// server: its version, when it was compiled, the patchlevel, when it + /// was started, and any other miscellaneous information which may be + /// considered to be relevant. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER + /// RPL_INFO RPL_ENDOFINFO + /// + /// Examples: + /// + /// INFO csd.bu.edu ; request an INFO reply from + /// csd.bu.edu + /// + /// INFO Angel ; request info from the server that + /// Angel is connected to. + /// + INFO(Option<&'a str>), + + /// 3.5.1 Servlist message + /// + /// Command: SERVLIST + /// Parameters: [ [ ] ] + /// + /// The SERVLIST command is used to list services currently connected to + /// the network and visible to the user issuing the command. The + /// optional parameters may be used to restrict the result of the query + /// (to matching services names, and services type). + /// + /// Numeric Replies: + /// + /// RPL_SERVLIST RPL_SERVLISTEND + /// + SERVLIST(Option<(&'a str, Option<&'a str>)>), + + /// 3.5.2 Squery + /// + /// Command: SQUERY + /// Parameters: + /// + /// The SQUERY command is used similarly to PRIVMSG. The only difference + /// is that the recipient MUST be a service. This is the only way for a + /// text message to be delivered to a service. + /// + /// See PRIVMSG for more details on replies and example. + /// + /// Examples: + /// + /// SQUERY irchelp :HELP privmsg + /// ; Message to the service with + /// nickname irchelp. + /// + /// SQUERY dict@irc.fr :fr2en blaireau + /// ; Message to the service with name + /// dict@irc.fr. + /// + SQUERY(&'a str, &'a str), + + /// 3.6.1 Who query + /// + /// Command: WHO + /// Parameters: [ [ "o" ] ] + /// + /// The WHO command is used by a client to generate a query which returns + /// a list of information which 'matches' the parameter given by + /// the client. In the absence of the parameter, all visible + /// (users who aren't invisible (user mode +i) and who don't have a + /// common channel with the requesting client) are listed. The same + /// result can be achieved by using a of "0" or any wildcard which + /// will end up matching every visible user. + /// + /// The passed to WHO is matched against users' host, server, real + /// name and nickname if the channel cannot be found. + /// + /// If the "o" parameter is passed only operators are returned according + /// to the supplied. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER + /// RPL_WHOREPLY RPL_ENDOFWHO + /// + /// Examples: + /// + /// WHO *.fi ; Command to list all users who match + /// against "*.fi". + /// + /// WHO jto* o ; Command to list all users with a + /// match against "jto*" if they are an + /// operator. + /// + WHO(&'a str, bool), + + /// 3.6.2 Whois query + /// + /// Command: WHOIS + /// Parameters: [ ] *( "," ) + /// + /// This command is used to query information about particular user. + /// The server will answer this command with several numeric messages + /// indicating different statuses of each user which matches the mask (if + /// you are entitled to see them). If no wildcard is present in the + /// , any information about that nick which you are allowed to see + /// is presented. + /// + /// If the parameter is specified, it sends the query to a + /// specific server. It is useful if you want to know how long the user + /// in question has been idle as only local server (i.e., the server the + /// user is directly connected to) knows that information, while + /// everything else is globally known. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER ERR_NONICKNAMEGIVEN + /// RPL_WHOISUSER RPL_WHOISCHANNELS + /// RPL_WHOISCHANNELS RPL_WHOISSERVER + /// RPL_AWAY RPL_WHOISOPERATOR + /// RPL_WHOISIDLE ERR_NOSUCHNICK + /// RPL_ENDOFWHOIS + /// + /// Examples: + /// + /// WHOIS wiz ; return available user information + /// about nick WiZ + /// + /// WHOIS eff.org trillian ; ask server eff.org for user + /// information about trillian + /// + WHOIS(Option<&'a str>, Vec<&'a str>), + + /// 3.6.3 Whowas + /// + /// Command: WHOWAS + /// Parameters: *( "," ) [ [ ] ] + /// + /// Whowas asks for information about a nickname which no longer exists. + /// This may either be due to a nickname change or the user leaving IRC. + /// In response to this query, the server searches through its nickname + /// history, looking for any nicks which are lexically the same (no wild + /// card matching here). The history is searched backward, returning the + /// most recent entry first. If there are multiple entries, up to + /// replies will be returned (or all of them if no + /// parameter is given). If a non-positive number is passed as being + /// , then a full search is done. + /// + /// Wildcards are allowed in the parameter. + /// + /// Numeric Replies: + /// + /// ERR_NONICKNAMEGIVEN ERR_WASNOSUCHNICK + /// RPL_WHOWASUSER RPL_WHOISSERVER + /// RPL_ENDOFWHOWAS + /// + /// Examples: + /// + /// WHOWAS Wiz ; return all information in the nick + /// history about nick "WiZ"; + /// + /// WHOWAS Mermaid 9 ; return at most, the 9 most recent + /// entries in the nick history for + /// "Mermaid"; + /// + /// WHOWAS Trillian 1 *.edu ; return the most recent history for + /// "Trillian" from the first server + /// found to match "*.edu". + /// + WHOWAS(Vec<&'a str>, Option<(&'a str, Option<&'a str>)>), + + /// 3.7.1 Kill message + /// + /// Command: KILL + /// Parameters: + /// + /// The KILL command is used to cause a client-server connection to be + /// closed by the server which has the actual connection. Servers + /// generate KILL messages on nickname collisions. It MAY also be + /// available available to users who have the operator status. + /// + /// Clients which have automatic reconnect algorithms effectively make + /// this command useless since the disconnection is only brief. It does + /// however break the flow of data and can be used to stop large amounts + /// of 'flooding' from abusive users or accidents. Abusive users usually + /// don't care as they will reconnect promptly and resume their abusive + /// behaviour. To prevent this command from being abused, any user may + /// elect to receive KILL messages generated for others to keep an 'eye' + /// on would be trouble spots. + /// + /// In an arena where nicknames are REQUIRED to be globally unique at all + /// times, KILL messages are sent whenever 'duplicates' are detected + /// (that is an attempt to register two users with the same nickname) in + /// the hope that both of them will disappear and only 1 reappear. + /// + /// When a client is removed as the result of a KILL message, the server + /// SHOULD add the nickname to the list of unavailable nicknames in an + /// attempt to avoid clients to reuse this name immediately which is + /// usually the pattern of abusive behaviour often leading to useless + /// "KILL loops". See the "IRC Server Protocol" document [IRC-SERVER] + /// for more information on this procedure. + /// + /// The comment given MUST reflect the actual reason for the KILL. For + /// server-generated KILLs it usually is made up of details concerning + /// the origins of the two conflicting nicknames. For users it is left + /// up to them to provide an adequate reason to satisfy others who see + /// it. To prevent/discourage fake KILLs from being generated to hide + /// the identify of the KILLer, the comment also shows a 'kill-path' + /// which is updated by each server it passes through, each prepending + /// its name to the path. + /// + /// Numeric Replies: + /// + /// ERR_NOPRIVILEGES ERR_NEEDMOREPARAMS + /// ERR_NOSUCHNICK ERR_CANTKILLSERVER + /// + /// NOTE: + /// It is RECOMMENDED that only Operators be allowed to kill other users + /// with KILL command. This command has been the subject of many + /// controversies over the years, and along with the above + /// recommendation, it is also widely recognized that not even operators + /// should be allowed to kill users on remote servers. + /// + KILL(&'a str, &'a str), + + /// 3.7.2 Ping message + /// + /// Command: PING + /// Parameters: [ ] + /// + /// The PING command is used to test the presence of an active client or + /// server at the other end of the connection. Servers send a PING + /// message at regular intervals if no other activity detected coming + /// from a connection. If a connection fails to respond to a PING + /// message within a set amount of time, that connection is closed. A + /// PING message MAY be sent even if the connection is active. + /// + /// When a PING message is received, the appropriate PONG message MUST be + /// sent as reply to (server which sent the PING message out) + /// as soon as possible. If the parameter is specified, it + /// represents the target of the ping, and the message gets forwarded + /// there. + /// + /// Numeric Replies: + /// + /// ERR_NOORIGIN ERR_NOSUCHSERVER + /// + /// Examples: + /// + /// PING tolsun.oulu.fi ; Command to send a PING message to + /// server + /// + /// PING WiZ tolsun.oulu.fi ; Command from WiZ to send a PING + /// message to server "tolsun.oulu.fi" + /// + /// PING :irc.funet.fi ; Ping message sent by server + /// "irc.funet.fi" + /// + PING(&'a str, Option<&'a str>), + + /// 3.7.3 Pong message + /// + /// Command: PONG + /// Parameters: [ ] + /// + /// PONG message is a reply to ping message. If parameter is + /// given, this message MUST be forwarded to given target. The + /// parameter is the name of the entity who has responded to PING message + /// and generated this message. + /// + /// Numeric Replies: + /// + /// ERR_NOORIGIN ERR_NOSUCHSERVER + /// + /// Example: + /// + /// PONG csd.bu.edu tolsun.oulu.fi ; PONG message from csd.bu.edu to + /// tolsun.oulu.fi + /// + PONG(&'a str, Option<&'a str>), + + /// 3.7.4 Error + /// + /// Command: ERROR + /// Parameters: + /// + /// The ERROR command is for use by servers when reporting a serious or + /// fatal error to its peers. It may also be sent from one server to + /// another but MUST NOT be accepted from any normal unknown clients. + /// + /// Only an ERROR message SHOULD be used for reporting errors which occur + /// with a server-to-server link. An ERROR message is sent to the server + /// at the other end (which reports it to appropriate local users and + /// logs) and to appropriate local users and logs. It is not to be + /// passed onto any other servers by a server if it is received from a + /// server. + /// + /// The ERROR message is also used before terminating a client + /// connection. + /// + /// When a server sends a received ERROR message to its operators, the + /// message SHOULD be encapsulated inside a NOTICE message, indicating + /// that the client was not responsible for the error. + /// + /// Numerics: + /// + /// None. + /// + /// Examples: + /// + /// ERROR :Server *.fi already exists ; ERROR message to the other server + /// which caused this error. + /// + /// NOTICE WiZ :ERROR from csd.bu.edu -- Server *.fi already exists + /// ; Same ERROR message as above but + /// sent to user WiZ on the other server. + /// + ERROR(&'a str), + + /// 4.1 Away + /// + /// Command: AWAY + /// Parameters: [ ] + /// + /// With the AWAY command, clients can set an automatic reply string for + /// any PRIVMSG commands directed at them (not to a channel they are on). + /// The server sends an automatic reply to the client sending the PRIVMSG + /// command. The only replying server is the one to which the sending + /// client is connected to. + /// + /// The AWAY command is used either with one parameter, to set an AWAY + /// message, or with no parameters, to remove the AWAY message. + /// + /// Because of its high cost (memory and bandwidth wise), the AWAY + /// message SHOULD only be used for client-server communication. A + /// server MAY choose to silently ignore AWAY messages received from + /// other servers. To update the away status of a client across servers, + /// the user mode 'a' SHOULD be used instead. (See Section 3.1.5) + /// + /// Numeric Replies: + /// + /// RPL_UNAWAY RPL_NOWAWAY + /// + /// Example: + /// + /// AWAY :Gone to lunch. Back in 5 ; Command to set away message to + /// "Gone to lunch. Back in 5". + /// + AWAY(Option<&'a str>), + + /// 4.2 Rehash message + /// + /// Command: REHASH + /// Parameters: None + /// + /// The rehash command is an administrative command which can be used by + /// an operator to force the server to re-read and process its + /// configuration file. + /// + /// Numeric Replies: + /// + /// RPL_REHASHING ERR_NOPRIVILEGES + /// + /// + /// Example: + /// + /// REHASH ; message from user with operator + /// status to server asking it to reread + /// its configuration file. + /// + REHASH, + + /// 4.3 Die message + /// + /// Command: DIE + /// Parameters: None + /// + /// An operator can use the DIE command to shutdown the server. This + /// message is optional since it may be viewed as a risk to allow + /// arbitrary people to connect to a server as an operator and execute + /// this command. + /// + /// The DIE command MUST always be fully processed by the server to which + /// the sending client is connected and MUST NOT be passed onto other + /// connected servers. + /// + /// Numeric Replies: + /// + /// ERR_NOPRIVILEGES + /// + /// Example: + /// + /// DIE ; no parameters required. + /// + DIE, + + /// 4.4 Restart message + /// + /// Command: RESTART + /// Parameters: None + /// + /// An operator can use the restart command to force the server to + /// restart itself. This message is optional since it may be viewed as a + /// risk to allow arbitrary people to connect to a server as an operator + /// and execute this command, causing (at least) a disruption to service. + /// + /// The RESTART command MUST always be fully processed by the server to + /// which the sending client is connected and MUST NOT be passed onto + /// other connected servers. + /// + /// Numeric Replies: + /// + /// ERR_NOPRIVILEGES + /// + /// Example: + /// + /// RESTART ; no parameters required. + /// + RESTART, + + /// 4.5 Summon message + /// + /// Command: SUMMON + /// Parameters: [ [ ] ] + /// + /// The SUMMON command can be used to give users who are on a host + /// running an IRC server a message asking them to please join IRC. This + /// message is only sent if the target server (a) has SUMMON enabled, (b) + /// the user is logged in and (c) the server process can write to the + /// user's tty (or similar). + /// + /// If no parameter is given it tries to summon from the + /// server the client is connected to is assumed as the target. + /// + /// If summon is not enabled in a server, it MUST return the + /// ERR_SUMMONDISABLED numeric. + /// + /// Numeric Replies: + /// + /// ERR_NORECIPIENT ERR_FILEERROR + /// ERR_NOLOGIN ERR_NOSUCHSERVER + /// ERR_SUMMONDISABLED RPL_SUMMONING + /// + /// Examples: + /// + /// SUMMON jto ; summon user jto on the server's + /// host + /// + /// SUMMON jto tolsun.oulu.fi ; summon user jto on the host which a + /// server named "tolsun.oulu.fi" is + /// running. + /// + SUMMON(&'a str, Option<(&'a str, Option<&'a str>)>), + + /// 4.6 Users + /// + /// Command: USERS + /// Parameters: [ ] + /// + /// The USERS command returns a list of users logged into the server in a + /// format similar to the UNIX commands who(1), rusers(1) and finger(1). + /// If disabled, the correct numeric MUST be returned to indicate this. + /// + /// Because of the security implications of such a command, it SHOULD be + /// disabled by default in server implementations. Enabling it SHOULD + /// require recompiling the server or some equivalent change rather than + /// simply toggling an option and restarting the server. The procedure + /// to enable this command SHOULD also include suitable large comments. + /// + /// Numeric Replies: + /// + /// ERR_NOSUCHSERVER ERR_FILEERROR + /// RPL_USERSSTART RPL_USERS + /// RPL_NOUSERS RPL_ENDOFUSERS + /// ERR_USERSDISABLED + /// + /// Disabled Reply: + /// + /// ERR_USERSDISABLED + /// + /// Example: + /// + /// USERS eff.org ; request a list of users logged in + /// on server eff.org + /// + USERS(Option<&'a str>), + + /// 4.7 Operwall message + /// + /// Command: WALLOPS + /// Parameters: + /// + /// The WALLOPS command is used to send a message to all currently + /// connected users who have set the 'w' user mode for themselves. (See + /// Section 3.1.5 "User modes"). + /// + /// After implementing WALLOPS as a user command it was found that it was + /// often and commonly abused as a means of sending a message to a lot of + /// people. Due to this, it is RECOMMENDED that the implementation of + /// WALLOPS allows and recognizes only servers as the originators of + /// WALLOPS. + /// + /// Numeric Replies: + /// + /// ERR_NEEDMOREPARAMS + /// + /// Example: + /// + /// :csd.bu.edu WALLOPS :Connect '*.uiuc.edu 6667' from Joshua ; WALLOPS + /// message from csd.bu.edu announcing a + /// CONNECT message it received from + /// Joshua and acted upon. + /// + WALLOPS(&'a str), + + /// 4.8 Userhost message + /// + /// Command: USERHOST + /// Parameters: *( SPACE ) + /// + /// The USERHOST command takes a list of up to 5 nicknames, each + /// separated by a space character and returns a list of information + /// about each nickname that it found. The returned list has each reply + /// separated by a space. + /// + /// Numeric Replies: + /// + /// RPL_USERHOST ERR_NEEDMOREPARAMS + /// + /// Example: + /// + /// USERHOST Wiz Michael syrk ; USERHOST request for information on + /// nicks "Wiz", "Michael", and "syrk" + /// + /// :ircd.stealth.net 302 yournick :syrk=+syrk@millennium.stealth.net + /// ; Reply for user syrk + /// + USERHOST(Vec<&'a str>), +} + +impl<'a> Command<'a> { + fn to_name(&self) -> &'static str { + match self { + PASS => "PING", + NICK => "NICK", + USER => "USER", + OPER => "1004", + MODE => "1005", + SERVICE => "1006", + QUIT => "1007", + SQUIT => "1008", + JOIN => "1009", + PART => "1010", + TOPIC => "1011", + NAMES => "1012", + LIST => "1013", + INVITE => "1014", + KICK => "1015", + PRIVMSG => "1016", + NOTICE => "1017", + MOTD => "1018", + LUSERS => "1019", + VERSION => "1020", + STATS => "1021", + LINKS => "1022", + TIME => "1023", + CONNECT => "1024", + TRACE => "1025", + ADMIN => "1026", + INFO => "1027", + SERVLIST => "1028", + SQUERY => "1029", + WHO => "1030", + WHOIS => "1031", + WHOWAS => "1032", + KILL => "1033", + PING => "1034", + PONG => "1035", + ERROR => "1036", + AWAY => "1037", + REHASH => "1038", + DIE => "1039", + RESTART => "1040", + SUMMON => "1041", + USERS => "1042", + WALLOPS => "1043", + USERHOST => "1044", + ISON => "1045", +/* + RPL_WELCOME => "001", + RPL_YOURHOST => "002", + RPL_CREATED => "003", + RPL_MYINFO => "004", + RPL_BOUNCE => "005", + RPL_USERHOST => "302", + RPL_ISON => "303", + RPL_AWAY => "301", + RPL_UNAWAY => "305", + RPL_NOWAWAY => "306", + RPL_WHOISUSER => "311", + RPL_WHOISSERVER => "312", + RPL_WHOISOPERATOR => "313", + RPL_WHOISIDLE => "317", + RPL_ENDOFWHOIS => "318", + RPL_WHOISCHANNELS => "319", + RPL_WHOWASUSER => "314", + RPL_ENDOFWHOWAS => "369", + RPL_LISTSTART => "321", + RPL_LIST => "322", + RPL_LISTEND => "323", + RPL_UNIQOPIS => "325", + RPL_CHANNELMODEIS => "324", + RPL_NOTOPIC => "331", + RPL_TOPIC => "332", + RPL_INVITING => "341", + RPL_SUMMONING => "342", + RPL_INVITELIST => "346", + RPL_ENDOFINVITELIST => "347", + RPL_EXCEPTLIST => "348", + RPL_ENDOFEXCEPTLIST => "349", + RPL_VERSION => "351", + RPL_WHOREPLY => "352", + RPL_ENDOFWHO => "315", + RPL_NAMREPLY => "353", + RPL_ENDOFNAMES => "366", + RPL_LINKS => "364", + RPL_ENDOFLINKS => "365", + RPL_BANLIST => "367", + RPL_ENDOFBANLIST => "368", + RPL_INFO => "371", + RPL_ENDOFINFO => "374", + RPL_MOTDSTART => "375", + RPL_MOTD => "372", + RPL_ENDOFMOTD => "376", + RPL_YOUREOPER => "381", + RPL_REHASHING => "382", + RPL_YOURESERVICE => "383", + RPL_TIME => "391", + RPL_USERSSTART => "392", + RPL_USERS => "393", + RPL_ENDOFUSERS => "394", + RPL_NOUSERS => "395", + RPL_TRACELINK => "200", + RPL_TRACECONNECTING => "201", + RPL_TRACEHANDSHAKE => "202", + RPL_TRACEUNKNOWN => "203", + RPL_TRACEOPERATOR => "204", + RPL_TRACEUSER => "205", + RPL_TRACESERVER => "206", + RPL_TRACESERVICE => "207", + RPL_TRACENEWTYPE => "208", + RPL_TRACECLASS => "209", + RPL_TRACERECONNECT => "210", + RPL_TRACELOG => "261", + RPL_TRACEEND => "262", + RPL_STATSLINKINFO => "211", + RPL_STATSCOMMAND => "212", + RPL_ENDOFSTATS => "219", + RPL_STATSUPTIME => "242", + RPL_STATSOLINE => "243", + RPL_UMODEIS => "221", + RPL_SERVLIST => "234", + RPL_SERVLISTEND => "235", + RPL_LUSERCLIENT => "251", + RPL_LUSEROP => "252", + RPL_LUSERUNKNOWN => "253", + RPL_LUSERCHANNELS => "254", + RPL_LUSERME => "255", + RPL_ADMINME => "256", + RPL_ADMINLOC1 => "257", + RPL_ADMINLOC2 => "258", + RPL_ADMINEMAIL => "259", + RPL_TRYAGAIN => "263", + + ERR_NOSUCHNICK => "401", + ERR_NOSUCHSERVER => "402", + ERR_NOSUCHCHANNEL => "403", + ERR_CANNOTSENDTOCHAN => "404", + ERR_TOOMANYCHANNELS => "405", + ERR_WASNOSUCHNICK => "406", + ERR_TOOMANYTARGETS => "407", + ERR_NOSUCHSERVICE => "408", + ERR_NOORIGIN => "409", + ERR_NORECIPIENT => "411", + ERR_NOTEXTTOSEND => "412", + ERR_NOTOPLEVEL => "413", + ERR_WILDTOPLEVEL => "414", + ERR_BADMASK => "415", + ERR_UNKNOWNCOMMAND => "421", + ERR_NOMOTD => "422", + ERR_NOADMININFO => "423", + ERR_FILEERROR => "424", + ERR_NONICKNAMEGIVEN => "431", + ERR_ERRONEUSNICKNAME => "432", + ERR_NICKNAMEINUSE => "433", + ERR_NICKCOLLISION => "436", + ERR_UNAVAILRESOURCE => "437", + ERR_USERNOTINCHANNEL => "441", + ERR_NOTONCHANNEL => "442", + ERR_USERONCHANNEL => "443", + ERR_NOLOGIN => "444", + ERR_SUMMONDISABLED => "445", + ERR_USERSDISABLED => "446", + ERR_NOTREGISTERED => "451", + ERR_NEEDMOREPARAMS => "461", + ERR_ALREADYREGISTERED => "462", + ERR_NOPERMFORHOST => "463", + ERR_PASSWDMISMATCH => "464", + ERR_YOUREBANNEDCREEP => "465", + ERR_YOUWILLBEBANNED => "466", + ERR_KEYSET => "467", + ERR_CHANNELISFULL => "471", + ERR_UNKNOWNMODE => "472", + ERR_INVITEONLYCHAN => "473", + ERR_BANNEDFROMCHAN => "474", + ERR_BADCHANNELKEY => "475", + ERR_BADCHANMASK => "476", + ERR_NOCHANMODES => "477", + ERR_BANLISTFULL => "478", + ERR_NOPRIVILEGES => "481", + ERR_CHANOPRIVSNEEDED => "482", + ERR_CANTKILLSERVER => "483", + ERR_RESTRICTED => "484", + ERR_UNIQOPPRIVSNEEDED => "485", + ERR_NOOPERHOST => "491", + ERR_UMODEUNKNOWNFLAG => "501",*/ + } + } +} + +impl<'a> Command<'a> { + pub fn from_message(msg: &'a Message) -> Option> { + match &msg.command.as_ref()[..] { + "NOTICE" => msg.content.get(0).and_then(|c| msg.content.get(1).map(|t| + Command::NOTICE { to: Cow::Borrowed(&t), content: Cow::Borrowed(&c) })), + "PING" => msg.content.get(0).and_then(|s1| msg.content.get(1).map(|s2| + Command::PING { server1: Some(Cow::Borrowed(&s1)), server2: Some(Cow::Borrowed(&s2)) })), + "001" => Some(Command::RPL_WELCOME), + "002" => Some(Command::RPL_YOURHOST), + "003" => Some(Command::RPL_CREATED), + "004" => Some(Command::RPL_MYINFO), + "451" => Some(Command::ErrNotRegistered), + _ => unimplemented!() + } + } + + pub fn to_message(&'a self) -> Message { + match self { + &Command::PING { ref server1, ref server2 } => { + let mut c = Vec::new(); + if let &Some(ref s) = server1 { c.push(s.clone()) } + if let &Some(ref s) = server2 { c.push(s.clone()) } + Message::new(None, Cow::Owned("PING".to_owned()), c, None, MsgType::Irc) + }, + &Command::PONG { ref server1, ref server2 } => { + let mut c = Vec::new(); + if let &Some(ref s) = server1 { c.push(s.clone()) } + if let &Some(ref s) = server2 { c.push(s.clone()) } + Message::new(None, Cow::Owned("PONG".to_owned()), c, None, MsgType::Irc) + }, + _ => unimplemented!() + } + } + + //pub fn is_reply(&self) -> bool { let i = *self as uint; i >= 200 && i <= 399 } + //pub fn is_error(&self) -> bool { let i = *self as uint; i >= 400 && i <= 599 } +} + diff --git a/src/lib.rs b/src/lib.rs index 577770d..f37c9a4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,11 +6,12 @@ extern crate regex; extern crate log; extern crate eventual; -pub mod server; +// pub mod server; pub mod color; pub mod ident; pub mod callback; pub mod message; +// pub mod command; use std::io; use std::result; diff --git a/src/message.rs b/src/message.rs index f2cd9d3..2341609 100644 --- a/src/message.rs +++ b/src/message.rs @@ -2,7 +2,10 @@ use std::str::FromStr; use std::string::{ ToString }; -use std::borrow::{ Cow, ToOwned }; +use std::borrow::{ ToOwned }; +use std::ops::Range; + +use ::IrscError; #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] pub enum MsgType { @@ -13,18 +16,20 @@ pub enum MsgType { Ctcp } -#[derive(Debug, PartialEq, Eq, Hash, Clone)] -pub struct Message<'a> { - pub prefix: Option>, - pub command: Cow<'a, String>, - pub content: Vec>, - pub suffix: Option>, +#[derive(Debug, PartialEq, Eq, Clone)] +pub struct Message { + pub source: String, + prefix: Option>, + command: Range, + content: Vec>, + suffix: Option>, pub msg_type: MsgType } -impl<'a> Message<'a> { - pub fn new(prefix: Option>, command: Cow<'a, String>, content: Vec>, suffix: Option>, msg_type: MsgType) -> Message<'a> { +impl Message { + pub fn new(source: String, prefix: Option>, command: Range, content: Vec>, suffix: Option>, msg_type: MsgType) -> Message { Message { + source: source, prefix: prefix, command: command, content: content, @@ -32,60 +37,111 @@ impl<'a> Message<'a> { msg_type: msg_type } } + + #[allow(unused_assignments)] + pub fn format(prefix: Option<&str>, command: &str, content: Vec<&str>, suffix: Option<&str>, msg_type: MsgType) -> Message { + let mut s = String::with_capacity(512); + let mut i = 0; + + let mut i_prefix = None; + if let Some(ref p) = prefix { + i_prefix = Some((i + 1) as u16..(i + 2 + p.len()) as u16); + s.push(':'); + s.push_str(p); + s.push(' '); + i += 2 + p.len(); + } + + let i_command = i as u16..(i + command.len()) as u16; + s.push_str(command); + s.push(' '); + i += 1 + command.len(); + + let mut i_content = Vec::new(); + for part in content.iter() { + i_content.push(i as u16..(i + part.len()) as u16); + s.push_str(part); + s.push(' '); + i += 1 + part.len(); + } + + let mut i_suffix = None; + if let Some(ref p) = suffix { + s.push(':'); + if let MsgType::Ctcp = msg_type { s.push('\u{1}'); i += 1; } + let n = i; + s.push_str(p); + if let MsgType::Ctcp = msg_type { s.push('\u{1}'); i += 1; } + i_suffix = Some(n as u16..(n + p.len()) as u16); + i += 1 + p.len(); + } + + s.push_str("\r\n"); + i += 2; + + Message::new(s, i_prefix, i_command, i_content, i_suffix, msg_type) + } + + pub fn range(&self, r: &Range) -> &str { + self.source.slice_chars(r.start as usize, r.end as usize) + } + + pub fn prefix(&self) -> Option<&str> { self.prefix.as_ref().map(|r| self.range(r)) } + pub fn command(&self) -> &str { self.range(&self.command) } + pub fn content(&self) -> Vec<&str> { self.content.iter().map(|r| self.range(&r)).collect() } + pub fn suffix(&self) -> Option<&str> { self.suffix.as_ref().map(|r| self.range(r)) } } -impl<'a> FromStr for Message<'a> { - type Err = ::IrscError; - fn from_str(i: &str) -> Result, ::IrscError> { +impl FromStr for Message { + type Err = IrscError; + fn from_str(i: &str) -> Result { info!("Attempting to parse message: {}", i); let len = i.len(); - let mut s = i; + let mut s = 0; - let prefix = if len >= 1 && s.chars().next() == Some(':') { - s.find(' ').map(|i| { - let p = s.slice_chars(1, i).to_owned(); - s = &s[i + 1..]; - p - }) + let prefix = if len >= 1 && i[s..].chars().next() == Some(':') { + i[s..].find(' ').map(|i| 1u16..i as u16) } else { None }; - let command = s.find(' ').map(|i| { - let p = s.slice_chars(0, i).to_owned(); - s = &s[i..]; + let command = i[s..].find(' ').map(|n| { + let p = s as u16..n as u16; + s = n; p - }).map(|c| c.parse()).map(|c| Some(Cow::Owned(c.unwrap()))); + }); // TODO: Parse last non-suffix argument as suffix if no suffix // with colon is available. let mut content = Vec::with_capacity(15); let mut suffix = None; - while s.len() > 0 { - if s.chars().next() == Some(':') { - suffix = Some(s[1..].to_owned()); + while i[s..].len() > 0 { + if i[s..].chars().next() == Some(':') { + suffix = Some(s as u16 + 1 as u16..i.len() as u16); break } - s.find(' ').map(|i| { + i[s..].find(' ').map(|i| { if i > 0 { - content.push(Cow::Owned(s.slice_chars(0, i).to_owned())); - s = &s[i..]; + content.push(s as u16..(s + i) as u16); + s = i; } }); // if s.chars().next() == Some(' ') { s = &s[1..] }; - s = &s[1..] + s += 1; } let msg_type = if suffix.as_ref() - .and_then(|s| s.chars().next()) == Some('\u{1}') { MsgType::Ctcp } else { MsgType::Irc }; + .and_then(|s| i[s.start as usize..].chars().next()) == Some('\u{1}') { MsgType::Ctcp } else { MsgType::Irc }; command.map(move |c| - Ok(Message::new(prefix.map(Cow::Owned), - c.unwrap(), + Ok(Message::new( + i.to_owned(), + prefix, + c, content, // strip \{1} if CTCP message // strip \r\n for each line, relying on their existence match msg_type { - MsgType::Irc => suffix.map(|s| s[0..s.len() - 2].to_string()).map(Cow::Owned), - MsgType::Ctcp => suffix.map(|s| s[1..s.len() - 3].to_string()).map(Cow::Owned) + MsgType::Irc => suffix.map(|s| s.start..s.end - 2), + MsgType::Ctcp => suffix.map(|s| s.start + 1..s.end - 3) }, msg_type )) @@ -94,32 +150,34 @@ impl<'a> FromStr for Message<'a> { } } -impl<'a> ToString for Message<'a> { +impl ToString for Message { fn to_string(&self) -> String { + self.source.clone() + /* let mut s = String::with_capacity(512); - if let Some(ref p) = self.prefix { + if let Some(ref p) = self.prefix() { s.push(':'); - s.push_str(&p); + s.push_str(p); s.push(' '); } - s.push_str(&self.command); + s.push_str(self.command()); s.push(' '); for part in self.content.iter() { - s.push_str(&part); + s.push_str(self.range(&part)); s.push(' '); } - if let Some(ref p) = self.suffix { + if let Some(ref p) = self.suffix() { s.push(':'); if let MsgType::Ctcp = self.msg_type { s.push('\u{1}') } - s.push_str(&p); + s.push_str(p); if let MsgType::Ctcp = self.msg_type { s.push('\u{1}') } } s.push_str("\r\n"); - s + s*/ } } @@ -204,906 +262,6 @@ pub enum SetMode { Minus } -#[derive(Clone, PartialEq, Eq, Hash)] -pub enum Command<'a> { - Pass { password: Cow<'a, String> }, - Nick { nickname: Cow<'a, String> }, - User { user: Cow<'a, String>, mode: Cow<'a, String>, unused: Cow<'a, String>, realname: Cow<'a, String> }, - Oper { name: Cow<'a, String>, password: Cow<'a, String> }, - Mode { nickname: Cow<'a, String>, mode: &'a [(SetMode, Mode)] }, - Service { nickname: Cow<'a, String>, reserved: Cow<'a, String>, distribution: Cow<'a, String>, service_type: Cow<'a, String>, reserved2: Cow<'a, String>, info: Cow<'a, String> }, - Quit { message: Option> }, - SQuit { server: Cow<'a, String>, comment: Cow<'a, String> }, - Join { channels: &'a [(Cow<'a, String>, Option>)] }, - Join_leave_all, - Part { channels: &'a [Cow<'a, String>], message: Cow<'a, String> }, - /* - Topic = 1011, - Names = 1012, - List = 1013, - Invite = 1014, - Kick = 1015, - */ - PrivMsg { from: Option>, to: Cow<'a, String>, content: Cow<'a, String> }, - Notice { to: Cow<'a, String>, content: Cow<'a, String> }, - /* - Motd = 1018, - LUsers = 1019, - Version = 1020, - Stats = 1021, - Links = 1022, - Time = 1023, - Connect = 1024, - Trace = 1025, - Admin = 1026, - Info = 1027, - ServList = 1028, - SQuery = 1029, - Who = 1030, - WhoIs = 1031, - WhoWas = 1032, - Kill = 1033, - */ - Ping { server1: Option>, server2: Option> }, - Pong { server1: Option>, server2: Option> }, - /* - Error = 1036, - Away = 1037, - Rehash = 1038, - Die = 1039, - Restart = 1040, - Summon = 1041, - Users = 1042, - Wallops = 1043, - Userhost = 1044, - Ison = 1045,*/ - - Ctcp { command: Cow<'a, String> }, - - - /// "Welcome to the Internet Relay Network !@" - RPL_WELCOME, - /// "Your host is , running version " - RPL_YOURHOST, - /// "This server was created " - RPL_CREATED, - /// " " - RPL_MYINFO, - /*/// "Try server , port " - /// Sent by the server to a user to suggest an alternative - /// server. This is often used when the connection is - /// refused because the server is already full. - RPL_BOUNCE = 005, - /// ":*1 *( " " )" - /// - Reply format used by USERHOST to list replies to - /// the query list. The reply string is composed as - /// follows: - /// - /// reply = nickname [ "*" ] "=" ( "+" / "-" ) hostname - /// - /// The '*' indicates whether the client has registered - /// as an Operator. The '-' or '+' characters represent - /// whether the client has set an AWAY message or not - /// respectively. - RPL_USERHOST = 302, - /// ":*1 *( " " )" - /// - Reply format used by ISON to list replies to the query list. - RPL_ISON = 303, - /// " :" - RPL_AWAY = 301, - /// ":You are no longer marked as being away" - RPL_UNAWAY = 305, - /// ":You have been marked as being away" - /// - These replies are used with the AWAY command (if - /// allowed). RPL_AWAY is sent to any client sending a - /// PRIVMSG to a client which is away. RPL_AWAY is only - /// sent by the server to which the client is connected. - /// Replies RPL_UNAWAY and RPL_NOWAWAY are sent when the - /// client removes and sets an AWAY message./ - RPL_NOWAWAY = 306, - /// " * :" - RPL_WHOISUSER = 311, - /// " :" - RPL_WHOISSERVER = 312, - /// " :is an IRC operator" - RPL_WHOISOPERATOR = 313, - /// " :seconds idle" - RPL_WHOISIDLE = 317, - /// " :End of WHOIS list" - RPL_ENDOFWHOIS = 318, - /// " :*( ( "@" / "+" ) " " )" - /// - Replies 311 - 313, 317 - 319 are all replies - /// generated in response to a WHOIS message. Given that - /// there are enough parameters present, the answering - /// server MUST either formulate a reply out of the above - /// numerics (if the query nick is found) or return an - /// error reply. The '*' in RPL_WHOISUSER is there as - /// the literal character and not as a wild card. For - /// each reply set, only RPL_WHOISCHANNELS may appear - /// more than once (for long lists of channel names). - /// The '@' and '+' characters next to the channel name - /// indicate whether a client is a channel operator or - /// has been granted permission to speak on a moderated - /// channel. The RPL_ENDOFWHOIS reply is used to mark - /// the end of processing a WHOIS message. - RPL_WHOISCHANNELS = 319, - /// " * :" - RPL_WHOWASUSER = 314, - /// " :End of WHOWAS" - /// - When replying to a WHOWAS message, a server MUST use - /// the replies RPL_WHOWASUSER, RPL_WHOISSERVER or - /// ERR_WASNOSUCHNICK for each nickname in the presented - /// list. At the end of all reply batches, there MUST - /// be RPL_ENDOFWHOWAS (even if there was only one reply - /// and it was an error). - RPL_ENDOFWHOWAS = 369, - /// Obsolete. Not used. - #[deprecated = "Obsolete. Not used."] - RPL_LISTSTART = 321, - /// " <# visible> :" - RPL_LIST = 322, - /// ":End of LIST" - /// - Replies RPL_LIST, RPL_LISTEND mark the actual replies - /// with data and end of the server's response to a LIST - /// command. If there are no channels available to return, - /// only the end reply MUST be sent. - RPL_LISTEND = 323, - /// " " - RPL_UNIQOPIS = 325, - /// " " - RPL_CHANNELMODEIS = 324, - /// " :No topic is set" - RPL_NOTOPIC = 331, - /// " :" - /// - When sending a TOPIC message to determine the - /// channel topic, one of two replies is sent. If - /// the topic is set, RPL_TOPIC is sent back else - /// RPL_NOTOPIC. - RPL_TOPIC = 332, - /// " " - /// - Returned by the server to indicate that the - /// attempted INVITE message was successful and is - /// being passed onto the end client. - RPL_INVITING = 341, - /// " :Summoning user to IRC" - /// - Returned by a server answering a SUMMON message to - /// indicate that it is summoning that user. - RPL_SUMMONING = 342, - /// " " - RPL_INVITELIST = 346, - /// " :End of channel invite list" - /// - When listing the 'invitations masks' for a given channel, - /// a server is required to send the list back using the - /// RPL_INVITELIST and RPL_ENDOFINVITELIST messages. A - /// separate RPL_INVITELIST is sent for each active mask. - /// After the masks have been listed (or if none present) a - /// RPL_ENDOFINVITELIST MUST be sent. - RPL_ENDOFINVITELIST = 347, - /// " " - RPL_EXCEPTLIST = 348, - /// " :End of channel exception list" - /// - When listing the 'exception masks' for a given channel, - /// a server is required to send the list back using the - /// RPL_EXCEPTLIST and RPL_ENDOFEXCEPTLIST messages. A - /// separate RPL_EXCEPTLIST is sent for each active mask. - /// After the masks have been listed (or if none present) - /// a RPL_ENDOFEXCEPTLIST MUST be sent./ - RPL_ENDOFEXCEPTLIST = 349, - /// ". :" - /// - Reply by the server showing its version details. - /// The is the version of the software being - /// used (including any patchlevel revisions) and the - /// is used to indicate if the server is - /// running in "debug mode". - /// - /// The "comments" field may contain any comments about - /// the version or further version details. - RPL_VERSION = 351, - /// " - /// ( "H" / "G" > ["*"] [ ( "@" / "+" ) ] - /// : " - RPL_WHOREPLY = 352, - /// " :End of WHO list" - /// - The RPL_WHOREPLY and RPL_ENDOFWHO pair are used - /// to answer a WHO message. The RPL_WHOREPLY is only - /// sent if there is an appropriate match to the WHO - /// query. If there is a list of parameters supplied - /// with a WHO message, a RPL_ENDOFWHO MUST be sent - /// after processing each list item with being - /// the item. - RPL_ENDOFWHO = 315, - /// "( "=" / "*" / "@" ) - /// :[ "@" / "+" ] *( " " [ "@" / "+" ] ) - /// - "@" is used for secret channels, "*" for private - /// channels, and "=" for others (public channels). - RPL_NAMREPLY = 353, - /// " :End of NAMES list" - /// - To reply to a NAMES message, a reply pair consisting - /// of RPL_NAMREPLY and RPL_ENDOFNAMES is sent by the - /// server back to the client. If there is no channel - /// found as in the query, then only RPL_ENDOFNAMES is - /// returned. The exception to this is when a NAMES - /// message is sent with no parameters and all visible - /// channels and contents are sent back in a series of - /// RPL_NAMEREPLY messages with a RPL_ENDOFNAMES to mark - /// the end. - RPL_ENDOFNAMES = 366, - /// " : " - RPL_LINKS = 364, - /// " :End of LINKS list" - /// - In replying to the LINKS message, a server MUST send - /// replies back using the RPL_LINKS numeric and mark the - /// end of the list using an RPL_ENDOFLINKS reply. - RPL_ENDOFLINKS = 365, - /// " " - RPL_BANLIST = 367, - /// " :End of channel ban list" - /// - When listing the active 'bans' for a given channel, - /// a server is required to send the list back using the - /// RPL_BANLIST and RPL_ENDOFBANLIST messages. A separate - /// RPL_BANLIST is sent for each active banmask. After the - /// banmasks have been listed (or if none present) a - /// RPL_ENDOFBANLIST MUST be sent. - RPL_ENDOFBANLIST = 368, - /// ":" - RPL_INFO = 371, - /// ":End of INFO list" - /// - A server responding to an INFO message is required to - /// send all its 'info' in a series of RPL_INFO messages - /// with a RPL_ENDOFINFO reply to indicate the end of the - /// replies. - RPL_ENDOFINFO = 374, - /// ":- Message of the day - " - RPL_MOTDSTART = 375, - /// ":- " - RPL_MOTD = 372, - /// ":End of MOTD command" - /// - When responding to the MOTD message and the MOTD file - /// is found, the file is displayed line by line, with - /// each line no longer than 80 characters, using - /// RPL_MOTD format replies. These MUST be surrounded - /// by a RPL_MOTDSTART (before the RPL_MOTDs) and an - /// RPL_ENDOFMOTD (after). - RPL_ENDOFMOTD = 376, - /// ":You are now an IRC operator" - /// - RPL_YOUREOPER is sent back to a client which has - /// just successfully issued an OPER message and gained - /// operator status. - RPL_YOUREOPER = 381, - /// " :Rehashing" - /// - If the REHASH option is used and an operator sends - /// a REHASH message, an RPL_REHASHING is sent back to - /// the operator. - RPL_REHASHING = 382, - /// "You are service " - /// - Sent by the server to a service upon successful - /// registration. - RPL_YOURESERVICE = 383, - /// " :" - /// - When replying to the TIME message, a server MUST send - /// the reply using the RPL_TIME format above. The string - /// showing the time need only contain the correct day and - /// time there. There is no further requirement for the - /// time string. - RPL_TIME = 391, - /// ":UserID Terminal Host" - RPL_USERSSTART = 392, - /// ": " - RPL_USERS = 393, - /// ":End of users" - RPL_ENDOFUSERS = 394, - /// ":Nobody logged in" - /// - If the USERS message is handled by a server, the - /// replies RPL_USERSTART, RPL_USERS, RPL_ENDOFUSERS and - /// RPL_NOUSERS are used. RPL_USERSSTART MUST be sent - /// first, following by either a sequence of RPL_USERS - /// or a single RPL_NOUSER. Following this is - /// RPL_ENDOFUSERS. - RPL_NOUSERS = 395, - /// "Link - /// V - /// - /// " - RPL_TRACELINK = 200, - /// "Try. " - RPL_TRACECONNECTING = 201, - /// "H.S. " - RPL_TRACEHANDSHAKE = 202, - /// "???? []" - RPL_TRACEUNKNOWN = 203, - /// "Oper " - RPL_TRACEOPERATOR = 204, - /// "User " - RPL_TRACEUSER = 205, - /// "Serv S C - /// @ V" - RPL_TRACESERVER = 206, - /// "Service " - RPL_TRACESERVICE = 207, - /// " 0 " - RPL_TRACENEWTYPE = 208, - /// "Class " - RPL_TRACECLASS = 209, - /// Unused. - #[deprecated = "Unused."] - RPL_TRACERECONNECT = 210, - /// "File " - RPL_TRACELOG = 261, - /// " :End of TRACE" - /// - The RPL_TRACE* are all returned by the server in - /// response to the TRACE message. How many are - /// returned is dependent on the TRACE message and - /// whether it was sent by an operator or not. There - /// is no predefined order for which occurs first. - /// Replies RPL_TRACEUNKNOWN, RPL_TRACECONNECTING and - /// RPL_TRACEHANDSHAKE are all used for connections - /// which have not been fully established and are either - /// unknown, still attempting to connect or in the - /// process of completing the 'server handshake'. - /// RPL_TRACELINK is sent by any server which handles - /// a TRACE message and has to pass it on to another - /// server. The list of RPL_TRACELINKs sent in - /// response to a TRACE command traversing the IRC - /// network should reflect the actual connectivity of - /// the servers themselves along that path. - /// RPL_TRACENEWTYPE is to be used for any connection - /// which does not fit in the other categories but is - /// being displayed anyway. - /// RPL_TRACEEND is sent to indicate the end of the list./ - RPL_TRACEEND = 262, - /// " - /// - ///