cleaning up IRCBridgeModule to allow for configuration from in-world,

chat relaying via private channels, and old IRCBridgeModule
behaviour. also cleaning up IRCBridgeModule's OpenSim.ini
configuration variable names (still supporting "old" variable
names). refactored IRCChatModule into IRCConnector and incorporating
watchdog from IRCBridgeModule into IRCConnector.

enabling ChatModule to be used as a super-class and utilizing it in
ConciergeModule.

1 files changed, 710 insertions, 0 deletions

diff --git a/OpenSim/Region/Environment/Modules/Avatar/Chat/IRCConnector.cs b/OpenSim/Region/Environment/Modules/Avatar/Chat/IRCConnector.cs
new file mode 100644
index 0000000..0eb303c
--- /dev/null
+++ b/OpenSim/Region/Environment/Modules/Avatar/Chat/IRCConnector.cs
@@ -0,0 +1,710 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Sockets;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Scenes;
+
+namespace OpenSim.Region.Environment.Modules.Avatar.Chat
+{
+    public class IRCConnector
+    {
+        #region ErrorReplies enum
+
+        public enum ErrorReplies
+        {
+            NotRegistered = 451, // ":You have not registered"
+            NicknameInUse = 433 // "<nick> :Nickname is already in use"
+        }
+
+        #endregion
+
+        #region Replies enum
+
+        public enum Replies
+        {
+            MotdStart = 375, // ":- <server> Message of the day - "
+            Motd = 372, // ":- <text>"
+            EndOfMotd = 376 // ":End of /MOTD command"
+        }
+
+        #endregion
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Thread m_listener = null;
+        private Thread m_watchdog = null;
+        private Thread m_pinger = null;
+
+        private bool m_randomizeNick = true;
+
+        public string m_baseNick = null;
+        private string m_nick = null;
+        public string Nick
+        {
+            get { return m_baseNick; }
+            set { m_baseNick = value; }
+        }
+        
+        private bool m_enabled = false;
+        public bool Enabled
+        {
+            get { return m_enabled; }
+        }
+
+        private bool m_connected = false;
+        public bool Connected
+        {
+            get { return m_connected; }
+        }
+
+        private string m_ircChannel;
+        public string IrcChannel
+        {
+            get { return m_ircChannel; }
+
+            set { m_ircChannel = value; }
+        }
+        
+        private bool m_relayPrivateChannels = false;
+        public bool RelayPrivateChannels
+        {
+            get { return m_relayPrivateChannels; } 
+            set { m_relayPrivateChannels = value; }
+        }
+
+        private int m_relayChannel = 0;
+        public int RelayChannel
+        {
+            get { return m_relayChannel; }
+            set { m_relayChannel = value; }
+        }
+
+        private bool m_clientReporting = true;
+        public bool ClientReporting
+        {
+            get { return m_clientReporting; }
+            set { m_clientReporting = value; }
+        }
+
+        private uint m_port = 6667;
+        public uint Port 
+        {
+            get { return m_port; }
+            set { m_port = value; }
+        }
+
+        private string m_server = null;
+        public string Server
+        {
+            get { return m_server; }
+            set { m_server = value; }
+        }
+
+        public string m_accessPassword = "badkitty";
+
+        private string m_privmsgformat = "PRIVMSG {0} :<{1} in {2}>: {3}";
+        private StreamReader m_reader;
+        private List<Scene> m_scenes = new List<Scene>();
+
+        private NetworkStream m_stream = null;
+        internal object m_syncConnect = new object();
+        private TcpClient m_tcp;
+        private string m_user = "USER OpenSimBot 8 * :I'm an OpenSim to IRC bot";
+        private StreamWriter m_writer;
+
+
+        public IRCConnector(IConfigSource config)
+        {
+            m_tcp = null;
+            m_writer = null;
+            m_reader = null;
+
+            // configuration in OpenSim.ini
+            // [IRC]
+            // server  = chat.freenode.net
+            // nick    = OSimBot_mysim
+            // nicknum = true
+            // ;nicknum set to true appends a 2 digit random number to the nick
+            // ;username = USER OpenSimBot 8 * :I'm a OpenSim to irc bot
+            // ; username is the IRC command line sent
+            // ; USER <irc_user> <visible=8,invisible=0> * : <IRC_realname>
+            // channel = #opensim-regions
+            // port = 6667
+            // ;MSGformat fields : 0=botnick, 1=user, 2=region, 3=message
+            // ;for <bot>:<user in region> :<message>
+            // ;msgformat = "PRIVMSG {0} :<{1} in {2}>: {3}"
+            // ;for <bot>:<message> - <user of region> :
+            // ;msgformat = "PRIVMSG {0} : {3} - {1} of {2}"
+            // ;for <bot>:<message> - from <user> :
+            // ;msgformat = "PRIVMSG {0} : {3} - from {1}"
+            // Traps I/O disconnects so it does not crash the sim
+            // Trys to reconnect if disconnected and someone says something
+            // Tells IRC server "QUIT" when doing a close (just to be nice)
+            // Default port back to 6667
+
+            try
+            {
+                m_server = config.Configs["IRC"].GetString("server");
+                m_baseNick = config.Configs["IRC"].GetString("nick", "OSimBot");
+
+                m_randomizeNick = config.Configs["IRC"].GetBoolean("randomize_nick", m_randomizeNick);
+                m_randomizeNick = config.Configs["IRC"].GetBoolean("nicknum", m_randomizeNick); // compat
+                m_ircChannel = config.Configs["IRC"].GetString("channel");
+                m_port = (uint)config.Configs["IRC"].GetInt("port", (int)m_port);
+                m_user = config.Configs["IRC"].GetString("username", m_user);
+                m_privmsgformat = config.Configs["IRC"].GetString("msgformat", m_privmsgformat);
+                // m_commandChannel = config.Configs["IRC"].GetInt("commandchannel", m_commandChannel);
+
+                // m_verbosity = config.Configs["IRC"].GetInt("verbosity", m_verbosity);
+                m_clientReporting = config.Configs["IRC"].GetInt("verbosity", 2) > 0;
+                m_clientReporting = config.Configs["IRC"].GetBoolean("report_clients", m_clientReporting);
+
+                // m_messageOutChannel = config.Configs["IRC"].GetInt("outchannel", m_messageOutChannel);
+                // m_messageInChannel = config.Configs["IRC"].GetInt("inchannel", m_messageInChannel);
+                m_relayPrivateChannels = config.Configs["IRC"].GetBoolean("relay_private_channels", m_relayPrivateChannels);
+                m_relayPrivateChannels = config.Configs["IRC"].GetBoolean("useworldcomm", m_relayPrivateChannels); //compat
+                m_relayChannel = config.Configs["IRC"].GetInt("relay_private_channel_in", m_relayChannel);
+                m_relayChannel = config.Configs["IRC"].GetInt("inchannel", m_relayChannel);
+                m_accessPassword = config.Configs["IRC"].GetString("access_password",m_accessPassword);
+                // m_useWorldComm = config.Configs["IRC"].GetBoolean("useworldcomm", m_useWorldComm);
+
+                if (m_server != null && m_baseNick != null && m_ircChannel != null)
+                {
+                    if (m_randomizeNick)
+                    {
+                        m_nick = m_baseNick + Util.RandomClass.Next(1, 99);
+                    }
+                    m_enabled = true;
+                }
+            }
+            catch (Exception ex)
+            {
+                m_log.Error("[IRCConnector]: Incomplete IRC configuration, skipping IRC bridge configuration");
+                m_log.DebugFormat("[IRCConnector] Incomplete IRC configuration: {0}", ex.ToString());
+            }
+
+            if (null == m_watchdog)
+            {
+                m_watchdog = new Thread(WatchdogRun);
+                m_watchdog.Name = "IRCWatchdog";
+                m_watchdog.IsBackground = true;
+            }
+        }
+
+        public void Start()
+        {
+            if (!m_watchdog.IsAlive) 
+            {
+                m_watchdog.Start();
+                ThreadTracker.Add(m_watchdog);
+            }
+        }
+
+        public void AddScene(Scene scene)
+        {
+            lock(m_syncConnect) m_scenes.Add(scene);
+        }
+
+        public bool Connect()
+        {
+            lock (m_syncConnect)
+            {
+                try
+                {
+                    if (m_connected) return true;
+
+                    m_tcp = new TcpClient(m_server, (int)m_port);
+                    m_stream = m_tcp.GetStream();
+                    m_reader = new StreamReader(m_stream);
+                    m_writer = new StreamWriter(m_stream);
+
+                    m_log.DebugFormat("[IRCConnector]: Connected to {0}:{1}", m_server, m_port); 
+
+                    m_pinger = new Thread(new ThreadStart(PingRun));
+                    m_pinger.Name = "PingSenderThread";
+                    m_pinger.IsBackground = true;
+                    m_pinger.Start();
+                    ThreadTracker.Add(m_pinger);
+
+                    m_listener = new Thread(new ThreadStart(ListenerRun));
+                    m_listener.Name = "IRCConnectorListenerThread";
+                    m_listener.IsBackground = true;
+                    m_listener.Start();
+                    ThreadTracker.Add(m_listener);
+
+                    m_writer.WriteLine(m_user);
+                    m_writer.Flush();
+                    m_writer.WriteLine(String.Format("NICK {0}", m_nick));
+                    m_writer.Flush();
+                    m_writer.WriteLine(String.Format("JOIN {0}", m_ircChannel));
+                    m_writer.Flush();
+                    m_log.Info("[IRCConnector]: Connection fully established");
+                    m_connected = true;
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("[IRCConnector] cannot connect to {0}:{1}: {2}",
+                                      m_server, m_port, e.Message);
+                }
+                m_log.Debug("[IRCConnector] Connected");
+                return m_connected;
+            }
+        }
+
+        public void Reconnect()
+        {
+            m_connected = false;
+            try
+            {
+                m_listener.Abort();
+                m_pinger.Abort();
+
+                m_writer.Close();
+                m_reader.Close();
+
+                m_tcp.Close();
+            }
+            catch (Exception)
+            {
+            }
+
+            if (m_enabled)
+            {
+                Connect();
+            }
+        }
+
+        public void PrivMsg(string from, string region, string msg)
+        {
+            m_log.DebugFormat("[IRCConnector] Sending message to IRC from {0}: {1}", from, msg);
+
+            // One message to the IRC server
+            try
+            {
+                m_writer.WriteLine(m_privmsgformat, m_ircChannel, from, region, msg);
+                m_writer.Flush();
+                m_log.InfoFormat("[IRCConnector]: PrivMsg {0} in {1}: {2}", from, region, msg);
+            }
+            catch (IOException)
+            {
+                m_log.Error("[IRCConnector]: Disconnected from IRC server.(PrivMsg)");
+                Reconnect();
+            }
+            catch (Exception ex)
+            {
+                m_log.ErrorFormat("[IRCConnector]: PrivMsg exception trap: {0}", ex.ToString());
+            }
+        }
+
+        public void Send(string msg)
+        {
+            try
+            {
+                m_writer.WriteLine(msg);
+                m_writer.Flush();
+                m_log.Info("IRC: Sent command string: " + msg);
+            }
+            catch (IOException)
+            {
+                m_log.Error("[IRCConnector]: Disconnected from IRC server.(PrivMsg)");
+                Reconnect();
+            }
+            catch (Exception ex)
+            {
+                m_log.ErrorFormat("[IRCConnector]: PrivMsg exception trap: {0}", ex.ToString());
+            }
+
+        }
+
+
+        private Dictionary<string, string> ExtractMsg(string input)
+        {
+            //examines IRC commands and extracts any private messages
+            // which will then be reboadcast in the Sim
+
+            m_log.Info("[IRCConnector]: ExtractMsg: " + input);
+            Dictionary<string, string> result = null;
+            string regex = @":(?<nick>[\w-]*)!(?<user>\S*) PRIVMSG (?<channel>\S+) :(?<msg>.*)";
+            Regex RE = new Regex(regex, RegexOptions.Multiline);
+            MatchCollection matches = RE.Matches(input);
+
+            // Get some direct matches $1 $4 is a
+            if ((matches.Count == 0) || (matches.Count != 1) || (matches[0].Groups.Count != 5))
+            {
+                // m_log.Info("[IRCConnector]: Number of matches: " + matches.Count);
+                // if (matches.Count > 0)
+                // {
+                //     m_log.Info("[IRCConnector]: Number of groups: " + matches[0].Groups.Count);
+                // }
+                return null;
+            }
+
+            result = new Dictionary<string, string>();
+            result.Add("nick", matches[0].Groups[1].Value);
+            result.Add("user", matches[0].Groups[2].Value);
+            result.Add("channel", matches[0].Groups[3].Value);
+            result.Add("msg", matches[0].Groups[4].Value);
+
+            return result;
+        }
+
+        public void PingRun()
+        {
+            // IRC keep alive thread
+            // send PING ever 15 seconds
+            while (m_enabled)
+            {
+                try
+                {
+                    if (m_connected == true)
+                    {
+                        m_writer.WriteLine(String.Format("PING :{0}", m_server));
+                        m_writer.Flush();
+                        Thread.Sleep(15000);
+                    }
+                }
+                catch (IOException)
+                {
+                    if (m_enabled)
+                    {
+                        m_log.Error("[IRCConnector]: Disconnected from IRC server.(PingRun)");
+                        Reconnect();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    m_log.ErrorFormat("[IRCConnector]: PingRun exception trap: {0}\n{1}", ex.ToString(), ex.StackTrace);
+                }
+            }
+        }
+
+        static private Vector3 pos = new Vector3(128, 128, 20);
+        public void ListenerRun()
+        {
+            string inputLine;
+
+            while (m_enabled)
+            {
+                try
+                {
+                    while ((m_connected) && ((inputLine = m_reader.ReadLine()) != null))
+                    {
+                        // m_log.Info("[IRCConnector]: " + inputLine);
+
+                        if (inputLine.Contains(m_ircChannel))
+                        {
+                            Dictionary<string, string> data = ExtractMsg(inputLine);
+                            // Any chat ???
+                            if (data != null)
+                            {
+                                OSChatMessage c = new OSChatMessage();
+                                c.Message = data["msg"];
+                                c.Type = ChatTypeEnum.Region;
+                                c.Position = pos;
+                                c.Channel = m_relayPrivateChannels ? m_relayChannel : 0;
+                                c.From = data["nick"];
+                                c.Sender = null;
+                                c.SenderUUID = UUID.Zero;
+
+                                // is message "\001ACTION foo
+                                // bar\001"? -> "/me foo bar"
+                                if ((1 == c.Message[0]) && c.Message.Substring(1).StartsWith("ACTION"))
+                                    c.Message = String.Format("/me {0}", c.Message.Substring(8, c.Message.Length - 9));
+
+                                m_log.DebugFormat("[IRCConnector] ListenerRun from: {0}, {1}", c.From, c.Message);
+
+                                foreach (Scene scene in m_scenes)
+                                {
+                                    c.Scene = scene;
+                                    scene.EventManager.TriggerOnChatBroadcast(this, c);
+                                }
+                            }
+
+                            Thread.Sleep(150);
+                            continue;
+                        }
+
+                        ProcessIRCCommand(inputLine);
+                        Thread.Sleep(150);
+                    }
+                }
+                catch (IOException)
+                {
+                    if (m_enabled)
+                    {
+                        m_log.Error("[IRCConnector]: ListenerRun IOException. Disconnected from IRC server ??? (ListenerRun)");
+                        Reconnect();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    m_log.ErrorFormat("[IRCConnector]: ListenerRun exception trap: {0}\n{1}", ex.ToString(), ex.StackTrace);
+                }
+            }
+        }
+
+        public void BroadcastSim(string sender, string format, params string[] args)
+        {
+            try
+            {
+                OSChatMessage c = new OSChatMessage();
+                c.From = sender;
+                c.Message = String.Format(format, args);
+                c.Type = ChatTypeEnum.Region; // ChatTypeEnum.Say;
+                c.Channel = m_relayPrivateChannels ? m_relayChannel : 0;
+                c.Position = new Vector3(128, 128, 20);
+                c.Sender = null;
+                c.SenderUUID = UUID.Zero;
+
+                m_log.DebugFormat("[IRCConnector] BroadcastSim from {0}: {1}", c.From, c.Message);
+
+                foreach (Scene scene in m_scenes)
+                {
+                    c.Scene = scene;
+                    scene.EventManager.TriggerOnChatBroadcast(this, c);
+                    // // m_scene.EventManager.TriggerOnChatFromWorld(this, c);
+                    // IWorldComm wComm = m_scene.RequestModuleInterface<IWorldComm>();
+                    // wComm.DeliverMessage(ChatTypeEnum.Region, m_messageInChannel, sender, UUID.Zero, c.Message);
+                    // //IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+                    // //wComm.DeliverMessage(ChatTypeEnum.Region, channelID, m_host.Name, m_host.UUID, text);
+
+                }
+            }
+            catch (Exception ex) // IRC gate should not crash Sim
+            {
+                m_log.ErrorFormat("[IRCConnector]: BroadcastSim Exception Trap: {0}\n{1}", ex.ToString(), ex.StackTrace);
+            }
+        }
+
+        public void ProcessIRCCommand(string command)
+        {
+            // m_log.Debug("[IRCConnector]: ProcessIRCCommand:" + command);
+
+            string[] commArgs = new string[command.Split(' ').Length];
+            string c_server = m_server;
+
+            commArgs = command.Split(' ');
+            if (commArgs[0].Substring(0, 1) == ":")
+            {
+                commArgs[0] = commArgs[0].Remove(0, 1);
+            }
+
+            if (commArgs[1] == "002")
+            {
+                // fetch the correct servername
+                // ex: irc.freenode.net -> brown.freenode.net/kornbluth.freenode.net/...
+                //     irc.bluewin.ch -> irc1.bluewin.ch/irc2.bluewin.ch
+
+                c_server = (commArgs[6].Split('['))[0];
+                m_server = c_server;
+            }
+
+            if (commArgs[0] == "ERROR")
+            {
+                m_log.ErrorFormat("[IRCConnector]: IRC SERVER ERROR: {0}", command);
+            }
+
+            if (commArgs[0] == "PING")
+            {
+                string p_reply = "";
+
+                for (int i = 1; i < commArgs.Length; i++)
+                {
+                    p_reply += commArgs[i] + " ";
+                }
+
+                m_writer.WriteLine(String.Format("PONG {0}", p_reply));
+                m_writer.Flush();
+            }
+            else if (commArgs[0] == c_server)
+            {
+                // server message
+                try
+                {
+                    Int32 commandCode = Int32.Parse(commArgs[1]);
+                    switch (commandCode)
+                    {
+                        case (int)ErrorReplies.NicknameInUse:
+                            // Gen a new name
+                            m_nick = m_baseNick + Util.RandomClass.Next(1, 99);
+                            m_log.ErrorFormat("[IRCConnector]: IRC SERVER reports NicknameInUse, trying {0}", m_nick);
+                            // Retry
+                            m_writer.WriteLine(String.Format("NICK {0}", m_nick));
+                            m_writer.Flush();
+                            m_writer.WriteLine(String.Format("JOIN {0}", m_ircChannel));
+                            m_writer.Flush();
+                            break;
+                        case (int)ErrorReplies.NotRegistered:
+                            break;
+                        case (int)Replies.EndOfMotd:
+                            break;
+                    }
+                }
+                catch (Exception)
+                {
+                }
+            }
+            else
+            {
+                // Normal message
+                string commAct = commArgs[1];
+                switch (commAct)
+                {
+                    case "JOIN":
+                        eventIrcJoin(commArgs);
+                        break;
+                    case "PART":
+                        eventIrcPart(commArgs);
+                        break;
+                    case "MODE":
+                        eventIrcMode(commArgs);
+                        break;
+                    case "NICK":
+                        eventIrcNickChange(commArgs);
+                        break;
+                    case "KICK":
+                        eventIrcKick(commArgs);
+                        break;
+                    case "QUIT":
+                        eventIrcQuit(commArgs);
+                        break;
+                    case "PONG":
+                        break; // that's nice
+                }
+            }
+        }
+
+        public void eventIrcJoin(string[] commArgs)
+        {
+            string IrcChannel = commArgs[2];
+            if (IrcChannel.StartsWith(":"))
+                IrcChannel = IrcChannel.Substring(1);
+            string IrcUser = commArgs[0].Split('!')[0];
+            if (m_clientReporting) 
+                BroadcastSim(IrcUser, "/me joins {0}", IrcChannel);
+        }
+
+        public void eventIrcPart(string[] commArgs)
+        {
+            string IrcChannel = commArgs[2];
+            string IrcUser = commArgs[0].Split('!')[0];
+            if (m_clientReporting) 
+                BroadcastSim(IrcUser, "/me parts {0}", IrcChannel);
+        }
+
+        public void eventIrcMode(string[] commArgs)
+        {
+            string UserMode = "";
+            for (int i = 3; i < commArgs.Length; i++)
+            {
+                UserMode += commArgs[i] + " ";
+            }
+
+            if (UserMode.Substring(0, 1) == ":")
+            {
+                UserMode = UserMode.Remove(0, 1);
+            }
+        }
+
+        public void eventIrcNickChange(string[] commArgs)
+        {
+            string UserOldNick = commArgs[0].Split('!')[0];
+            string UserNewNick = commArgs[2].Remove(0, 1);
+            if (m_clientReporting) 
+                BroadcastSim(UserOldNick, "/me is now known as {0}", UserNewNick);
+        }
+
+        public void eventIrcKick(string[] commArgs)
+        {
+            string UserKicker = commArgs[0].Split('!')[0];
+            string UserKicked = commArgs[3];
+            string IrcChannel = commArgs[2];
+            string KickMessage = "";
+            for (int i = 4; i < commArgs.Length; i++)
+            {
+                KickMessage += commArgs[i] + " ";
+            }
+            if (m_clientReporting) 
+                BroadcastSim(UserKicker, "/me kicks kicks {0} off {1} saying \"{2}\"", UserKicked, IrcChannel, KickMessage);
+            if (UserKicked == m_nick)
+            {
+                BroadcastSim(m_nick, "Hey, that was me!!!");
+            }
+        }
+
+        public void eventIrcQuit(string[] commArgs)
+        {
+            string IrcUser = commArgs[0].Split('!')[0];
+            string QuitMessage = "";
+
+            for (int i = 2; i < commArgs.Length; i++)
+            {
+                QuitMessage += commArgs[i] + " ";
+            }
+            if (m_clientReporting)
+                BroadcastSim(IrcUser, "/me quits saying \"{0}\"", QuitMessage);
+        }
+
+        public void Close()
+        {
+            m_writer.WriteLine(String.Format("QUIT :{0} to {1} wormhole to {2} closing",
+                                             m_nick, m_ircChannel, m_server));
+            m_writer.Flush();
+
+            m_connected = false;
+            m_enabled = false;
+
+            //listener.Abort();
+            //pingSender.Abort();
+
+            m_writer.Close();
+            m_reader.Close();
+            m_stream.Close();
+            m_tcp.Close();
+        }
+
+        protected void WatchdogRun()
+        {
+            while (m_enabled)
+            {
+                if (!m_connected) Connect();
+                Thread.Sleep(15000);
+            }
+        }
+    }
+}
\ No newline at end of file