mirror of
https://github.com/opensim/opensim.git
synced 2026-05-18 04:45:35 +08:00
a1fe54baa0
config options, this has NO default, if you use the IRC module, you MUST add this setting to your ini file.
630 lines
28 KiB
C#
630 lines
28 KiB
C#
/*
|
|
* 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.Framework.Interfaces;
|
|
using OpenSim.Region.Framework.Scenes;
|
|
|
|
namespace OpenSim.Region.OptionalModules.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;
|
|
private static int DEBUG_CHANNEL = 2147483647;
|
|
|
|
// These are the IRC Connector configurable parameters with hard-wired
|
|
// default values (retained for compatability).
|
|
|
|
internal string Server = null;
|
|
internal string Password = null;
|
|
internal string IrcChannel = null;
|
|
internal string BaseNickname = "OSimBot";
|
|
internal uint Port = 6667;
|
|
internal string User = null;
|
|
|
|
internal bool ClientReporting = true;
|
|
internal bool RelayChat = true;
|
|
internal bool RelayPrivateChannels = false;
|
|
internal int RelayChannel = 1;
|
|
internal List<int> ValidInWorldChannels = new List<int>();
|
|
|
|
// 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 bool CommandsEnabled = false;
|
|
internal int CommandChannel = -1;
|
|
internal int ConnectDelay = 10;
|
|
internal int PingDelay = 15;
|
|
internal string DefaultZone = "Sim";
|
|
|
|
internal string _accessPassword = String.Empty;
|
|
internal Regex AccessPasswordRegex = null;
|
|
internal string AccessPassword
|
|
{
|
|
get { return _accessPassword; }
|
|
set
|
|
{
|
|
_accessPassword = value;
|
|
AccessPasswordRegex = new Regex(String.Format(@"^{0},\s*(?<avatar>[^,]+),\s*(?<message>.+)$", _accessPassword),
|
|
RegexOptions.Compiled);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// IRC connector reference
|
|
|
|
internal IRCConnector 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;
|
|
Password = model.Password;
|
|
IrcChannel = model.IrcChannel;
|
|
Port = model.Port;
|
|
BaseNickname = model.BaseNickname;
|
|
RandomizeNickname = model.RandomizeNickname;
|
|
User = model.User;
|
|
CommandsEnabled = model.CommandsEnabled;
|
|
CommandChannel = model.CommandChannel;
|
|
RelayChat = model.RelayChat;
|
|
RelayPrivateChannels = model.RelayPrivateChannels;
|
|
RelayChannelOut = model.RelayChannelOut;
|
|
RelayChannel = model.RelayChannel;
|
|
ValidInWorldChannels = model.ValidInWorldChannels;
|
|
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.Password = Substitute(rs, config.GetString("password", null));
|
|
// probably not a good idea to put a password in the log file
|
|
cs.User = Substitute(rs, config.GetString("user", null));
|
|
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.RelayChat = Convert.ToBoolean(Substitute(rs, config.GetString("relay_chat", Convert.ToString(cs.RelayChat))));
|
|
m_log.DebugFormat("[IRC-Channel-{0}] RelayChat : <{1}>", cs.idn, cs.RelayChat);
|
|
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.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);
|
|
cs.AccessPassword = Substitute(rs, config.GetString("access_password", cs.AccessPassword));
|
|
m_log.DebugFormat("[IRC-Channel-{0}] AccessPassword : <{1}>", cs.idn, cs.AccessPassword);
|
|
|
|
|
|
// 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
|
|
|
|
if (cs.RelayChat)
|
|
{
|
|
cs.ValidInWorldChannels.Add(0);
|
|
cs.ValidInWorldChannels.Add(DEBUG_CHANNEL);
|
|
}
|
|
|
|
if (cs.RelayPrivateChannels)
|
|
cs.ValidInWorldChannels.Add(cs.RelayChannelOut);
|
|
|
|
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.
|
|
|
|
lock (IRCBridgeModule.m_channels)
|
|
{
|
|
|
|
foreach (ChannelState xcs in IRCBridgeModule.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 IRCConnector(cs)) != null)
|
|
{
|
|
|
|
IRCBridgeModule.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} associated with 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 &&
|
|
RelayChat == cs.RelayChat &&
|
|
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.
|
|
|
|
// m_log.DebugFormat("[IRC-Channel] Parse[1]: {0}", result);
|
|
|
|
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;
|
|
}
|
|
// m_log.DebugFormat("[IRC-Channel] Parse[2]: {0}", result);
|
|
}
|
|
|
|
// m_log.DebugFormat("[IRC-Channel] Parse[3]: {0}", result);
|
|
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();
|
|
}
|
|
|
|
// Close is called to ensure that the IRC session is terminated if this is the
|
|
// only client.
|
|
|
|
public void Close(RegionState rs)
|
|
{
|
|
RemoveRegion(rs);
|
|
lock (IRCBridgeModule.m_channels)
|
|
{
|
|
if (clientregions.Count == 0)
|
|
{
|
|
Close();
|
|
IRCBridgeModule.m_channels.Remove(this);
|
|
m_log.InfoFormat("[IRC-Channel-{0}] Region {1} is last user of channel <{2}> to server <{3}:{4}>",
|
|
idn, rs.Region, IrcChannel, Server, Port);
|
|
m_log.InfoFormat("[IRC-Channel-{0}] Removed", idn);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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(IRCConnector 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
|
|
|
|
lock (IRCBridgeModule.m_channels)
|
|
{
|
|
foreach (ChannelState cs in IRCBridgeModule.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);
|
|
}
|
|
}
|
|
}
|
|
}
|