root/lang/csharp/IrcSendOnly/IRCClient.cs

using System;
using System.IO;
using System.Collections;
using System.Threading; 
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace IrcSend
{
        public class IRCClient
        {
                private string mServer;
                private int mPort;
                private string mNick;
                private string mEncoding;
                private ArrayList mChannels;
                private string mBotChannel;
                private StreamWriter mWriter;
                private StreamReader mReader;
                private NetworkStream mNetStream;
                private Thread mNetThread;
                private TcpClient mTCP;
                private bool mContinue;
                private IRCListener mListener;

                private Hashtable mJoinedChannels;

                public string BotChannel
                {
                        get
                        {
                                return mBotChannel;
                        }
                }

                public IRCClient(IRCListener ln)
                {
                        mChannels = new ArrayList();
                        mJoinedChannels = new Hashtable();
                        mListener = ln;
                        mEncoding = "iso-2022-jp";
                }

                public void start()
                {
                        mContinue = true;
                        mTCP = new TcpClient(mServer, mPort);
                        mNetStream = mTCP.GetStream();

                        mReader = new StreamReader(mNetStream, Encoding.GetEncoding("iso-2022-jp"));
                        mWriter = new StreamWriter(mNetStream, Encoding.GetEncoding("iso-2022-jp"));

                        string user_cmd = "USER "+mNick+" gyuque * :"+mNick;

                        mWriter.WriteLine(user_cmd);
                        mWriter.WriteLine("NICK " + mNick);

                        foreach(Object ch in mChannels)
                        {
                                string chname = ch.ToString();
                                mWriter.WriteLine("JOIN " + chname);
                        }
                        mWriter.Flush();

                        mNetThread = new Thread(new ThreadStart(run));
                        mNetThread.Start();
                }

                public bool loadConfigFromFile(string fn)
                {
                        StreamReader sr = new StreamReader(fn, System.Text.Encoding.GetEncoding("Shift_JIS"));
                        string content = sr.ReadToEnd();
                        sr.Close();

                        JsonApi.Parser json = new JsonApi.Parser(content);
                        Hashtable root = json.Parse();

                        mServer = root["server"].ToString();
                        mPort = Int32.Parse( root["port"].ToString() );
                        mNick = root["nick"].ToString();

                        Object ch = root["channels"];
                        if (ch is ArrayList)
                        {
                                ArrayList channels = ch as ArrayList;
                                foreach(Object c in channels)
                                        mChannels.Add(c.ToString());
                        }
                        else if (ch is String)
                        {
                                mChannels.Add(ch.ToString());
                        }

                        if (root["encoding"] != null)
                        {
                                mEncoding = root["encoding"].ToString();
                        }

                        mBotChannel = null;
                        if (root["bot_channel"] != null)
                                mBotChannel = root["bot_channel"].ToString();

                        return true;
                }

                private static bool isJoinMsg(string s)
                {
                        return (s.IndexOf("JOIN :") >= 0);
                }

                private static bool isChannelMsg(string s)
                {
                        char[] dlms = {' '};
                        string[] fields = s.Split(dlms);
                        
                        if (fields.Length < 4)
                                return false;

                        if (fields[2].StartsWith("#") && fields[1].ToUpper().Equals("PRIVMSG"))
                                return true;

                        return false;
                }

                private void handleChannelMsg(string s)
                {
                        char[] dlms = {' '};
                        string[] fields = s.Split(dlms);
                        string channel = fields[2];
                        string message = fields[3];

                        if (fields.Length > 4)
                        {
                                for (int i = 4;i < fields.Length;i++)
                                        message += " "+fields[i];
                        }

                        string nick = s.Substring(1, s.IndexOf ("!") - 1);
                        if (message.StartsWith(":"))
                                message = message.Substring(1, message.Length-1);

                        if (mListener != null)
                                mListener.channelMessageArrived(channel, nick, message);
                }

                private void handleJoinMsg(string s)
                {
                        string nick = s.Substring(1, s.IndexOf ("!") - 1);
                        string channel = s.Substring(s.IndexOf ("JOIN :") + 6);

                        if (nick == mNick && mListener != null)
                                mListener.afterIJoined(channel);

                        lock(mJoinedChannels)
                        {
                                mJoinedChannels[channel] = true;
                        }
                }

                public void run()
                {
                        string readLn;
                        KeepAlive ka = new KeepAlive(mWriter, mServer, 20000);
                        while(mContinue) 
                        {
                                while ( (readLn = mReader.ReadLine () ) != null && mContinue)
                                {
                                        Console.WriteLine(readLn);
                                        if (mListener != null)
                                                mListener.anyMessageArrived(readLn);

                                        if (isJoinMsg(readLn))
                                                handleJoinMsg(readLn);
                                        else if (isChannelMsg(readLn))
                                                handleChannelMsg(readLn);

                                        Thread.Sleep(100);
                                }
                                Thread.Sleep(1000);
                        }

                        ka.stop();
                        mReader.Close();
                        mWriter.Close();
                        mNetStream.Close();

                        mTCP.Close();
                }

                public void privmsg(string chname, string msg)
                {
                        if (!mContinue)
                                return;
                        lock(mJoinedChannels)
                        {
                                if (!mJoinedChannels.ContainsKey(chname))
                                        return;
                        }

                        lock(mWriter)
                        {
                                mWriter.WriteLine("PRIVMSG "+chname+" :"+msg);
                                mWriter.Flush();

                                if (mListener != null)
                                        mListener.myMessageSent(chname, mNick, msg);
                        }
                }

                public void stop()
                {
                        mContinue = false;
                }
        }


        class KeepAlive
        {
                static string PING = "PING :";
                private Thread th;
                private string mServerName;
                private int mInterval;
                private StreamWriter mOut;
                private bool mContinue;
                
                public KeepAlive(StreamWriter outs, string servername, int intv)
                {
                        mServerName = servername;
                        mOut = outs;
                        mInterval = intv;
                        mContinue = true;
                        th = new Thread (new ThreadStart(run));
                        th.Start();
                }

                public void stop()
                {
                        mContinue = false;
                }

                public void run()
                {
                        while (mContinue)
                        {
                                lock(mOut)
                                {
                                        mOut.WriteLine (PING + mServerName);
                                        mOut.Flush();
                                }
                                Thread.Sleep(mInterval);
                        }
                }

        }
}