From: Alan Webb (alan_webb@us.ibm.com)

XIRCBrigeModule is transient, will merge it with IRCBridgeModule:
extends/refactors IRCBridgeModule to support channel-per-region (if
desired).

1 files changed, 570 insertions, 0 deletions

diff --git a/OpenSim/Region/Environment/Modules/Avatar/Chat/ChannelState.cs b/OpenSim/Region/Environment/Modules/Avatar/Chat/ChannelState.cs
new file mode 100644
index 0000000..7a3eadf
--- /dev/null
+++ b/OpenSim/Region/Environment/Modules/Avatar/Chat/ChannelState.cs
@@ -0,0 +1,570 @@
+/*
+ * 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.Reflection;
+using System.Text.RegularExpressions;
+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
+{
+
+    // An instance of this class exists for each unique combination of 
+    // IRC chat interface characteristics, as determined by the supplied
+    // configuration file.
+
+    internal class ChannelState
+    {
+
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static Regex arg = new Regex(@"\[[^\[\]]*\]");
+        private static int _idk_ = 0;
+
+        // These are the IRC Connector configurable parameters with hard-wired
+        // default values (retained for compatability).
+
+        internal string Server               = null;
+        internal string IrcChannel           = null;
+        internal string BaseNickname         = "OSimBot";
+        internal uint   Port                 = 6667;
+        internal string User                 = "USER OpenSimBot 8 * :I'm an OpenSim to IRC bot";
+
+        internal bool   ClientReporting      = true;
+        internal bool   RelayPrivateChannels = false;
+        internal int    RelayChannel         = 1;
+
+        // Connector agnostic parameters. These values are NOT shared with the
+        // connector and do not differentiate at an IRC level
+
+        internal string PrivateMessageFormat = "PRIVMSG {0} :<{2}> {1} {3}";
+        internal string NoticeMessageFormat  = "PRIVMSG {0} :<{2}> {3}";
+        internal int    RelayChannelOut      = -1;
+        internal bool   RandomizeNickname    = true;
+        internal string AccessPassword       = "badkitty";
+        internal bool   CommandsEnabled      = false;
+        internal int    CommandChannel       = -1;
+        internal int    ConnectDelay         = 10;
+        internal int    PingDelay            = 15;
+        internal string DefaultZone          = "Sim";
+
+        // IRC connector reference
+
+        internal XIRCConnector irc           = null;
+
+        internal int idn                     = _idk_++;
+
+        // List of regions dependent upon this connection
+
+        internal List<RegionState> clientregions = new List<RegionState>();
+
+        // Needed by OpenChannel
+
+        internal ChannelState()
+        {
+        }
+
+        // This constructor is used by the Update* methods. A copy of the
+        // existing channel state is created, and distinguishing characteristics
+        // are copied across.
+
+        internal ChannelState(ChannelState model)
+        {
+            Server               = model.Server;
+            IrcChannel           = model.IrcChannel;
+            Port                 = model.Port;
+            BaseNickname         = model.BaseNickname;
+            RandomizeNickname    = model.RandomizeNickname;
+            User                 = model.User;
+            CommandsEnabled      = model.CommandsEnabled;
+            CommandChannel       = model.CommandChannel;
+            RelayPrivateChannels = model.RelayPrivateChannels;
+            RelayChannelOut      = model.RelayChannelOut;
+            RelayChannel         = model.RelayChannel;
+            PrivateMessageFormat = model.PrivateMessageFormat;
+            NoticeMessageFormat  = model.NoticeMessageFormat;
+            ClientReporting      = model.ClientReporting;
+            AccessPassword       = model.AccessPassword;
+            DefaultZone          = model.DefaultZone;
+            ConnectDelay         = model.ConnectDelay;
+            PingDelay            = model.PingDelay;
+        }
+        
+        // Read the configuration file, performing variable substitution and any
+        // necessary aliasing. See accompanying documentation for how this works.
+        // If you don't need variables, then this works exactly as before.
+        // If either channel or server are not specified, the request fails.
+
+        internal static void OpenChannel(RegionState rs, IConfig config)
+        {
+
+            // Create a new instance of a channel. This may not actually
+            // get used if an equivalent channel already exists.
+
+            ChannelState cs = new ChannelState();
+
+            // Read in the configuration file and filter everything for variable
+            // subsititution.
+
+            m_log.DebugFormat("[IRC-Channel-{0}] Initial request by Region {1} to connect to IRC", cs.idn, rs.Region);
+
+            cs.Server               = Substitute(rs, config.GetString("server", null));
+            m_log.DebugFormat("[IRC-Channel-{0}] Server : <{1}>", cs.idn, cs.Server);
+            cs.IrcChannel           = Substitute(rs, config.GetString("channel", null));
+            m_log.DebugFormat("[IRC-Channel-{0}] IrcChannel : <{1}>", cs.idn, cs.IrcChannel);
+            cs.Port                 = Convert.ToUInt32(Substitute(rs, config.GetString("port", Convert.ToString(cs.Port))));
+            m_log.DebugFormat("[IRC-Channel-{0}] Port : <{1}>", cs.idn, cs.Port);
+            cs.BaseNickname         = Substitute(rs, config.GetString("nick", cs.BaseNickname));
+            m_log.DebugFormat("[IRC-Channel-{0}] BaseNickname : <{1}>", cs.idn, cs.BaseNickname);
+            cs.RandomizeNickname    = Convert.ToBoolean(Substitute(rs, config.GetString("randomize_nick", Convert.ToString(cs.RandomizeNickname))));
+            m_log.DebugFormat("[IRC-Channel-{0}] RandomizeNickname : <{1}>", cs.idn, cs.RandomizeNickname);
+            cs.RandomizeNickname    = Convert.ToBoolean(Substitute(rs, config.GetString("nicknum", Convert.ToString(cs.RandomizeNickname))));
+            m_log.DebugFormat("[IRC-Channel-{0}] RandomizeNickname : <{1}>", cs.idn, cs.RandomizeNickname);
+            cs.User                 = Substitute(rs, config.GetString("username", cs.User));
+            m_log.DebugFormat("[IRC-Channel-{0}] User : <{1}>", cs.idn, cs.User);
+            cs.CommandsEnabled      = Convert.ToBoolean(Substitute(rs, config.GetString("commands_enabled", Convert.ToString(cs.CommandsEnabled))));
+            m_log.DebugFormat("[IRC-Channel-{0}] CommandsEnabled : <{1}>", cs.idn, cs.CommandsEnabled);
+            cs.CommandChannel       = Convert.ToInt32(Substitute(rs, config.GetString("commandchannel", Convert.ToString(cs.CommandChannel))));
+            m_log.DebugFormat("[IRC-Channel-{0}] CommandChannel : <{1}>", cs.idn, cs.CommandChannel);
+            cs.CommandChannel       = Convert.ToInt32(Substitute(rs, config.GetString("command_channel", Convert.ToString(cs.CommandChannel))));
+            m_log.DebugFormat("[IRC-Channel-{0}] CommandChannel : <{1}>", cs.idn, cs.CommandChannel);
+            cs.RelayPrivateChannels = Convert.ToBoolean(Substitute(rs, config.GetString("relay_private_channels", Convert.ToString(cs.RelayPrivateChannels))));
+            m_log.DebugFormat("[IRC-Channel-{0}] RelayPrivateChannels : <{1}>", cs.idn, cs.RelayPrivateChannels);
+            cs.RelayPrivateChannels = Convert.ToBoolean(Substitute(rs, config.GetString("useworldcomm", Convert.ToString(cs.RelayPrivateChannels))));
+            m_log.DebugFormat("[IRC-Channel-{0}] RelayPrivateChannels : <{1}>", cs.idn, cs.RelayPrivateChannels);
+            cs.RelayChannelOut      = Convert.ToInt32(Substitute(rs, config.GetString("relay_private_channel_out", Convert.ToString(cs.RelayChannelOut))));
+            m_log.DebugFormat("[IRC-Channel-{0}] RelayChannelOut : <{1}>", cs.idn, cs.RelayChannelOut);
+            cs.RelayChannel         = Convert.ToInt32(Substitute(rs, config.GetString("relay_private_channel_in", Convert.ToString(cs.RelayChannel))));
+            m_log.DebugFormat("[IRC-Channel-{0}] RelayChannel : <{1}>", cs.idn, cs.RelayChannel);
+            cs.RelayChannel         = Convert.ToInt32(Substitute(rs, config.GetString("inchannel", Convert.ToString(cs.RelayChannel))));
+            m_log.DebugFormat("[IRC-Channel-{0}] RelayChannel : <{1}>", cs.idn, cs.RelayChannel);
+            cs.PrivateMessageFormat = Substitute(rs, config.GetString("msgformat", cs.PrivateMessageFormat));
+            m_log.DebugFormat("[IRC-Channel-{0}] PrivateMessageFormat : <{1}>", cs.idn, cs.PrivateMessageFormat);
+            cs.NoticeMessageFormat = Substitute(rs, config.GetString("noticeformat", cs.NoticeMessageFormat));
+            m_log.DebugFormat("[IRC-Channel-{0}] NoticeMessageFormat : <{1}>", cs.idn, cs.NoticeMessageFormat);
+            cs.ClientReporting      = Convert.ToInt32(Substitute(rs, config.GetString("verbosity", cs.ClientReporting?"1":"0"))) > 0;
+            m_log.DebugFormat("[IRC-Channel-{0}] ClientReporting : <{1}>", cs.idn, cs.ClientReporting);
+            cs.ClientReporting      = Convert.ToBoolean(Substitute(rs, config.GetString("report_clients", Convert.ToString(cs.ClientReporting))));
+            m_log.DebugFormat("[IRC-Channel-{0}] ClientReporting : <{1}>", cs.idn, cs.ClientReporting);
+            cs.AccessPassword       = Substitute(rs, config.GetString("access_password", cs.AccessPassword));
+            m_log.DebugFormat("[IRC-Channel-{0}] AccessPassword : <{1}>", cs.idn, cs.AccessPassword);
+            cs.DefaultZone          = Substitute(rs, config.GetString("fallback_region", cs.DefaultZone));
+            m_log.DebugFormat("[IRC-Channel-{0}] DefaultZone : <{1}>", cs.idn, cs.DefaultZone);
+            cs.ConnectDelay      = Convert.ToInt32(Substitute(rs, config.GetString("connect_delay", Convert.ToString(cs.ConnectDelay))));
+            m_log.DebugFormat("[IRC-Channel-{0}] ConnectDelay : <{1}>", cs.idn, cs.ConnectDelay);
+            cs.PingDelay      = Convert.ToInt32(Substitute(rs, config.GetString("ping_delay", Convert.ToString(cs.PingDelay))));
+            m_log.DebugFormat("[IRC-Channel-{0}] PingDelay : <{1}>", cs.idn, cs.PingDelay);
+
+            // Fail if fundamental information is still missing
+
+            if (cs.Server == null || cs.IrcChannel == null || cs.BaseNickname == null || cs.User == null)
+                throw new Exception(String.Format("[IRC-Channel-{0}] Invalid configuration for region {1}", cs.idn, rs.Region));
+
+            m_log.InfoFormat("[IRC-Channel-{0}] Configuration for Region {1} is valid", cs.idn, rs.Region);
+            m_log.InfoFormat("[IRC-Channel-{0}]    Server = {1}", cs.idn, cs.Server);
+            m_log.InfoFormat("[IRC-Channel-{0}]   Channel = {1}", cs.idn, cs.IrcChannel);
+            m_log.InfoFormat("[IRC-Channel-{0}]      Port = {1}", cs.idn, cs.Port);
+            m_log.InfoFormat("[IRC-Channel-{0}]  Nickname = {1}", cs.idn, cs.BaseNickname);
+            m_log.InfoFormat("[IRC-Channel-{0}]      User = {1}", cs.idn, cs.User);
+
+            // Set the channel state for this region
+
+            rs.cs = Integrate(rs, cs);
+
+        }
+
+        // An initialized channel state instance is passed in. If an identical
+        // channel state instance already exists, then the existing instance
+        // is used to replace the supplied value.
+        // If the instance matches with respect to IRC, then the underlying
+        // IRCConnector is assigned to the supplied channel state and the
+        // updated value is returned.
+        // If there is no match, then the supplied instance is completed by
+        // creating and assigning an instance of an IRC connector.
+
+        private static ChannelState Integrate(RegionState rs, ChannelState p_cs)
+        {
+
+            ChannelState cs = p_cs;
+
+            // Check to see if we have an existing server/channel setup that can be used
+            // In the absence of variable substitution this will always resolve to the 
+            // same ChannelState instance, and the table will only contains a single 
+            // entry, so the performance considerations for the existing behavior are 
+            // zero. Only the IRC connector is shared, the ChannelState still contains
+            // values that, while independent of the IRC connetion, do still distinguish 
+            // this region's behavior.
+
+            foreach (ChannelState xcs in XIRCBridgeModule.m_channels)
+            {
+                if (cs.IsAPerfectMatchFor(xcs))
+                {
+                    m_log.DebugFormat("[IRC-Channel-{0}]  Channel state matched", cs.idn);
+                    cs = xcs;
+                    break;
+                }
+                if (cs.IsAConnectionMatchFor(xcs))
+                {
+                    m_log.DebugFormat("[IRC-Channel-{0}]  Channel matched", cs.idn);
+                    cs.irc = xcs.irc;
+                    break;
+                }
+            }
+
+            // No entry was found, so this is going to be a new entry.
+
+            if (cs.irc == null)
+            {
+
+                m_log.DebugFormat("[IRC-Channel-{0}]  New channel required", cs.idn);
+
+                if ((cs.irc = new XIRCConnector(cs)) != null)
+                {
+                    XIRCBridgeModule.m_channels.Add(cs);
+
+                    m_log.InfoFormat("[IRC-Channel-{0}] New channel initialized for {1}, nick: {2}, commands {3}, private channels {4}", 
+                                 cs.idn, rs.Region, cs.DefaultZone, 
+                                 cs.CommandsEnabled ? "enabled" : "not enabled",
+                                 cs.RelayPrivateChannels ? "relayed" : "not relayed");
+                }
+                else
+                {
+                    string txt = String.Format("[IRC-Channel-{0}] Region {1} failed to connect to channel {2} on server {3}:{4}",
+                            cs.idn, rs.Region, cs.IrcChannel, cs.Server, cs.Port);
+                    m_log.Error(txt);
+                    throw new Exception(txt);
+                }
+            }
+            else
+            {
+                m_log.InfoFormat("[IRC-Channel-{0}] Region {1} reusing existing connection to channel {2} on server {3}:{4}",
+                        cs.idn, rs.Region, cs.IrcChannel, cs.Server, cs.Port);
+            }
+
+            m_log.InfoFormat("[IRC-Channel-{0}] Region {1} connected to channel {2} on server {3}:{4}",
+                        cs.idn, rs.Region, cs.IrcChannel, cs.Server, cs.Port);
+
+            // We're finally ready to commit ourselves
+
+            return cs;
+
+        }
+
+        // These routines allow differentiating changes to 
+        // the underlying channel state. If necessary, a
+        // new channel state will be created.
+
+        internal ChannelState UpdateServer(RegionState rs, string server)
+        {
+            RemoveRegion(rs);
+            ChannelState cs = new ChannelState(this);
+            cs.Server = server;
+            cs = Integrate(rs, cs);
+            cs.AddRegion(rs);
+            return cs;
+        }
+
+        internal ChannelState UpdatePort(RegionState rs, string port)
+        {
+            RemoveRegion(rs);
+            ChannelState cs = new ChannelState(this);
+            cs.Port = Convert.ToUInt32(port);
+            cs = Integrate(rs, cs);
+            cs.AddRegion(rs);
+            return cs;
+        }
+
+        internal ChannelState UpdateChannel(RegionState rs, string channel)
+        {
+            RemoveRegion(rs);
+            ChannelState cs = new ChannelState(this);
+            cs.IrcChannel = channel;
+            cs = Integrate(rs, cs);
+            cs.AddRegion(rs);
+            return cs;
+        }
+
+        internal ChannelState UpdateNickname(RegionState rs, string nickname)
+        {
+            RemoveRegion(rs);
+            ChannelState cs = new ChannelState(this);
+            cs.BaseNickname = nickname;
+            cs = Integrate(rs, cs);
+            cs.AddRegion(rs);
+            return cs;
+        }
+
+        internal ChannelState UpdateClientReporting(RegionState rs, string cr)
+        {
+            RemoveRegion(rs);
+            ChannelState cs = new ChannelState(this);
+            cs.ClientReporting = Convert.ToBoolean(cr);
+            cs = Integrate(rs, cs);
+            cs.AddRegion(rs);
+            return cs;
+        }
+
+        internal ChannelState UpdateRelayIn(RegionState rs, string channel)
+        {
+            RemoveRegion(rs);
+            ChannelState cs = new ChannelState(this);
+            cs.RelayChannel = Convert.ToInt32(channel);
+            cs = Integrate(rs, cs);
+            cs.AddRegion(rs);
+            return cs;
+        }
+
+        internal ChannelState UpdateRelayOut(RegionState rs, string channel)
+        {
+            RemoveRegion(rs);
+            ChannelState cs = new ChannelState(this);
+            cs.RelayChannelOut = Convert.ToInt32(channel);
+            cs = Integrate(rs, cs);
+            cs.AddRegion(rs);
+            return cs;
+        }
+
+        // Determine whether or not this is a 'new' channel. Only those
+        // attributes that uniquely distinguish an IRC connection should
+        // be included here (and only those attributes should really be
+        // in the ChannelState structure)
+
+        private bool IsAConnectionMatchFor(ChannelState cs)
+        {
+            return ( 
+                Server == cs.Server && 
+                IrcChannel == cs.IrcChannel &&
+                Port == cs.Port &&
+                BaseNickname == cs.BaseNickname &&
+                User == cs.User
+            );
+        }
+
+        // This level of obsessive matching allows us to produce
+        // a minimal overhead int he case of a server which does 
+        // need to differentiate IRC at a region level.
+
+        private bool IsAPerfectMatchFor(ChannelState cs)
+        {
+            return ( IsAConnectionMatchFor(cs) &&
+
+                RelayChannelOut == cs.RelayChannelOut &&
+                PrivateMessageFormat == cs.PrivateMessageFormat &&
+                NoticeMessageFormat == cs.NoticeMessageFormat &&
+                RandomizeNickname == cs.RandomizeNickname &&
+                AccessPassword == cs.AccessPassword &&
+                CommandsEnabled == cs.CommandsEnabled &&
+                CommandChannel == cs.CommandChannel &&
+                DefaultZone == cs.DefaultZone &&
+                RelayPrivateChannels == cs.RelayPrivateChannels &&
+                RelayChannel == cs.RelayChannel &&
+                ClientReporting == cs.ClientReporting
+            );
+        }
+
+        // This function implements the variable substitution mechanism 
+        // for the configuration values. Each string read from the 
+        // configuration file is scanned for '[...]' enclosures. Each
+        // one that is found is replaced by either a runtime variable
+        // (%xxx) or an existing configuration key. When no further
+        // substitution is possible, the remaining string is returned
+        // to the caller. This allows for arbitrarily nested
+        // enclosures.
+
+        private static string Substitute(RegionState rs, string instr)
+        {
+
+            string result = instr;
+
+            if (result == null || result.Length == 0)
+                return result;
+
+            // Repeatedly scan the string until all possible
+            // substitutions have been performed.
+
+            while (arg.IsMatch(result))
+            {
+
+                string vvar = arg.Match(result).ToString();
+                string var  = vvar.Substring(1,vvar.Length-2).Trim();
+
+                switch (var.ToLower())
+                {
+                    case "%region"  :
+                        result = result.Replace(vvar, rs.Region);
+                        break;
+                    case "%host"    :
+                        result = result.Replace(vvar, rs.Host);
+                        break;
+                    case "%master1" :
+                        result = result.Replace(vvar, rs.MA1);
+                        break;
+                    case "%master2" :
+                        result = result.Replace(vvar, rs.MA2);
+                        break;
+                    case "%locx"    :
+                        result = result.Replace(vvar, rs.LocX);
+                        break;
+                    case "%locy"    :
+                        result = result.Replace(vvar, rs.LocY);
+                        break;
+                    case "%k"       :
+                        result = result.Replace(vvar, rs.IDK);
+                        break;
+                    default         :
+                        result = result.Replace(vvar, rs.config.GetString(var,var));
+                        break;
+                }
+            }
+
+            return result;
+
+        }
+
+        public void Close()
+        {
+
+            m_log.InfoFormat("[IRC-Channel-{0}] Closing channel <{1} to server <{2}:{3}>",
+                    idn, IrcChannel, Server, Port);
+
+            m_log.InfoFormat("[IRC-Channel-{0}] There are {1} active clients",
+                    idn, clientregions.Count);
+
+            irc.Close();
+
+        }
+
+        public void Open()
+        {
+            m_log.InfoFormat("[IRC-Channel-{0}] Opening channel <{1} to server <{2}:{3}>",
+                    idn, IrcChannel, Server, Port);
+
+            irc.Open();
+
+        }
+
+        // These are called by each region that attaches to this channel. The call affects
+        // only the relationship of the region with the channel. Not the channel to IRC
+        // relationship (unless it is closed and we want it open).
+
+        public void Open(RegionState rs)
+        {
+            AddRegion(rs);
+            Open();
+        }
+
+        public void Close(RegionState rs)
+        {
+            RemoveRegion(rs);
+        }
+
+        // Add a client region to this channel if it is not already known
+
+        public void AddRegion(RegionState rs)
+        {
+            m_log.InfoFormat("[IRC-Channel-{0}] Adding region {1} to channel <{2} to server <{3}:{4}>",
+                    idn, rs.Region, IrcChannel, Server, Port);
+            if (!clientregions.Contains(rs))
+            {
+                clientregions.Add(rs);
+                lock (irc) irc.depends++;
+            }
+        }
+
+        // Remove a client region from the channel. If this is the last
+        // region, then clean up the channel. The connector will clean itself
+        // up if it finds itself about to be GC'd.
+
+        public void RemoveRegion(RegionState rs)
+        {
+
+            m_log.InfoFormat("[IRC-Channel-{0}] Removing region {1} from channel <{2} to server <{3}:{4}>",
+                    idn, rs.Region, IrcChannel, Server, Port);
+
+            if (clientregions.Contains(rs))
+            {
+                clientregions.Remove(rs);
+                lock (irc) irc.depends--;
+            }
+
+        }
+
+        // This function is lifted from the IRCConnector because it 
+        // contains information that is not differentiating from an
+        // IRC point-of-view.
+
+        public static void OSChat(XIRCConnector p_irc, OSChatMessage c, bool cmsg)
+        {
+
+            // m_log.DebugFormat("[IRC-OSCHAT] from {0}:{1}", p_irc.Server, p_irc.IrcChannel);
+
+            try
+            {
+
+                // Scan through the set of unique channel configuration for those
+                // that belong to this connector. And then forward the message to 
+                // all regions known to those channels.
+                // Note that this code is responsible for completing some of the
+                // settings for the inbound OSChatMessage
+
+                foreach (ChannelState cs in XIRCBridgeModule.m_channels)
+                {
+                    if ( p_irc == cs.irc)
+                    {
+
+                        // This non-IRC differentiator moved to here
+
+                        if (cmsg && !cs.ClientReporting)
+                            continue;
+
+                        // This non-IRC differentiator moved to here
+
+                        c.Channel = (cs.RelayPrivateChannels ? cs.RelayChannel : 0);
+
+                        foreach (RegionState region in cs.clientregions)
+                        {
+                            region.OSChat(cs.irc, c);
+                        }
+
+                    }
+                }
+
+            }
+            catch (Exception ex)
+            {
+                m_log.ErrorFormat("[IRC-OSCHAT]: BroadcastSim Exception: {0}", ex.Message);
+                m_log.Debug(ex);
+            }
+        }
+    }
+}