public bool Login(string username, string password) { mylogin = username; LogFile.WriteLine(this.GetType().ToString() + " Login()"); //InformClient( "test inform" ); try { Config.Coordination coordinationconfig = Config.GetInstance().coordination; string[] serverlist = new string[] { coordinationconfig.ircserver }; int port = coordinationconfig.ircport; _channel = coordinationconfig.ircchannel; LogFile.WriteLine("ircchat connecting to " + coordinationconfig.ircserver); ircclient.Connect(serverlist, port); ircclient.Login(username, username); ircclient.RfcJoin(_channel); if (password != "") { ircclient.SendMessage(SendType.Message, "nickserv", "identify " + password); } IsConnected = true; } catch (ConnectionException e) { OnMessage(ChatMessageType.Error, "", "IRC Error: " + e.Message + ". Irc chat will not be available in this session"); } return(IsConnected); }
public IRCBot() { // The IRC Bot must run in a seperate thread, or else the server will freeze. ircThread = new Thread(new ThreadStart(delegate { // Attach event handlers irc.OnConnecting += new EventHandler(OnConnecting); irc.OnConnected += new EventHandler(OnConnected); irc.OnChannelMessage += new IrcEventHandler(OnChanMessage); irc.OnJoin += new JoinEventHandler(OnJoin); irc.OnPart += new PartEventHandler(OnPart); irc.OnQuit += new QuitEventHandler(OnQuit); irc.OnNickChange += new NickChangeEventHandler(OnNickChange); irc.OnDisconnected += new EventHandler(OnDisconnected); irc.OnQueryMessage += new IrcEventHandler(OnPrivMsg); irc.OnNames += new NamesEventHandler(OnNames); irc.OnChannelAction += new ActionEventHandler(OnAction); irc.OnKick += new KickEventHandler(OnKick); // Attempt to connect to the IRC server try { irc.Connect(server, Server.ircPort); } catch (Exception ex) { Server.s.Log("Unable to connect to IRC server: " + ex.Message); } })); ircThread.Start(); }
public GlobalChatBot() { // The IRC Bot must run in a seperate thread, or else the server will freeze. globalThread = new Thread(new ThreadStart(delegate { // Attach event handlers globalchat.OnConnecting += new EventHandler(OnConnecting); globalchat.OnConnected += new EventHandler(OnConnected); globalchat.OnChannelMessage += new IrcEventHandler(OnChanMessage); globalchat.OnJoin += new JoinEventHandler(OnJoin); globalchat.OnPart += new PartEventHandler(OnPart); globalchat.OnQuit += new QuitEventHandler(OnQuit); globalchat.OnNickChange += new NickChangeEventHandler(OnNickChange); globalchat.OnDisconnected += new EventHandler(OnDisconnected); globalchat.OnQueryMessage += new IrcEventHandler(OnPrivMsg); globalchat.OnNames += new NamesEventHandler(OnNames); globalchat.OnChannelAction += new ActionEventHandler(OnAction); // Attempt to connect to the IRC server try { globalchat.Connect(server, 6667); } catch (Exception ex) { if (Server.useglobal) { Server.s.Log("Unable to connect to MCDawn Global Chat Server: " + ex.Message); } } })); globalThread.Start(); }
public void Connect() { if (server.server.Contains(":")) { client.Connect(server.server.Split(':')[0], Convert.ToInt32(server.server.Split(':')[1]), false, regInfo); return; } client.Connect(server.server, false, regInfo); }
private void Reconnect() { if (IrcClient != null) { IrcClient.Disconnect(); IrcClient = null; } IrcClient = new IrcClient(); IrcClient.ClientId = "TWITCHCLIENT 2"; IrcClient.Connected += IrcClient_Connected; IrcClient.ProtocolError += IrcClient_ProtocolError; IrcClient.Error += IrcClient_Error; IrcClient.Disconnected += IrcClient_Disconnected; IrcClient.RawMessageReceived += IrcClient_RawMessageReceived; IrcClient.ConnectFailed += IrcClient_ConnectFailed; IrcClient.MotdReceived += IrcClient_MotdReceived; Random rnd = new Random(); string s = "justinfan" + rnd.Next(100000000); regInfo = new IrcUserRegistrationInfo() { NickName = s, UserName = s, Password = "******", RealName = s }; Header = "http://twitch.tv, Подключаемся к " + StreamerNick; if (!string.IsNullOrEmpty(_directAdress)) { string[] dat = _directAdress.Split(':'); try { int port = int.Parse(dat[1]); IrcClient.Connect(dat[0], port, false, regInfo); } catch { Header = "http://twitch.tv, Ошибка " + StreamerNick; } } else { IrcClient.Connect(StreamerNick + ".jtvirc.com", 6667, false, regInfo); } }
public void Create(User user, CountdownEvent countdownEvent, bool shouldChat) { _user = user; _countdownEvent = countdownEvent; _irc.Encoding = System.Text.Encoding.UTF8; _irc.SendDelay = 1000; _irc.ActiveChannelSyncing = true; _irc.AutoReconnect = true; _irc.AutoRejoinOnKick = true; _irc.AutoRetry = true; _irc.AutoRetryDelay = 30000; _irc.AutoRelogin = true; _irc.OnError += new ErrorEventHandler(OnError); _irc.OnRawMessage += new IrcEventHandler(OnRawMessage); try { _irc.Connect(Settings.Server, Settings.Port); } catch (Exception e) { Log.AddErrorMessage(e.Message); _countdownEvent.Signal(); System.Environment.Exit(1); } try { _irc.Login(_user.Username, _user.Username, 0, _user.Username, _user.Password); foreach (var channel in Settings.Channels) { _irc.RfcJoin(channel); } if (shouldChat) { _timer = new Timer(streamTimer, null, TimeSpan.FromSeconds(Math.Max(Settings.UserInitialWait + (StaticRandom.Rand() % (Settings.UserChatVariance * 2)) - Settings.UserChatVariance, 0)), TimeSpan.FromSeconds(Math.Max(Settings.UserChatInterval + (StaticRandom.Rand() % (Settings.UserChatVariance * 2)) - Settings.UserChatVariance, 0))); } while (!_shouldDisconnect) { _irc.ListenOnce(); } } catch (Exception e) { Log.AddErrorMessage(e.Message); //System.Environment.Exit(2); } finally { _countdownEvent.Signal(); _irc.Disconnect(); } }
static void InitIrcClient() { Thread.CurrentThread.Name = "Main"; irc.Encoding = System.Text.Encoding.UTF8; // wait time between messages, we can set this lower on own irc servers irc.SendDelay = 200; // we use channel sync, means we can use irc.GetChannel() and so on irc.ActiveChannelSyncing = true; irc.AutoReconnect = true; irc.AutoRejoin = true; irc.AutoRejoinOnKick = true; irc.SupportNonRfc = true; // here we connect the events of the API to our written methods // most have own event handler types, because they ship different data irc.OnQueryMessage += new IrcEventHandler(OnPrivateMessage); irc.OnError += new Meebey.SmartIrc4net.ErrorEventHandler(OnError); irc.OnRawMessage += new IrcEventHandler(OnRawMessage); irc.OnChannelMessage += new IrcEventHandler(OnChannelMessage); irc.OnJoin += new JoinEventHandler(OnUserJoin); irc.OnPart += new PartEventHandler(OnUserPartChannel); string[] serverlist; // the server we want to connect to, could be also a simple string serverlist = new string[] { "irc.miners-zone.net" }; int port = 6667; try { // here we try to connect to the server and exceptions get handled irc.Connect(serverlist, port); } catch (ConnectionException e) { // something went wrong, the reason will be shown System.Console.WriteLine("couldn't connect! Reason: " + e.Message); } try { // here we logon and register our nickname and so on irc.Login(Program.BotName, Program.BotDescription); // join the channel irc.RfcJoin(Program.PublicChannel); irc.RfcJoin(Program.AdminChannel); } catch (ConnectionException) { // this exception is handled because Disconnect() can throw a not // connected exception } catch (Exception e) { // this should not happen by just in case we handle it nicely System.Console.WriteLine("Error occurred! Message: " + e.Message); System.Console.WriteLine("Exception: " + e.StackTrace); irc.Disconnect(); } }
public void Connect() { try { irc.Connect(server, port); } catch (ConnectionException e) { Console.WriteLine("Could not connect: " + e.Message); return; } try { irc.Login("testuser889", "testing the goonite irc client"); irc.RfcJoin(channel); _listenThread = new Thread(new ThreadStart(irc.Listen)); _listenThread.Start(); // here we send just 3 different types of messages, 3 times for // testing the delay and flood protection (messagebuffer work) //irc.SendMessage(SendType.Message, channel, "test message (" + i.ToString() + ")"); //irc.SendMessage(SendType.Action, channel, "thinks this is cool (" + i.ToString() + ")"); //irc.SendMessage(SendType.Notice, channel, "SmartIrc4net rocks (" + i.ToString() + ")"); } catch (ConnectionException e) { Console.WriteLine("Error at Login / Listen" + e.Message); return; } }
bool ConnectIRC(object[] Params) { if (!Session.Safe || (!Session.InSpace && !Session.InStation)) { return(false); } if (Config.UseIRC) { try { IrcUserRegistrationInfo reginfo = new IrcUserRegistrationInfo(); reginfo.NickName = Me.Name.Replace(" ", string.Empty).Replace("'", string.Empty); reginfo.RealName = Me.Name.Replace(" ", string.Empty).Replace("'", string.Empty); reginfo.UserName = Me.Name.Replace(" ", string.Empty).Replace("'", string.Empty); IRC.FloodPreventer = new IrcStandardFloodPreventer(4, 2000); IRC.Connect(new Uri("irc://" + Config.Server), reginfo); } catch { return(false); } } return(true); }
public bool Connect(string server) { connectedEvent.Reset(); client.Connect(server, false, RegistrationInfo); return(connectedEvent.Wait(10000)); }
public void Connect() { try { IrcClientConnectionOptions options = null; if (Settings.Current.IRC.Ssl) { options = new IrcClientConnectionOptions(); options.Ssl = true; options.SslHostname = Settings.Current.IRC.Server; if (Settings.Current.IRC.SslAcceptInvalid) { options.SslCertificateValidationCallback = (sender, certificate, chain, policyErrors) => true; } } Client.Connect(Settings.Current.IRC.Server, Settings.Current.IRC.Port, options); } catch (Exception e) { Log.WriteError("IRC", "Failed to connect: {0}\n{1}", e.Message, e.StackTrace); } }
/// <summary> /// See interface. /// </summary> /// <param name="network"></param> public void Connect(INetwork network) { // Create client Client = new IrcClient { Encoding = Encoding.UTF8, SendDelay = 200, ActiveChannelSyncing = true, }; Network = network; // Hook up to events Client.OnList += OnChannelListReceived; Client.OnConnected += OnConnected; Client.OnConnectionError += OnError; Client.OnDisconnected += OnDisconnected; Client.OnError += OnError; Client.OnErrorMessage += OnErrorMessage; Client.OnMotd += OnMotd; // << USED AS *CONNECTED* FOR NOW Client.OnChannelMessage += OnChannelMessage; Client.OnQueryMessage += OnQueryMessage; Client.OnRawMessage += OnRawMessage; Client.OnRegistered += OnRegistered; Client.Connect(network.Address, network.Port); Task.Run(() => Client.Listen()); }
void Listen() { int port = 6667; string channel = "#" + Settings.Default.Language + ".wikipedia"; try { _irc.Connect("irc.wikimedia.org", port); } catch (ConnectionException err) { System.Console.WriteLine("couldn't connect! Reason: " + err.Message); return; } try { _autoEvent.Reset(); _irc.Login(Settings.Default.IrcUser, Settings.Default.IrcDescription); _irc.RfcJoin(channel); _stop = false; while (!_stop) { _irc.ListenOnce(); } _irc.Disconnect(); _autoEvent.Set(); } catch (ConnectionException) { } }
static void Connect() { Irc.Connect(ip, port); Irc.Login(nick, realname); Irc.RfcJoin(channel); new Thread(new ThreadStart(Irc.Listen)).Start(); }
public void Connect() { irc.Encoding = System.Text.Encoding.UTF8; irc.SendDelay = 200; irc.ActiveChannelSyncing = true; RegisterEvents(); string[] serverlist = new string[] { "irc.ppy.sh" }; int port = 6667; try { irc.Connect(serverlist, port); } catch (ConnectionException e) { System.Console.WriteLine("couldn't connect! Reason: " + e.Message); return; } try { irc.Login(name, name, 4, name, password); irc.RfcJoin("#korean"); StartLoop(); } catch (Exception e) { // this should not happen by just in case we handle it nicely System.Console.WriteLine("Error occurred! Message: " + e.Message); System.Console.WriteLine("Exception: " + e.StackTrace); return; } }
private void Reconnect(ConfigPlugin config) { if (ircClient.IsConnected) { ircClient.Disconnect(); } threadRunning = false; try { ircThread.Abort(); } catch (Exception) { } ircClient.Connect(config.Host, config.Port); ircClient.Login(config.IrcNick, config.IrcNick); ircClient.RfcJoin(config.Channel); if (!threadRunning) { ircThread = new Thread(new ThreadStart(IrcThread)); } threadRunning = true; ircThread.Start(); }
public void SpawnBot() { new Thread(() => { try { ircClient.Connect(server, port); ircClient.Login(nick, loginName); if (authstring.Length != 0) { ircClient.SendMessage(SendType.Message, authuser, authstring); Thread.Sleep(1000); // login delay } ircClient.RfcJoin(channel); ircClient.Listen(); timer.Start(); } catch (Exception ex) { Console.WriteLine(ex.Message); return; } }).Start(); }
public void Connect() { if (client.IsConnected) { return; } new Thread(() => { try { client.Connect(Game.Settings.Chat.Hostname, Game.Settings.Chat.Port); } catch (Exception e) { connectionStatus = ChatConnectionStatus.Error; AddNotification(e.Message); Game.RunAfterTick(() => Log.Write("irc", e.ToString())); return; } client.Listen(); }) { Name = "IrcListenThread", IsBackground = true }.Start(); }
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"); } }
// // Connecting, Joining, Listening // public void Connect(string server, int port, string botName, string pass) { try { // here we try to connect to the server and exceptions get handled mainIRCClient.Connect(server, port); } catch (ConnectionException e) { // something went wrong, the reason will be shown System.Console.WriteLine("couldn't connect! Reason: " + e.Message); } try { // here we logon and register our nickname and so on mainIRCClient.Login(botName, botName); } catch (ConnectionException) { // this exception is handled because Disconnect() can throw a not // connected exception } catch (Exception e) { // this should not happen by just in case we handle it nicely System.Console.WriteLine("Error occurred! Message: " + e.Message); System.Console.WriteLine("Exception: " + e.StackTrace); } }
public static void Main(string[] args) { sessions = new Dictionary <string, ChatterBotSession>(); ChatterBotFactory factory = new ChatterBotFactory(); bot1 = factory.Create(ChatterBotType.CLEVERBOT); //ChatterBot bot2 = factory.Create(ChatterBotType.PANDORABOTS, "b0dafd24ee35a477"); //ChatterBotSession bot2session = bot2.CreateSession(); //string s = "Hi"; irc = new IrcClient(); irc.Connected += irc_Connected; irc.Registered += irc_Registered; irc.Error += irc_Error; irc.ConnectFailed += irc_ConnectFailed; irc.Connect("chat.freenode.net", false, new IrcUserRegistrationInfo() { NickName = name, RealName = name, UserName = name }); while (true) { Thread.Sleep(1000); } }
void Listen() { try { _irc = new IrcClient(); _irc.AutoRejoin = true; _irc.SendDelay = 500; _irc.OnConnecting += new EventHandler(_irc_OnConnecting); _irc.OnConnected += new EventHandler(_irc_OnConnected); _irc.OnConnectionError += new EventHandler(_irc_OnConnectionError); _irc.OnDisconnected += new EventHandler(_irc_OnDisconnected); _irc.OnChannelMessage += new IrcEventHandler(_irc_OnChannelMessage); _irc.OnRawMessage += new IrcEventHandler(_irc_OnRawMessage); _irc.OnError += new ErrorEventHandler(_irc_OnError); _irc.OnErrorMessage += new IrcEventHandler(_irc_OnErrorMessage); _irc.Connect(_server, _port); _irc.Login(_nick, _realName); _irc.RfcJoin(_channel); _irc.Listen(); } catch (Exception ex) { OutputMessage("Fatal Error: " + ex.Message); } }
private void Connect() { Console.WriteLine("Connecting to {0} port {1}", hostname, port); while (!m_IrcClient.Connected) { try { m_IrcClient.Connect(hostname, port); } catch (Exception ex) { Console.WriteLine(ex.Message); Thread.Sleep(10000); } } m_IrcClient.Register(botname, password, null); Console.WriteLine("Registered as {0}...", m_IrcClient.Nickname); /* Did we get the nick we wanted? */ if (m_IrcClient.Nickname != botname) { /* there must have been an existing one, kill it */ m_IrcClient.GhostNick(botname, password);; } JoinChannels(); }
private void IRCMessenger_Load(object sender, EventArgs e) { m_IRCClient = new IrcClient(); // UTF-8 test m_IRCClient.Encoding = System.Text.Encoding.UTF8; // wait time between messages, we can set this lower on own irc servers m_IRCClient.SendDelay = 200; // we use channel sync, means we can use irc.GetChannel() and so on m_IRCClient.ActiveChannelSyncing = true; // Setup Events m_IRCClient.OnConnected += new EventHandler(ircClient_OnConnect); m_IRCClient.OnJoin += new JoinEventHandler(ircClient_OnJoin); m_IRCClient.OnNames += new NamesEventHandler(ircClient_OnNames); // Leave room m_IRCClient.OnPart += new PartEventHandler(ircClient_OnPart); m_IRCClient.OnQuit += new QuitEventHandler(ircClient_OnQuit); m_IRCClient.OnKick += new KickEventHandler(ircClient_OnKick); m_IRCClient.OnQueryMessage += new IrcEventHandler(ircClient_OnPrivMsg); m_IRCClient.OnErrorMessage += new IrcEventHandler(ircClient_OnError); //m_IRCClient.OnRawMessage += new IrcEventHandler(OnRawMessage); m_IRCClient.Connect(m_IRCServer, m_IRCPort); // here we logon and register our nickname and so on m_IRCClient.Login(m_Nick, "SmartIrc4net Test Bot"); // Setup listen thread m_IrcThread = new Thread(ListenThread); m_IrcThread.Start(); }
public void Connect() { try { IrcClientConnectionOptions options = null; if (Settings.Current.IRC.Ssl) { options = new IrcClientConnectionOptions { Ssl = true, SslHostname = Settings.Current.IRC.Server }; if (Settings.Current.IRC.SslAcceptInvalid) { options.SslCertificateValidationCallback = (sender, certificate, chain, policyErrors) => true; } } Client.Connect(Settings.Current.IRC.Server, Settings.Current.IRC.Port, options); } catch (Exception e) { ErrorReporter.Notify("IRC", e); } }
public void Tick() { if (DateTime.Now >= nextConnect) { nextConnect = DateTime.MaxValue; Log.WriteInfo("IRC", "Connecting..."); if (client.IsConnected) { client.Disconnect(); } client.Connect(Settings.Current.IRCServer, Settings.Current.IRCPort); var nickList = new string[] { Settings.Current.IRCNick, Settings.Current.IRCNick + "_" }; if (!string.IsNullOrEmpty(Settings.Current.IRCPassword)) { client.Login(nickList, Settings.Current.IRCNick, 4, "steamircbot", Settings.Current.IRCPassword); } else { client.Login(nickList, Settings.Current.IRCNick, 4, "steamircbot"); } } client.ListenOnce(false); CommandManager.Tick(); }
private void IrcThread(object param) { object[] args = (object[])param; string server = (string)args[0]; int port = (int)args[1]; string nick = (string)args[2]; string chan = (string)args[3]; connecting = true; PrintMsg("System", "Connecting..."); try { irc.Connect(server, port); PrintMsg("System", "Logging in..."); irc.Login(nick, "Radegast SL Relay", 0, nick); irc.RfcJoin(chan); connecting = false; } catch (Exception ex) { PrintMsg("System", "An error has occured: " + ex.Message); } try { irc.Listen(); if (irc.IsConnected) { irc.AutoReconnect = false; irc.Disconnect(); } } catch { } }
private void btnConnect_Click(object sender, EventArgs e) { lstLog.Items.Clear(); nummsg = 0; oldnummsg = 0; if (_ircClient.IsConnected) { _ircClient.Disconnect(); } _ircClient.SendDelay = 200; _ircClient.ActiveChannelSyncing = true; AddItemToLog("Connecting to " + txtServer.Text); try { _ircClient.Connect(txtServer.Text, 6667); grpIRCCONFIG.Enabled = false; grpLOGCONFIG.Enabled = false; StatsTimer.Interval = Convert.ToInt32(txtLogInterval.Text); } catch (ConnectionException ex) { AddItemToLog("couldn't connect! Reason: " + ex.Message); } }
protected void Connect(string server, IrcRegistrationInfo registrationInfo) { // Create new IRC client and connect to given server. var client = new IrcClient(); client.FloodPreventer = new IrcStandardFloodPreventer(4, 2000); client.Connected += IrcClient_Connected; client.Disconnected += IrcClient_Disconnected; client.Registered += IrcClient_Registered; // Wait until connection has succeeded or timed out. using (var connectedEvent = new ManualResetEventSlim(false)) { client.Connected += (sender2, e2) => connectedEvent.Set(); client.Connect(server, false, registrationInfo); if (!connectedEvent.Wait(10000)) { client.Dispose(); ConsoleUtilities.WriteError("Connection to '{0}' timed out.", server); return; } } // Add new client to collection. this.allClients.Add(client); Console.Out.WriteLine("Now connected to '{0}'.", server); }
private void IRCApp_Load(object sender, EventArgs e) { // Show connection dialog ConnectForm connectDialog = new ConnectForm(); connectDialog.ShowDialog(); // Fetch the client object... client = connectDialog.client; // Register client events... client.SelfJoinedChannel += Client_SelfJoinedChannel; client.GotGeneralMessage += Client_GotGeneralMessage; // And get connected. client.Connect(); // Initialize the status tab... StatusTabControl = new TabLayout(client, null); StatusTabControl.TopLevel = false; StatusTab.Controls.Add(StatusTabControl); // And make it visible. StatusTabControl.Dock = DockStyle.Fill; StatusTabControl.Show(); }
public static void IrcClientList() { IrcClient irc = new IrcClient(); irc.OnRawMessage += new EventHandler<IrcEventArgs>(IrcClientListCallback); irc.Connect(SERVER, PORT); irc.Login(NICK, REALNAME); irc.RfcList(CHANNEL); irc.Listen(); }
private void menuItemConnect_Click(object sender, System.EventArgs e) { try { AppendText(tabControlChatTabs.SelectedTab.Text, "notice", " -!- Attempting connection to " + User.server + ":" + User.port.ToString() + "\n"); if (File.Exists("ignore")) { using (StreamReader sr = new StreamReader("ignore")) { string line = null; while ((line = sr.ReadLine()) != null) { alIgnoredHosts.Add(line.ToString()); } } } irc = new IrcClient(); irc.SendDelay = 200; irc.AutoRetry = false; irc.ChannelSyncing = true; irc.OnTopic += new TopicEventHandler(irc_OnTopic); irc.OnDisconnected += new SimpleEventHandler(irc_OnDisconnected); irc.OnDeop += new DeopEventHandler(irc_OnDeop); irc.OnOp += new OpEventHandler(irc_OnOp); irc.OnOwner += new OwnerEventHandler(irc_OnOwner); irc.OnHalfOp += new HalfOpEventHandler(irc_OnHalfOp); irc.OnProtect += new ProtectEventHandler(irc_OnProtect); irc.OnDeOwner += new DeOwnerEventHandler(irc_OnDeOwner); irc.OnDeHalfOp += new DeHalfOpEventHandler(irc_OnDeHalfOp); irc.OnDeProtect += new DeProtectEventHandler(irc_OnDeProtect); irc.OnDevoice += new DevoiceEventHandler(irc_OnDevoice); irc.OnVoice += new VoiceEventHandler(irc_OnVoice); irc.OnWho += new WhoEventHandler(irc_OnWho); irc.OnModeChange += new MessageEventHandler(irc_OnModeChange); irc.OnUserModeChange += new MessageEventHandler(irc_OnUserModeChange); irc.OnUnban += new UnbanEventHandler(irc_OnUnban); irc.OnBan += new BanEventHandler(irc_OnBan); irc.OnKick += new KickEventHandler(irc_OnKick); irc.OnQueryAction += new ActionEventHandler(irc_OnQueryAction); irc.OnQuit += new QuitEventHandler(irc_OnQuit); irc.OnNickChange += new NickChangeEventHandler(irc_OnNickChange); irc.OnChannelAction += new ActionEventHandler(irc_OnChannelAction); irc.OnReadLine += new ReadLineEventHandler(irc_OnReadLine); irc.OnJoin += new JoinEventHandler(irc_OnJoin); irc.OnPart += new PartEventHandler(irc_OnPart); irc.OnQueryNotice += new MessageEventHandler(irc_OnQueryNotice); irc.OnChannelMessage += new MessageEventHandler(irc_OnChannelMessage); irc.OnQueryMessage += new MessageEventHandler(irc_OnQueryMessage); if (irc.Connect(User.server, User.port)) { irc.Login(User.username, Application.Name + " " + Application.Version); irc.Join(User.channel); if (irc.Connected) { menuItemConnect.Enabled = false; menuItemDisconnect.Enabled = true; threadIrcConnection = new Thread(new ThreadStart(IRCListenThread)); threadIrcConnection.Start(); } else { AppendText(tabControlChatTabs.SelectedTab.Text, "tag", "["); AppendText(tabControlChatTabs.SelectedTab.Text, "time", DateTime.Now.ToShortTimeString().ToString()); AppendText(tabControlChatTabs.SelectedTab.Text, "tag", "] "); AppendText(tabControlChatTabs.SelectedTab.Text, "notice", " -!- Unable to connect to " + User.server + ":" + User.port.ToString() + "\n"); } } else { AppendText(tabControlChatTabs.SelectedTab.Text, "tag", "["); AppendText(tabControlChatTabs.SelectedTab.Text, "time", DateTime.Now.ToShortTimeString().ToString()); AppendText(tabControlChatTabs.SelectedTab.Text, "tag", "] "); AppendText(tabControlChatTabs.SelectedTab.Text, "notice", " -!- A connection to " + User.server + ":" + User.port.ToString() + " could not be established.\n"); } } catch (Exception ex) { User.ErrorLog(ex.ToString()); } }
public static void ClassInitialize(TestContext testContext) { stateManager = new TestStateManager<IrcClientTestState>(); // Create IRC clients. ircClient1 = new IrcClient(); #if DEBUG ircClient1.ClientId = "1"; #endif ircClient1.FloodPreventer = new IrcStandardFloodPreventer(4, 2000); ircClient1.Connected += ircClient1_Connected; ircClient1.ConnectFailed += ircClient1_ConnectFailed; ircClient1.Disconnected += ircClient1_Disconnected; ircClient1.Error += ircClient1_Error; ircClient1.ProtocolError += ircClient1_ProtocolError; ircClient1.Registered += ircClient1_Registered; ircClient1.MotdReceived += ircClient1_MotdReceived; ircClient1.NetworkInformationReceived += ircClient1_NetworkInformationReceived; ircClient1.ServerVersionInfoReceived += ircClient1_ServerVersionInfoReceived; ircClient1.ServerTimeReceived += ircClient1_ServerTimeReceived; ircClient1.ServerLinksListReceived += ircClient1_ServerLinksListReceived; ircClient1.ServerStatsReceived += ircClient1_ServerStatsReceived; ircClient1.WhoReplyReceived += ircClient1_WhoReplyReceived; ircClient1.WhoIsReplyReceived += ircClient1_WhoIsReplyReceived; ircClient1.WhoWasReplyReceived += ircClient1_WhoWasReplyReceived; ircClient1.ChannelListReceived += ircClient1_ChannelListReceived; ircClient2 = new IrcClient(); #if DEBUG ircClient2.ClientId = "2"; #endif ircClient2.Connected += ircClient2_Connected; ircClient2.ConnectFailed += ircClient2_ConnectFailed; ircClient2.Disconnected += ircClient2_Disconnected; ircClient2.Error += ircClient2_Error; ircClient2.ProtocolError += ircClient2_ProtocolError; ircClient2.Registered += ircClient2_Registered; // Create CTCP clients over IRC clients. ctcpClient1 = new CtcpClient(ircClient1); ctcpClient1.ClientVersion = clientVersionInfo; ctcpClient1.PingResponseReceived += ctcpClient1_PingResponseReceived; ctcpClient1.VersionResponseReceived += ctcpClient1_VersionResponseReceived; ctcpClient1.TimeResponseReceived += ctcpClient1_TimeResponseReceived; ctcpClient1.ActionReceived += ctcpClient1_ActionReceived; ctcpClient2 = new CtcpClient(ircClient2); ctcpClient2.ClientVersion = clientVersionInfo; ctcpClient2.PingResponseReceived += ctcpClient2_PingResponseReceived; ctcpClient2.VersionResponseReceived += ctcpClient2_VersionResponseReceived; ctcpClient2.TimeResponseReceived += ctcpClient2_TimeResponseReceived; ctcpClient2.ActionReceived += ctcpClient2_ActionReceived; // Initialize wait handles for all events. GetAllWaitHandlesFields().ForEach(fieldInfo => fieldInfo.SetValue(null, new AutoResetEvent(false))); // Nick name length limit on irc.freenode.net is 16 chars. Func<string> getRandomUserId = () => Guid.NewGuid().ToString().Substring(0, 8); serverPassword = Properties.Resources.ServerPassword; if (string.IsNullOrEmpty(serverPassword)) serverPassword = null; nickName1 = userName1 = string.Format(Properties.Resources.NickNameFormat, getRandomUserId()); nickName2 = userName2 = string.Format(Properties.Resources.NickNameFormat, getRandomUserId()); realName = Properties.Resources.RealName; Debug.WriteLine("Client users have real name '{0}'", realName); Debug.WriteLine("Client 1 user has nick name '{0}' and user name '{1}'.", nickName1, userName1); Debug.WriteLine("Client 2 user has nick name '{0}' and user name '{1}'.", nickName2, userName2); stateManager.SetStates(IrcClientTestState.Client1Initialized, IrcClientTestState.Client2Initialized); ircClient1.Connect(Properties.Resources.ServerHostName, false, new IrcUserRegistrationInfo() { Password = serverPassword, NickName = nickName1, UserName = userName1, RealName = realName, }); ircClient2.Connect(Properties.Resources.ServerHostName, false, new IrcUserRegistrationInfo() { Password = serverPassword, NickName = nickName2, UserName = userName2, RealName = realName, }); }
public void Connect(string server, IrcRegistrationInfo registrationInfo) { // Create new IRC client and connect to given server. var client = new IrcClient(); client.FloodPreventer = new IrcStandardFloodPreventer(4, 2000); client.Connected += IrcClient_Connected; client.Disconnected += IrcClient_Disconnected; client.Registered += IrcClient_Registered; // Wait until connection has succeeded or timed out. using (var connectedEvent = new ManualResetEventSlim(false)) { client.Connected += (sender2, e2) => connectedEvent.Set(); client.Connect(server, false, registrationInfo); if (!connectedEvent.Wait(10000)) { client.Dispose(); ConsoleUtilities.WriteError("Connection to '{0}' timed out.", server); return; } } // Add new client to collection. this.allClients.Add(client); Console.Out.WriteLine("Now connected to '{0}'.", server); }