| public Connect ( string addresslist, int port ) : void | ||
| addresslist | string | The list of server hostnames. |
| port | int | The TCP port the server listens on. |
| Résultat | void | |
public void Connect()
{
IrcClient = new IrcClient();
IrcClient.OnConnected += OnConnected;
IrcClient.OnConnecting += OnConnecting;
IrcClient.OnDisconnected += OnDisconnected;
//IrcClient.OnReadLine += OnReadLine;
IrcClient.OnPing += OnPing;
IrcClient.OnRawMessage += OnRawMessage;
IrcClient.AutoRetry = Convert.ToBoolean(Connection.auto_retry);
IrcClient.AutoRetryDelay = Convert.ToInt32(Connection.auto_retry_delay);
IrcClient.AutoReconnect = Convert.ToBoolean(Connection.auto_reconnect);
IrcClient.AutoRelogin = Convert.ToBoolean(Connection.auto_relogin);
IrcClient.AutoRejoin = Convert.ToBoolean(Connection.auto_rejoin);
IrcClient.AutoRejoinOnKick = Convert.ToBoolean(Connection.auto_rejoin_on_kick);
IrcClient.AutoNickHandling = Convert.ToBoolean(Connection.auto_nick_handling);
try
{
IrcClient.Connect(Connection.hostname, Convert.ToInt32(Connection.port));
}
catch (Exception e)
{
Console.WriteLine("Failed to connect: " + e.Message);
}
}
public static void IrcClientList()
{
IrcClient irc = new IrcClient();
irc.OnRawMessage += new IrcEventHandler(IrcClientListCallback);
irc.Connect(SERVER, PORT);
irc.Login(NICK, REALNAME);
irc.RfcList(CHANNEL);
irc.Listen();
}
public Client()
{
instance = new IrcClient();
instance.OnConnected += clientInstance_OnConnected;
instance.OnRegistered += clientInstance_OnRegistered;
instance.Connect(Server, Port);
Timer timer = new Timer(15 * 1000);
timer.Elapsed += saveGlobalStorage;
timer.Start();
}
protected override void Connect()
{
_ircClient = new SIRC4N.IrcClient();
_ircClient.OnRawMessage += _ircClient_OnRawMessage;
_ircClient.OnRegistered += _ircClient_OnRegistered;
_ircClient.OnChannelMessage += _ircClient_OnPrivmsg;
_ircClient.OnQueryMessage += _ircClient_OnPrivmsg;
_ircClient.OnQueryNotice += _ircClient_OnQueryNotice;
_ircClient.Connect(_host, _port);
_ircClient.Login(_nickname, _nickname);
_listenThread = new Thread(_ircClient.Listen);
_listenThread.Start();
_ircClient.OnDisconnected += HandleDisconnect;
}
private void Connect()
{
_ircClient = new SIRC4N.IrcClient();
_ircClient.OnDisconnected += _ircClient_OnDisconnected;
_ircClient.OnRawMessage += _ircClient_OnRawMessage;
_ircClient.OnRegistered += _ircClient_OnRegistered;
_ircClient.OnChannelAction += _ircClient_OnChannelAction;
_ircClient.OnChannelMessage += _ircClient_OnChannelMessage;
_ircClient.OnQueryAction += _ircClient_OnQueryAction;
_ircClient.OnQueryMessage += _ircClient_OnQueryMessage;
_ircClient.OnQueryNotice += _ircClient_OnQueryNotice;
_ircClient.Connect(Server.Host, Server.Port ?? 6667);
_ircClient.Login(Network.BotNickname, Network.BotRealname);
listenThread = new Thread(_ircClient.Listen);
listenThread.Start();
}
public BetWorker(MainViewModel viewModel)
{
_viewModel = viewModel;
_bets = new List<Bet>();
_users = new List<User>();
_ircClient = new IrcClient();
_ircClient.Connect(_server, _port);
_ircClient.WriteLine(Rfc2812.Nick(_botName), Priority.Critical);
_ircClient.WriteLine(Rfc2812.User(_botName, 0, _botName), Priority.Critical);
_ircClient.WriteLine(Rfc2812.Join(_channel));
_listenThread = new Thread(() =>
{
_ircClient.OnChannelMessage += _ircClient_OnChannelMessage;
_ircClient.OnJoin += _ircClient_OnJoin;
_ircClient.OnPart += _ircClient_OnPart;
_ircClient.OnQuit += _ircClient_OnQuit;
_ircClient.Listen();
});
_listenThread.Start();
}
private static void Run()
{
while( !stopRequested ) {
try {
irc = new IrcClient();
irc.Encoding = System.Text.Encoding.UTF8;
irc.SendDelay = 200;
irc.ActiveChannelSyncing = true;
irc.OnRawMessage += new IrcEventHandler( irc_OnRawMessage );
irc.Connect( settings.IrcHost, settings.IrcPort );
irc.Login( NICK, NICK, 0, NICK, settings.IrcPassword );
irc.RfcJoin( settings.IrcChannelName );
irc.Listen();
if( irc.IsConnected ) {
irc.Disconnect();
}
} catch( Exception e ) {
Console.WriteLine( e.Message );
}
if( !stopRequested ) {
Thread.Sleep( TimeSpan.FromSeconds( 10 ) );
}
}
}
public IrcMaster(string host, int port)
{
// Init IRC client
client = new IrcClient();
client.Encoding = Encoding.UTF8;
client.ActiveChannelSyncing = true;
client.SendDelay = 1;
Log.Info("Connecting to "+host+":"+port+".");
client.Connect(host, port);
if(!client.IsConnected) {
throw new Exception("Could not connect to the server.");
}
// Hook up events
client.OnChannelMessage += new IrcEventHandler(OnChannelMessage);
client.OnQueryMessage += new IrcEventHandler(OnQueryMessage);
client.OnKick += new KickEventHandler(OnKick);
client.OnDisconnected += new EventHandler(OnDisconnect);
client.OnJoin += new JoinEventHandler(OnJoin);
client.OnPart += new PartEventHandler(OnPart);
client.OnQuit += new QuitEventHandler(OnQuit);
}
public override void Loop()
{
while (true)
{
_client = new IrcClient
{
AutoJoinOnInvite = true,
AutoReconnect = true,
AutoRejoin = true,
AutoRejoinOnKick = true,
AutoRelogin = true,
AutoRetry = true
};
var mre = new ManualResetEvent(false);
_client.OnJoin += (sender, args) =>
Output("I have joined " + args.Channel);
_client.OnChannelMessage += (sender, args) =>
Handle(args.Data.Message);
_client.OnConnected += (sender, args) =>
{
mre.Set();
_client.RfcJoin("#jarvis");
};
_client.Connect("irc.clossit.com", 6668);
_client.Login("Jarvis", "Jarvis");
new Thread(() => _client.Listen()).Start();
mre.WaitOne(30.Seconds());
while (_client.IsConnected)
{
5.Seconds().Sleep();
}
Output("I have lost connection to I.R.C");
}
}
static void Main()
{
var client = new IrcClient() {
ActiveChannelSyncing = true
};
client.Connect("irc.oftc.net", 6667);
client.Login("smuxi-bot", "smuxi bot");
client.OnRegistered += delegate {
client.RfcJoin("#smuxi");
};
var client2 = new IrcClient() {
ActiveChannelSyncing = true
};
client2.Connect("irc.freenode.net", 6667);
client2.Login("smuxi-bot", "smuxi bot");
client2.OnRegistered += delegate {
client2.RfcJoin("#smuxi");
};
var timer = new Timer(delegate {
var chan = client.GetChannel("#smuxi");
var chan2 = client2.GetChannel("#smuxi");
if (chan == null) {
client.RfcJoin("#smuxi");
return;
}
if (chan2 == null) {
client2.RfcJoin("#smuxi");
return;
}
// filter duplicates and clones
var users = new List<string>();
foreach (string user in chan.Users.Keys) {
var nick = user.TrimEnd('_');
users.Add(nick);
};
foreach (string user in chan2.Users.Keys) {
var nick = user.TrimEnd('_');
if (users.Contains(nick)) {
continue;
}
users.Add(nick);
}
Console.WriteLine("{0} #smuxi user count: {1}",
DateTime.Now.ToString("s"), users.Count);
}, null, TimeSpan.Zero, TimeSpan.FromMinutes(1));
var thread = new Thread(new ThreadStart(delegate {
while (client.IsConnected) {
client.Listen();
Thread.Sleep(1000);
}
}));
thread.Start();
var thread2 = new Thread(new ThreadStart(delegate {
while (client2.IsConnected) {
client2.Listen();
Thread.Sleep(1000);
}
}));
thread2.Start();
thread.Join();
thread2.Join();
}
static void Main(string[] args)
{
string confFile = "bot.conf";
// accept some console arguments
if (args.Length > 0)
{
foreach (string arg in args)
{
string[] nv = arg.Split(new char[] { '=' });
switch (nv[0])
{
//config file
case "-c":
case "-config":
confFile = nv[1];
break;
}
}
}
// load the configuration information first
// since other things will rely on it.
try
{
System.Console.WriteLine("Using config: " + confFile);
conf = new IniConfigSource(Path.Combine(Environment.CurrentDirectory,confFile));
}
catch (IOException ioe)
{
FatalError(ioe.Message);
}
catch (Exception ex)
{
FatalError(ex.Message);
}
// initialise our functions (the IRC commands).
// let them set up and initialise before we connect
functions = new List<IFunction>();
InitFunctions();
// and begin to handle their outputs now
foreach (var f in functions)
{
f.FunctionOutputHandler += new FunctionOutput(f_FunctionOutputHandler);
}
// load the irc stuff
irc = new IrcClient();
// and handle some irc events
irc.OnRawMessage += new IrcEventHandler(irc_OnRawMessage);
irc.OnConnected += new EventHandler(irc_OnConnected);
// listen for commands in the console
// (but we don't do anything with it yet)
new Thread(new ThreadStart(ReadLine)).Start();
// now set up IRC and connect
try
{
irc.SendDelay = Convert.ToInt32(GetConf("bot", "delay"));
irc.ActiveChannelSyncing = true;
irc.Encoding = System.Text.Encoding.UTF8;
irc.AutoNickHandling = true;
}
catch (Exception ex)
{
Console.WriteLine("IRC Initialisation error: ");
FatalError(ex.Message);
}
try
{
string network = (string)GetConf("bot", "network");
int port = Convert.ToInt32(GetConf("bot", "port"));
irc.Connect(network, port);
}
catch (ConnectionException e)
{
Console.WriteLine("Connection error: ");
FatalError(e.Message);
}
string nick = "", realName = "", ident = "";
try
{
nick = (string)GetConf("bot", "nick");
realName = (string)GetConf("bot", "real_name");
ident = (string)GetConf("bot", "ident");
}
catch (Exception e)
{
Console.WriteLine("Configuration error.");
FatalError(e.Message);
}
try
{
irc.Login(nick, realName, 0, ident);
irc.Listen(); // hang here until disconnect
irc.Disconnect();
}
catch (ConnectionException ce)
{
Console.WriteLine("Login error: ");
FatalError(ce.Message);
}
catch (Exception e)
{
Console.WriteLine("Unkonwn error: ");
Console.Write(e);
FatalError(e.Message);
}
}
/// <summary>
/// just testing the IRC chat connection stability...
/// </summary>
private static void TestConnectionStability()
{
while (true)
{
try
{
irc_test = new IrcClient();
irc_test.AutoRetry = true;
irc_test.AutoReconnect = true;
irc_test.OnChannelMessage += new IrcEventHandler(irc_test_OnChannelMessage);
irc_test.OnRawMessage += new IrcEventHandler(irc_test_OnRawMessage);
// here we try to connect to the server and exceptions get handled
irc_test.Connect(serverlist, port);
}
catch (ConnectionException e)
{
// something went wrong, the reason will be shown
logger.Trace("couldn't connect! Reason: " + e.Message);
//Exit();
}
try
{
// here we logon and register our nickname and so on
irc_test.Login(nick, real);
// join the channel
irc_test.RfcJoin(channel);
// here we tell the IRC API to go into a receive mode, all events
// will be triggered by _this_ thread (main thread in this case)
// Listen() blocks by default, you can also use ListenOnce() if you
// need that does one IRC operation and then returns, so you need then
// an own loop
irc_test.Listen();
// when Listen() returns our IRC session is over, to be sure we call
// disconnect manually
irc_test.Disconnect();
}
catch (ConnectionException e)
{
// this exception is handled becaused Disconnect() can throw a not
// connected exception
logger.Trace("Connection exception: " + e.Message);
//Exit();
}
catch (Exception e)
{
// this should not happen by just in case we handle it nicely
logger.Trace("Error occurred! Message: " + e.Message);
logger.Trace("Exception: " + e.StackTrace);
//Exit();
}
logger.Trace("Going to sleep");
System.Threading.Thread.Sleep(5*60000);
logger.Trace("===========================================");
}
}
public static void Main(string[] args)
{
//this method is just for some tests
//TestConnectionStability();
//return;
int cycle_cnt = 0;
while (true)
{
cycle_cnt++;
//Console.Clear();
Console.WriteLine("Cycle: " + cycle_cnt);
Thread.CurrentThread.Name = "Main";
#region Settings
string startupPath = Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName);
if (File.Exists(startupPath + "\\settings.ini"))
profile = new Ini(startupPath + "\\settings.ini");
else
{
logger.Trace("Did not find" + startupPath);
}
channel = (string)profile.GetValue("Main", "Channel");
nick = (string)profile.GetValue("Main", "Nick");
real = (string)profile.GetValue("Main", "Real");
#endregion
#region IRC Setup
irc = new IrcClient();
irc.SendDelay = 500;
irc.ActiveChannelSyncing = true;
irc.OnChannelMessage += new IrcEventHandler(OnChannelMessage);
irc.OnQueryMessage += new IrcEventHandler(OnQueryMessage);
irc.OnBan += new BanEventHandler(OnBanMessage);
irc.OnError += new Meebey.SmartIrc4net.ErrorEventHandler(OnError);
irc.OnPart += new PartEventHandler(irc_OnPart);
irc.OnRawMessage += new IrcEventHandler(OnRawMessage);
if (proactiveMode)
{
timer = new System.Timers.Timer();
timer.Elapsed += new System.Timers.ElapsedEventHandler(autoAnswering);
}
#endregion
sl = new SortedList();
Console.WriteLine("**********************************************************");
Console.WriteLine("These are my settings: ");
Console.WriteLine("Trying to connect to " + serverlist[0] + " on port " + port + " - joining channel: " + channel);
Console.WriteLine("My nickname is: " + nick + " and my real name is: " + real);
Console.WriteLine("**********************************************************");
try
{
irc.AutoRetry = true;
irc.AutoReconnect = true;
irc.Connect(serverlist, port);
}
catch (ConnectionException e)
{
logger.Trace("couldn't connect! Reason: " + e.Message);
}
try
{
// here we logon and register our nickname and so on
irc.OnRawMessage += new IrcEventHandler(irc_OnRawMessage);
irc.Login(nick, real);
//load all channels
irc.RfcList("");
Dictionary<string, int> chann = new Dictionary<string, int>();
// join the channel
irc.RfcJoin(channel);
irc.OnChannelAction += new ActionEventHandler(irc_OnChannelAction);
#region Prelude Setup
//initialize interface
logger.Trace("Loading Prelude...");
pi = new PreLudeInterface();
//define path to mind file
pi.loadedMind = "mind.mdu";
pi.avoidLearnByRepeating = true;
pi.initializedAssociater = Mind.MatchingAlgorithm.Dice;
//start your engine ...
pi.initializeEngine();
logger.Trace("Prelude loaded and initialized...");
#endregion
// spawn a new thread to read the stdin of the console, this we use
// for reading IRC commands from the keyboard while the IRC connection
// stays in its own thread
new Thread(new ThreadStart(ReadCommands)).Start();
irc.Listen();
// when Listen() returns our IRC session is over, to be sure we call
// disconnect manually
irc.Disconnect();
}
catch (ConnectionException)
{
logger.Trace("Connection exception");
pi.stopPreludeEngine();
}
catch (Exception e)
{
logger.Trace("Error occurred! Message: " + e.Message);
logger.Trace("Exception: " + e.StackTrace);
pi.stopPreludeEngine();
}
logger.Trace("Going to sleep");
System.Threading.Thread.Sleep(5 * 60000);
logger.Trace("===========================================");
}
}
/// <summary>
/// Creates and sets up an IrcClient instance and connects to a server according to "server"
/// </summary>
public void Connect(ServerDescriptor server)
{
if (server == null)
throw new ArgumentNullException("server");
IrcClient irc = new IrcClient();
// Settings
irc.AutoReconnect = true;
irc.Encoding = System.Text.Encoding.UTF8;
irc.SendDelay = config.GetInt("send-delay", 200);
irc.ActiveChannelSyncing = config.GetBoolean("use-active-channel-syncing", false);
irc.UseSsl = server.UseSsl;
// Bind event handlers
irc.OnChannelMessage += OnChannelMessage;
irc.OnQueryMessage += OnQueryMessage;
irc.OnQueryNotice += OnQueryNotice;
irc.OnDisconnected += OnDisconnected;
// Create scrollback buffer
scrollback[server.Host] = new C5.CircularQueue<string>(1000);
try
{
log.Info("Connecting to server " + server.Host);
irc.Connect(server.Host, server.Port);
}
catch (ConnectionException e)
{
log.Error("Could not connect to server " + irc.Address, e);
Exit();
}
try
{
irc.Login(server.Nick,
config.GetString("realname", "slave"),
0,
config.GetString("username", "slave")
);
foreach (string channel in server.Channels)
irc.RfcJoin(channel);
ircs[irc.Address] = irc;
}
catch (ConnectionException e)
{
log.Error("Connection error", e);
Exit();
}
catch (Exception e)
{
Exit();
}
}
public void Connect()
{
while (true)
{
_irc = new IrcClient();
Logger.InfoFormat("Connecting to: {0}:{1}", _settings.Server, _settings.Port);
try
{
_irc.Encoding = System.Text.Encoding.UTF8;
_irc.SendDelay = 500;
_irc.ActiveChannelSyncing = true;
_irc.AutoReconnect = false;
_irc.AutoRejoinOnKick = true;
_irc.AutoRetry = true;
_irc.AutoRetryDelay = 10000;
_irc.OnQueryMessage += OnQueryMessage;
_irc.OnQueryNotice += OnQueryMessage;
_irc.OnError += OnError;
_irc.OnChannelMessage += OnChannelMessage;
//_irc.OnRawMessage += (x, e) => Logger.Info(e.Data.RawMessage);
_irc.Connect(_settings.Server, _settings.Port);
}
catch (Exception e)
{
// Log this shit
Logger.Error(e.ToString());
}
Logger.Info("Connected! Joining channels");
try
{
_irc.Login(_settings.Nickname, "Name");
if (!String.IsNullOrWhiteSpace(_settings.Password))
{
_irc.RfcPrivmsg("NickServ", "identify " + _settings.Password);
}
foreach (var channel in _settings.GetAllChannels())
{
_irc.RfcJoin(channel);
}
_checkTimer.Change(TimeSpan.Zero, _settings.Period);
}
catch (Exception e)
{
Logger.Error(e.ToString());
}
try
{
_irc.Listen();
Logger.Error("Lost connection to IRC (Automatically reconnecting in 10 seconds)");
Thread.Sleep(10000);
if (_irc.IsConnected)
{
_irc.Disconnect();
}
}
catch (Exception e)
{
Logger.Error(e.ToString());
}
}
}
private void DoHive(bool enabled)
{
try
{
// Is everything ok?
if((txtIRCserver.Text == "" || txtIRCchannel.Text == "") && enabled)
{
disableHive.Checked = true;
}
else if(enabled)
{
try { IPHostEntry ipHost = Dns.GetHostEntry(txtIRCserver.Text); }
catch { disableHive.Checked = true; }
}
if(disableHive.Checked && enabled)
{
new frmWtf().Show();
MessageBox.Show("Did you filled IRC options correctly?", "What the shit.");
return;
}
// We are starting connection. Disable input in IRC boxes.
txtIRCserver.Enabled = !enabled;
txtIRCport.Enabled = !enabled;
txtIRCchannel.Enabled = !enabled;
// Lets try this!
ircenabled = enabled;
if(enabled)
{
label25.Text = "Connecting..";
irc = new IrcClient();
irc.OnConnected += IrcConnected;
irc.OnReadLine += OnReadLine;
irc.OnChannelMessage += OnMessage;
irc.OnOp += OnOp;
irc.OnDeop += OnDeOp;
irc.OnPart += OnPart;
irc.OnNickChange += OnNickChange;
irc.OnTopic += OnTopic;
irc.OnTopicChange += OnTopicChange;
irc.OnQuit += OnQuit;
irc.OnKick += OnKick;
irc.OnDisconnected += IrcDisconnected;
irc.OnNames += OnNames;
irc.AutoRejoinOnKick = true;
irc.AutoRejoin = true;
try
{
int port;
if(!int.TryParse(txtIRCport.Text, out port)) port = 6667;
irc.Connect(txtIRCserver.Text, port);
channel = txtIRCchannel.Text.ToLower();
irc.Login("LOIC_" + Functions.RandomString(), "Newfag's remote LOIC", 0, "IRCLOIC");
// Spawn a thread to handle the listen.
irclisten = new Thread(new ThreadStart(IrcListenThread));
irclisten.Start();
}
catch
{ }
}
else
{
try
{
if(irc != null) irc.Disconnect();
}
catch
{ }
label25.Text = "Disconnected.";
}
}
catch
{ }
}
public override void Initialize()
{
if (Init) return;
try
{
_irc = new IrcClient();
_irc.OnRawMessage += OnRawMessage;
//
Chat.Battleground += ChatSpec;
Chat.BattlegroundLeader += ChatSpec;
Chat.Guild += Chat_Guild;
Chat.Officer += ChatSpec;
Chat.Raid += ChatSpec;
Chat.Channel += ChatSpec;
Chat.Party += ChatSpec;
Chat.PartyLeader += ChatSpec;
Chat.Say += ChatSpec;
Chat.Yell += ChatSpec;
Chat.Whisper += Chat_Whisper;
Chat.WhisperTo += ChatSpec;
//
Logging.OnLogMessage += Logging_OnLogMessage;
//
Lua.Events.AttachEvent("CHAT_MSG_LOOT", LootChatMonitor);
Lua.Events.AttachEvent("ACHIEVEMENT_EARNED", AchievementMonitor);
Lua.Events.AttachEvent("CHAT_MSG_BN_WHISPER", BnChatMonitor);
Lua.Events.AttachEvent("CHAT_MSG_BN_CONVERSATION", BnChatMonitor);
Lua.Events.AttachEvent("BN_FRIEND_ACCOUNT_ONLINE", BnFriendsOn);
Lua.Events.AttachEvent("BN_FRIEND_ACCOUNT_OFFLINE", BnFriendsOff);
Lua.Events.AttachEvent("CHAT_MSG_BN_WHISPER_INFORM", BnInform);
//
BotEvents.OnBotStopped += BotEvents_OnBotStopped;
BotEvents.OnBotStarted += BotEvents_OnBotStarted;
BotEvents.OnBotChanged += BotEvents_OnBotChanged;
BotEvents.Player.OnLevelUp += Player_OnLevelUp;
BotEvents.Player.OnPlayerDied += Player_OnPlayerDied;
BotEvents.Player.OnMobKilled += Player_OnMobKilled;
//
_irc.Connect(ConfigValues.Instance.IrcAddress, ConfigValues.Instance.IrcPort);
_irc.Login(ConfigValues.Instance.IrcUsername, ConfigValues.Instance.IrcUsername[0]);
_irc.RfcJoin(ConfigValues.Instance.IrcChannel);
_listener = new Thread(Listen) {IsBackground = true};
_listener.Start();
}
catch (Exception ex)
{
Logging.WriteException(ex);
Init = false;
return;
}
finally
{
Logging.Write("GeekyIrc version: {0} started.",Version);
}
Init = true;
}
/// <summary>
/// Creates and sets up an IrcClient instance and connects to a server according to "server"
/// </summary>
public void Connect(ServerDescriptor server)
{
if (server == null)
throw new ArgumentNullException();
Thread.CurrentThread.Name = server.Host;
irc = new IrcClient();
// Settings
irc.Encoding = System.Text.Encoding.UTF8;
irc.SendDelay = config.GetInt("send-delay", 200);
irc.ActiveChannelSyncing = config.GetBoolean("use-active-channel-syncing", false);
irc.UseSsl = server.UseSsl;
// Bind event handlers
irc.OnQueryMessage += new IrcEventHandler(OnQueryMessage);
irc.OnChannelMessage += new IrcEventHandler(OnChannelMessage);
irc.OnError += new Meebey.SmartIrc4net.ErrorEventHandler(OnError);
irc.OnRawMessage += new IrcEventHandler(OnRawMessage);
irc.OnPart += new PartEventHandler(OnPart);
log.Info("Initializing plugins...");
foreach (var plugin in Plugins)
{
plugin.Initialize(config);
irc.OnChannelMessage += new IrcEventHandler(plugin.OnChannelMessage);
irc.OnRawMessage += new IrcEventHandler(plugin.OnRawMessage);
}
try
{
log.Info("Connecting to server " + irc.Address);
irc.Connect(server.Host, server.Port);
}
catch (ConnectionException e)
{
log.Error("Could not connect to server " + irc.Address, e);
Exit();
}
try
{
irc.Login(config.GetString("nick", "slave"),
config.GetString("realname", "slave"),
0,
config.GetString("username", "slave")
);
foreach (string channel in server.Channels)
irc.RfcJoin(channel);
irc.Listen();
irc.Disconnect();
}
catch (ThreadAbortException e)
{
log.Info("Aborting thread", e);
irc.Disconnect();
Thread.CurrentThread.Abort();
}
catch (ConnectionException e)
{
log.Error("Error", e);
Thread.CurrentThread.Abort();
}
catch (Exception e)
{
log.Error("Error", e);
Thread.CurrentThread.Abort();
}
}
