diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/event.rs | 50 | ||||
| -rw-r--r-- | src/ident.rs | 2 | ||||
| -rw-r--r-- | src/lib.rs | 24 | ||||
| -rw-r--r-- | src/message.rs | 658 | ||||
| -rw-r--r-- | src/server.rs | 149 |
5 files changed, 613 insertions, 270 deletions
diff --git a/src/event.rs b/src/event.rs deleted file mode 100644 index b8e9743..0000000 --- a/src/event.rs +++ /dev/null @@ -1,50 +0,0 @@ -use ident::Ident; - -use std::borrow::ToOwned; - -#[deriving(Clone)] -pub struct Event { - pub prefix: String, - pub command: String, - pub content: Vec<String> -} - -pub trait ParseResult { - fn parse(event: Event) -> Option<Self>; -} - -pub const PING: &'static str = "PING"; - -pub const PRIVMSG: &'static str = "PRIVMSG"; - -fn join(v: Vec<String>, from: uint) -> String { - let mut msg = if v[from].chars().next().unwrap() == ':' { - v[from][][1..].to_owned() - } else { v[from].clone() }; - for m in v.iter().skip(from + 1) { - msg.push_str(" "); - msg.push_str(m.trim_right()); - } - msg -} - -pub struct PrivMsg { - pub from: Ident, - pub to: String, - pub content: String -} - -impl ParseResult for PrivMsg { - fn parse(event: Event) -> Option<PrivMsg> { - let from = Ident::parse(event.prefix[]); - let to = event.content[0].clone(); - match from { - Some(from) => Some(PrivMsg { - from: from, - to: to, - content: join(event.content, 1) - }), - None => None - } - } -} diff --git a/src/ident.rs b/src/ident.rs index 099a129..0008d53 100644 --- a/src/ident.rs +++ b/src/ident.rs @@ -3,7 +3,7 @@ use std::borrow::ToOwned; static PATTERN: Regex = regex!(":(.*)!(.*)@(.*)"); -#[derive(Show, Clone)] +#[derive(Debug, Clone)] pub struct Ident { pub nickname: String, pub user: String, @@ -1,14 +1,30 @@ -#![feature(globs, phase, slicing_syntax, macro_rules, unboxed_closures)] +#![feature(plugin, slicing_syntax, unboxed_closures)] +#![allow(unstable)] -#[phase(plugin)] -extern crate regex_macros; +#![plugin(regex_macros)] extern crate regex; -#[phase(plugin, link)] +#[macro_use] extern crate log; +extern crate eventual; + pub mod server; pub mod color; pub mod ident; pub mod callback; pub mod message; + +use std::io; +use std::result; + +#[derive(Debug)] +pub enum IrscError { + Io(io::Error), + AlreadyConnected, + NotConnected +} + +pub type Result<T> = result::Result<T, IrscError>; + +pub const DEBUG: bool = cfg!(not(ndebug)); diff --git a/src/message.rs b/src/message.rs index edc1874..4adc83a 100644 --- a/src/message.rs +++ b/src/message.rs @@ -1,183 +1,258 @@ #![allow(non_camel_case_types)] use std::str::FromStr; -use std::borrow::ToOwned; - -#[derive(Clone)] -pub struct Message { - pub prefix: Option<String>, - pub command: Command, - pub content: Vec<String>, - pub suffix: Option<String> +use std::string::{ ToString }; +use std::borrow::{ Cow, ToOwned }; + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum MsgType { + /// Plain old IRC messages, as defined in [rfc2812][rfc] + /// rfc: http://tools.ietf.org/html/rfc2812 + Irc, + /// Ctcp messages, wrapped in \u{1} + Ctcp +} + +#[derive(Debug, PartialEq, Eq, Hash, Clone)] +pub struct Message<'a> { + pub prefix: Option<Cow<'a, String>>, + pub command: Cow<'a, String>, + pub content: Vec<Cow<'a, String>>, + pub suffix: Option<Cow<'a, String>>, + pub msg_type: MsgType } -impl Message { - pub fn new(prefix: Option<String>, command: Command, content: Vec<String>, suffix: Option<String>) -> Message { +impl<'a> Message<'a> { + pub fn new(prefix: Option<Cow<'a, String>>, command: Cow<'a, String>, content: Vec<Cow<'a, String>>, suffix: Option<Cow<'a, String>>, msg_type: MsgType) -> Message<'a> { Message { prefix: prefix, command: command, content: content, - suffix: suffix + suffix: suffix, + msg_type: msg_type } } +} - pub fn parse(i: &str) -> Option<Message> { +impl<'a> FromStr for Message<'a> { + type Err = ::IrscError; + fn from_str(i: &str) -> Result<Message<'a>, ::IrscError> { + info!("Attempting to parse message: {}", i); let len = i.len(); let mut s = i; + + let msg_type = if s.char_at(0) == '\u{1}' { MsgType::Ctcp } else { MsgType::Irc }; + let prefix = if len >= 1 && s.char_at(0) == ':' { s.find(' ').map(|i| { let p = s.slice_chars(1, i).to_owned(); - s = s[i..]; + s = &s[i + 1..]; p }) } else { None }; let command = s.find(' ').map(|i| { let p = s.slice_chars(0, i).to_owned(); - s = s[i..]; + s = &s[i..]; p - }).and_then(|c| c.parse()); + }).map(|c| c.parse()).map(|c| Some(Cow::Owned(c))); + // 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.char_at(0) == ':' { - suffix = Some(s.slice_from(1).to_owned()); + suffix = Some(s[1..].to_owned()); break } s.find(' ').map(|i| { - content.push(s.slice_chars(0, i).to_owned()); - s = s[i..]; + if i > 0 { + content.push(Cow::Owned(s.slice_chars(0, i).to_owned())); + s = &s[i..]; + } }); + if s.char_at(0) == ' ' { s = &s[1..] }; } - command.map(move |c| Message::new(prefix, c, content, suffix)) + command.and_then(move |Ok(c)| + Ok(Message::new(prefix.map(|p| Cow::Owned(p)), + c, + content, + suffix.map(|s| Cow::Owned(s)), + msg_type + )) + ) + } +} - pub fn format(&self) -> String { +impl<'a> ToString for Message<'a> { + fn to_string(&self) -> String { let mut s = String::with_capacity(512); if let Some(ref p) = self.prefix { s.push(':'); - s.push_str(p[]); + s.push_str(&p); s.push(' '); } - s.push_str(format!("{} ", self.command)[]); + s.push_str(&self.command); + s.push(' '); + + for part in self.content.iter() { + s.push_str(&part); + s.push(' '); + } if let Some(ref p) = self.suffix { s.push(':'); - s.push_str(p[]); + s.push_str(&p); } s + } } -#[derive(Copy, Clone, Show, PartialEq, Eq, Hash)] -pub enum Command { - PASS, - NICK, - USER, - OPER, - MODE, - SERVICE, - QUIT, - SQUIT, - JOIN, - PART, - TOPIC, - NAMES, - LIST, - INVITE, - KICK, - PRIVMSG, - NOTICE, - MOTD, - LUSERS, - VERSION, - STATS, - LINKS, - TIME, - CONNECT, - TRACE, - ADMIN, - INFO, - SERVLIST, - SQUERY, - WHO, - WHOIS, - WHOWAS, - KILL, - PING, - PONG, - ERROR, - AWAY, - REHASH, - DIE, - RESTART, - SUMMON, - USERS, - WALLOPS, - USERHOST, - ISON +/* +pub trait Command { + fn name(&self) -> String; + fn to_message(&self) -> Message; + fn from_message(msg: &Message) -> Option<Self> } -impl FromStr for Command { - fn from_str(s: &str) -> Option<Command> { - use self::Command::*; - match s { - "PASS" => Some(PASS), - "NICK" => Some(NICK), - "USER" => Some(USER), - "OPER" => Some(OPER), - "MODE" => Some(MODE), - "SERVICE" => Some(SERVICE), - "QUIT" => Some(QUIT), - "SQUIT" => Some(SQUIT), - "JOIN" => Some(JOIN), - "PART" => Some(PART), - "TOPIC" => Some(TOPIC), - "NAMES" => Some(NAMES), - "LIST" => Some(LIST), - "INVITE" => Some(INVITE), - "KICK" => Some(KICK), - "PRIVMSG" => Some(PRIVMSG), - "NOTICE" => Some(NOTICE), - "MOTD" => Some(MOTD), - "LUSERS" => Some(LUSERS), - "VERSION" => Some(VERSION), - "STATS" => Some(STATS), - "LINKS" => Some(LINKS), - "TIME" => Some(TIME), - "CONNECT" => Some(CONNECT), - "TRACE" => Some(TRACE), - "ADMIN" => Some(ADMIN), - "INFO" => Some(INFO), - "SERVLIST" => Some(SERVLIST), - "SQUERY" => Some(SQUERY), - "WHO" => Some(WHO), - "WHOIS" => Some(WHOIS), - "WHOWAS" => Some(WHOWAS), - "KILL" => Some(KILL), - "PING" => Some(PING), - "PONG" => Some(PONG), - "ERROR" => Some(ERROR), - "AWAY" => Some(AWAY), - "REHASH" => Some(REHASH), - "DIE" => Some(DIE), - "RESTART" => Some(RESTART), - "SUMMON" => Some(SUMMON), - "USERS" => Some(USERS), - "WALLOPS" => Some(WALLOPS), - "USERHOST" => Some(USERHOST), - "ISON" => Some(ISON), - _ => None +macro_rules! command ( + ($name: ident { $($field: ident: $t: ty),* } to $to_msg: expr; from $from_msg: expr;) => ( + pub struct $name { + $(pub $field: $t),* } - } + + impl Command for $name { + fn name(&self) -> String { stringify!($name).to_owned() } + fn to_message(&self) -> Message { ($to_msg)(self) } + fn from_message(msg: &Message) -> Option<$name> { ($from_msg)(msg) } + } + ) +);*/ + +/* +command!(Pass { password: String } + to |&:s: &Pass| Message::new(None, "PASS".to_owned(), Vec::new(), Some(s.password.clone())); + from |&:msg: &Message| msg.clone().suffix.map(|s| Pass { password: s });); + +command!(Ping { server1: Option<String>, server2: Option<String> } + to |&:s :&Ping| { + let mut v = Vec::new(); + if let Some(ref s) = s.server1 { v.push(s.clone()) } + if let Some(ref s) = s.server2 { v.push(s.clone()) } + Message::new(None, "PING".to_owned(), v, None) + }; + from |&:msg: &Message| { + let mut c = msg.content.clone(); + Some(Ping { server2: c.pop(), server1: c.pop() }) }; ); + +command!(Pong { server1: Option<String>, server2: Option<String> } + to |&:s: &Pong| { + let mut v = Vec::new(); + if let Some(ref s) = s.server1 { v.push(s.clone()) } + if let Some(ref s) = s.server2 { v.push(s.clone()) } + Message::new(None, "PONG".to_owned(), v, None) + }; + from |&:msg: &Message| { + let mut c = msg.content.clone(); + Some(Pong { server2: c.pop(), server1: c.pop() }) + }; ); + +command!(PrivMsg { from: Option<String>, to: String, content: String } + to |&:s: &PrivMsg| { + Message::new(s.from.clone(), "PRIVMSG".to_owned(), vec![s.to.clone()], Some(s.content.clone())) + }; + from |&:msg: &Message| { + msg.content.clone().pop().map( + |c| PrivMsg { + from: msg.prefix.clone(), + to: c, + content: msg.suffix.clone().unwrap_or(String::new()) + }) + }; ); +*/ + +#[derive(Clone, PartialEq, Eq, Hash)] +pub enum Mode { + Away, + Invisible, + Wallops, + Restricted, + Operator, + LocalOperator, + ServerNotices, + Custom(String) } -#[derive(Show, Copy, PartialEq, Eq)] -pub enum Response { +#[derive(Copy, Clone, PartialEq, Eq, Hash)] +pub enum SetMode { + Plus, + 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<Cow<'a, String>> }, + SQuit { server: Cow<'a, String>, comment: Cow<'a, String> }, + Join { channels: &'a [(Cow<'a, String>, Option<Cow<'a, String>>)] }, + 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<Cow<'a, String>>, 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<Cow<'a, String>>, server2: Option<Cow<'a, String>> }, + Pong { server1: Option<Cow<'a, String>>, server2: Option<Cow<'a, String>> }, + /* + 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 <nick>!<user>@<host>" RPL_WELCOME = 001, /// "Your host is <servername>, running version <ver>" @@ -678,12 +753,12 @@ pub enum Response { /// ":USERS has been disabled" /// - Returned as a response to the USERS command. MUST be /// returned by any server which does not implement it. - ERR_USERSDISABLED = 446, + ERR_USERSDISABLED = 446,*/ /// ":You have not registered" /// - Returned by the server to indicate that the client /// MUST be registered before the server will allow it /// to be parsed in detail. - ERR_NOTREGISTERED = 451, + ErrNotRegistered,/* /// "<command> :Not enough parameters" /// - Returned by the server by numerous commands to /// indicate to the client that it didn't supply enough @@ -770,17 +845,305 @@ pub enum Response { /// ":Cannot change mode for other users" /// - Error sent to any user trying to view or change the /// user mode for a user other than themselves. - ERR_USERSDONTMATCH = 502, + ERR_USERSDONTMATCH = 502 + */ } -impl Response { - 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 } +/* +impl ToString for Command { + fn to_string(&self) -> String { + 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", + }.to_owned() + } +}*/ + + +/* +impl FromStr for Command { + fn from_str(s: &str) -> Option<Command> { + use self::Command::*; + match s { + "PASS" => Some(PASS), + "NICK" => Some(NICK), + "USER" => Some(USER), + "OPER" => Some(OPER), + "MODE" => Some(MODE), + "SERVICE" => Some(SERVICE), + "QUIT" => Some(QUIT), + "SQUIT" => Some(SQUIT), + "JOIN" => Some(JOIN), + "PART" => Some(PART), + "TOPIC" => Some(TOPIC), + "NAMES" => Some(NAMES), + "LIST" => Some(LIST), + "INVITE" => Some(INVITE), + "KICK" => Some(KICK), + "PRIVMSG" => Some(PRIVMSG), + "NOTICE" => Some(NOTICE), + "MOTD" => Some(MOTD), + "LUSERS" => Some(LUSERS), + "VERSION" => Some(VERSION), + "STATS" => Some(STATS), + "LINKS" => Some(LINKS), + "TIME" => Some(TIME), + "CONNECT" => Some(CONNECT), + "TRACE" => Some(TRACE), + "ADMIN" => Some(ADMIN), + "INFO" => Some(INFO), + "SERVLIST" => Some(SERVLIST), + "SQUERY" => Some(SQUERY), + "WHO" => Some(WHO), + "WHOIS" => Some(WHOIS), + "WHOWAS" => Some(WHOWAS), + "KILL" => Some(KILL), + "PING" => Some(PING), + "PONG" => Some(PONG), + "ERROR" => Some(ERROR), + "AWAY" => Some(AWAY), + "REHASH" => Some(REHASH), + "DIE" => Some(DIE), + "RESTART" => Some(RESTART), + "SUMMON" => Some(SUMMON), + "USERS" => Some(USERS), + "WALLOPS" => Some(WALLOPS), + "USERHOST" => Some(USERHOST), + "ISON" => Some(ISON), + _ => None + } + } +}*/ + +/// If you hoped it couldn't get any uglier... I'm sorry, it does. +/// Why a giant match? API. +/// +/// I tried structuring it as a bunch of structs that impl a `Command` trait, +/// but the user would have to use Any and lots of cats. Also, extensibility isn't +/// really a goal; the IRC protocol doesn't seem to evolve very fast. +/// +/// Granted, I *could* have used a phf-map to map to functions to parse this, which +/// - while more readable - shouldn't have resulted in performance gains. +/// +/// Please don't cry. + +impl<'a> Command<'a> { + pub fn from_message(msg: &'a Message) -> Option<Command<'a>> { + match &msg.command { + "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)) })), + "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 } } -pub fn join(v: Vec<String>, from: uint) -> String { +pub fn join(v: Vec<String>, from: usize) -> String { let mut msg = if v[from].chars().next().unwrap() == ':' { - v[from][][1..].to_owned() + v[from][1..].to_owned() } else { v[from].clone() }; for m in v.iter().skip(from + 1) { msg.push_str(" "); @@ -809,3 +1172,36 @@ impl ParseResult for PrivMsg { } } }*/ + +#[cfg(test)] +mod test { + use std::borrow::{ Cow, ToOwned }; + use message::{ Message, MsgType }; + + #[test] + fn parse_message() { + let a = ":a.b.c NOTICE AUTH :*** Looking up your hostname..."; + // I'm not even kidding... + let a2 = Message::new( + Some(Cow::Owned("a.b.c".to_owned())), + Cow::Owned("NOTICE".to_owned()), + vec![Cow::Owned("AUTH".to_owned())], + Some(Cow::Owned("*** Looking up your hostname...".to_owned())), + MsgType::Irc + ); + assert_eq!(a.parse(), Some(a2.clone())); + assert_eq!(a2.to_string(), a); + + let b = ":d PRIVMSG You :\u{1}ACTION sends you funny pictures of cats!\u{1}"; + let b2 = Message::new( + Some(Cow::Owned("d".to_owned())), + Cow::Owned("PRIVMSG".to_owned()), + vec![Cow::Owned("You".to_owned())], + Some(Cow::Owned("\u{1}ACTION sends you funny pictures of cats!\u{1}".to_owned())), + MsgType::Ctcp + ); + assert_eq!(b.parse(), Some(b2.clone())); + assert_eq!(b2.to_string(), b); + } + +} diff --git a/src/server.rs b/src/server.rs index 154e517..9c4bb65 100644 --- a/src/server.rs +++ b/src/server.rs @@ -1,25 +1,19 @@ use std::io::{ - BufferedReader, - TcpStream, - IoError, - IoResult + self, + Write, + Read, + BufRead, + BufReader, }; -use std::mem; -use callback::Callback; +use std::net::TcpStream; + use message; use message::{ Command, Message }; #[cfg(feature = "ssl")] use openssl::ssl::{ SslContext, SslMethod, SslStream }; -#[derive(Show, PartialEq, Eq, Clone)] -pub enum Failure { - AlreadyConnected, - NotConnected, - Io(IoError) -} - /// Yes, I don't like the name either, but it's private, so... enum StreamKind { Plain(TcpStream), @@ -27,18 +21,26 @@ enum StreamKind { Ssl(SslStream) } -impl Writer for StreamKind { - fn write(&mut self, buf: &[u8]) -> IoResult<()> { +impl Write for StreamKind { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { match *self { StreamKind::Plain(ref mut s) => s.write(buf), #[cfg(feature = "ssl")] StreamKind::Ssl(ref mut s) => s.write(buf) } } + + fn flush(&mut self) -> io::Result<()> { + match *self { + StreamKind::Plain(ref mut s) => s.flush(), + #[cfg(feature = "ssl")] + StreamKind::Ssl(ref mut s) => s.flush() + } + } } -impl Reader for StreamKind { - fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { +impl Read for StreamKind { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { match *self { StreamKind::Plain(ref mut s) => s.read(buf), #[cfg(feature = "ssl")] @@ -47,55 +49,41 @@ impl Reader for StreamKind { } } -pub struct Event<'a> { - pub server: &'a mut Server<'a>, - pub message: &'a Message -} - -pub struct Server<'a> { +pub struct Server { stream: Option<StreamKind>, - pub events: Callback<Event<'a>>, } -impl<'a> Server<'a> { - pub fn new() -> Server<'a> { +impl Server { + pub fn new() -> Server { Server { - stream: None, - events: { - let mut c = Callback::new(); - c.register(Server::handle_event); - c - } + stream: None } } - fn handle_event(e: &mut Event) { - match e.message.command { - Command::PING => { - e.server.sendraw(format!("PONG :{}", message::join(e.message.content.clone(), 0)).as_slice(), true).unwrap(); - } - _ => () + fn handle_event(&mut self, msg: &message::Message) { + if *msg.command == "PING" { + let _ = self.send(Command::Pong { server1: msg.suffix.clone(), server2: None }.to_message()); } } - pub fn connect(&mut self, host: String, port: u16) -> Result<(), Failure> { + pub fn connect(&mut self, host: String, port: u16) -> ::Result<()> { let s = &mut self.stream; - match *s { Some(_) => return Err(Failure::AlreadyConnected), _ => () }; + match *s { Some(_) => return Err(::IrscError::AlreadyConnected), _ => () }; *s = match TcpStream::connect((host.as_slice(), port)) { Ok(tcp) => Some(StreamKind::Plain(tcp)), - Err(e) => return Err(Failure::Io(e)) + Err(e) => return Err(::IrscError::Io(e)) }; Ok(()) } #[cfg(feature = "ssl")] - pub fn connect_ssl(&mut self, host: String, port: u16) -> Result<(), Failure> { + pub fn connect_ssl(&mut self, host: String, port: u16) -> ::Result<()> { let mut s = self.stream.lock(); - match *s { Some(_) => return Err(Failure::AlreadyConnected), _ => () }; + match *s { Some(_) => return Err(::IrscError::AlreadyConnected), _ => () }; let tcp_stream = match TcpStream::connect((host.as_slice(), port)) { Ok(tcp) => Some(tcp), - Err(e) => return Err(Failure::Io(e)) + Err(e) => return Err(::IrscError::Io(e)) }; let ssl = SslContext::new(SslMethod::Tlsv1); @@ -103,87 +91,80 @@ impl<'a> Server<'a> { *s = ssl_stream; Ok(()) - } #[inline] - fn sendraw(&mut self, s: &str, newline: bool) -> Result<(), Failure> { + fn sendraw(&mut self, s: &str, newline: bool) -> ::Result<usize> { info!(">> {}", s); - if cfg!(not(ndebug)) && s.len() > 510 { + if ::DEBUG && s.len() > 510 { panic!("Message too long, kitties will die if this runs in release mode. Msg: {}", s) } let stream = &mut self.stream; if stream.is_some() { stream.as_mut().map(|stream| { - match stream.write_str(s) { - Ok(_) => match { if newline { stream.write_str("\r\n") } else { Ok(()) } } { - Ok(_) => match stream.flush() { - Ok(_) => Ok(()), - Err(e) => return Err(Failure::Io(e)) + match stream.write(s.as_bytes()) { + Ok(a) => match { if newline { stream.write(b"\r\n").map(|s| s + a) } else { Ok(a) } } { + Ok(b) => match stream.flush() { + Ok(_) => Ok(b), + Err(e) => return Err(::IrscError::Io(e)) }, - Err(e) => return Err(Failure::Io(e)) + Err(e) => return Err(::IrscError::Io(e)) }, - Err(e) => return Err(Failure::Io(e)) + Err(e) => return Err(::IrscError::Io(e)) } }).unwrap() } else { - Err(Failure::NotConnected) + Err(::IrscError::NotConnected) } } - pub fn send(&mut self, msg: message::Message) -> Result<(), Failure> { - self.sendraw(msg.format()[], true) + pub fn send(&mut self, msg: message::Message) -> ::Result<usize> { + self.sendraw(&msg.to_string(), true) } - pub fn join(&mut self, channel: &str) -> Result<(), Failure> { + pub fn join(&mut self, channel: &str) -> ::Result<usize> { self.sendraw(format!("JOIN {}", channel).as_slice(), true) } - pub fn part(&mut self, channel: &str) -> Result<(), Failure> { + pub fn part(&mut self, channel: &str) -> ::Result<usize> { self.sendraw(format!("PART {}", channel).as_slice(), true) } - pub fn nick(&mut self, nick: &str) -> Result<(), Failure> { + pub fn nick(&mut self, nick: &str) -> ::Result<usize> { self.sendraw(format!("NICK {}", nick).as_slice(), true) } - pub fn user(&mut self, username: &str, hostname: &str, servername: &str, realname: &str) -> Result<(), Failure> { + pub fn user(&mut self, username: &str, hostname: &str, servername: &str, realname: &str) -> ::Result<usize> { self.sendraw(format!("USER {} {} {} :{}", username, hostname, servername, realname).as_slice(), true) } - pub fn password(&mut self, password: &str) -> Result<(), Failure> { + pub fn password(&mut self, password: &str) -> ::Result<usize> { self.sendraw(format!("PASS {}", password).as_slice(), true) } - pub fn msg(&mut self, target: &str, message: &str) -> Result<(), Failure> { + pub fn msg(&mut self, target: &str, message: &str) -> ::Result<usize> { self.sendraw(format!("PRIVMSG {} :{}", target, message).as_slice(), true) } - pub fn listen(&mut self) -> Result<(), Failure> { - let stream = { - match self.stream { - Some(ref s) => s.clone(), - None => return Err(Failure::NotConnected) - } - }; - - let mut reader = BufferedReader::new(match *stream { - StreamKind::Plain(ref s) => (*s).clone(), + pub fn listen(&mut self, events: &[fn(&mut Server, &Message)]) -> ::Result<()> { + let mut reader = BufReader::new(match self.stream { + Some(StreamKind::Plain(ref s)) => (*s).try_clone().unwrap(), #[cfg(feature = "ssl")] - StreamKind::Ssl(ref s) => (*s).clone() + Some(StreamKind::Ssl(ref s)) => (*s).try_clone().unwrap(), + None => return Err(::IrscError::NotConnected) }); - loop { - let line = reader.read_line().unwrap(); - info!("<< {}", line); + /*for line in reader.lines() { + let line = line.unwrap().parse(); - if let Some(msg) = Message::parse(line[]) { - let mut e = self.events; - e.fire(&mut Event { - server: self, - message: &msg - }); + if let Ok(msg) = line { + println!("{:?}", msg); + self.handle_event(&msg); + for e in events.iter() { + e(self, &msg) + } } - } + }*/ + Ok(()) } } |