source: binary-improvements/7dtd-server-fixes/src/NetConnections/Servers/Telnet/TelnetConnection.cs@ 186

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

namespace AllocsFixes.NetConnections.Servers.Telnet
{
        public class TelnetConnection : IConnection
        {
                private readonly BlockingQueue<string> toClientQueue = new BlockingQueue<string> ();
                private readonly Telnet owner;
                private readonly Thread receiveThread = null;
                private readonly Thread sendThread = null;
                private int authTries = 0;
                private bool authenticated = false;
                private readonly bool authEnabled;
                private TcpClient client;
                private readonly NetworkStream stream;
                private readonly EndPoint endpoint;
                private readonly int endpointAddressHash;

                public TelnetConnection (Telnet owner, TcpClient client, bool authEnabled)
                {
                        this.owner = owner;
                        this.authEnabled = authEnabled;
                        this.client = client;
                        this.stream = client.GetStream ();
                        this.endpoint = client.Client.RemoteEndPoint;

                        Log.Out ("Telnet connection from: " + endpoint);

                        receiveThread = ThreadMaster.Create ("TelnetClientReceive", new ThreadStart (ReceiveThread));
                        receiveThread.Start ();
                        sendThread = ThreadMaster.Create ("TelnetClientSend", new ThreadStart (SendThread));
                        sendThread.Start ();

                        if (endpoint is IPEndPoint) {
                                endpointAddressHash = ((IPEndPoint)endpoint).Address.GetHashCode();
                                //Log.Out ("Hash: " + endpointAddressHash);
                        } else {
                                Log.Out ("EndPoint is not an IPEndPoint but: " + endpoint.GetType().ToString());
                        }

                        if (authEnabled) {
                                WriteLine ("Please enter password:");
                        } else {
                                LoginMessage ();
                        }
                }

                private void LoginMessage ()
                {
                        WriteLine ("*** Connected with 7DTD server.");
                        WriteLine ("*** Dedicated server only build");
                        WriteLine ("*** Allocs server fixes loaded");
                        WriteLine (string.Empty);
                        WriteLine ("Server IP:   " + 
                                ((GamePrefs.GetString (EnumGamePrefs.ServerIP) != null && GamePrefs.GetString (EnumGamePrefs.ServerIP).Length != 0) ? GamePrefs.GetString (EnumGamePrefs.ServerIP) : "Any")
                        );
                        WriteLine ("Server port: " + GamePrefs.GetInt (EnumGamePrefs.ServerPort));
                        WriteLine ("Max players: " + GamePrefs.GetInt (EnumGamePrefs.ServerMaxPlayerCount));
                        WriteLine ("Game mode:   " + GamePrefs.GetString (EnumGamePrefs.GameMode));
                        WriteLine ("World:       " + GamePrefs.GetString (EnumGamePrefs.GameWorld));
                        WriteLine ("Game name:   " + GamePrefs.GetString (EnumGamePrefs.GameName));
                        WriteLine ("Difficulty:  " + GamePrefs.GetInt (EnumGamePrefs.GameDifficulty));
                        WriteLine (string.Empty);
                        WriteLine ("Press 'help' to get a list of all commands. Press 'exit' to end session.");
                        WriteLine (string.Empty);
                }

                private void ReceiveThread ()
                {
                        try {
                                StreamReader reader = new StreamReader (stream);
                                try {
                                        while (!IsClosed()) {
                                                string line = reader.ReadLine ();
                                                if (line != null) {
                                                        line = line.Trim ();

                                                        if (!IsAuthenticated ()) {
                                                                if (line.Equals (GamePrefs.GetString (EnumGamePrefs.TelnetPassword))) {
                                                                        authenticated = true;
                                                                        WriteLine ("Logon successful.");
                                                                        WriteLine (string.Empty);
                                                                        WriteLine (string.Empty);
                                                                        WriteLine (string.Empty);
                                                                        LoginMessage ();
                                                                } else {
                                                                        authTries++;
                                                                        // TODO: check if IP has more login attempts by now
                                                                        if (authTries < 3) {
                                                                                WriteLine ("Password incorrect, please enter password:");
                                                                        } else {
                                                                                WriteLine ("Too many failed login attempts!");
                                                                                Thread.Sleep(100);
                                                                                //TODO: owner.FailedLogins();
                                                                                Close ();
                                                                                Log.Out ("Telnet connection closed for too many login attempts: " + endpoint);
                                                                                break;
                                                                        }
                                                                }
                                                        } else {
                                                                if (line.ToLower ().Equals ("exit")) {
                                                                        Log.Out ("Telnet connection closed by client: " + endpoint);
                                                                        Close ();
                                                                        break;
                                                                }
                                                                Log.Out ("Telnet executed \"" + line + "\" from: " + endpoint);
                                                                ConsoleOutputSeparator.QueueNetCommand (line, this);
                                                        }
                                                }
                                        }
                                } catch (ObjectDisposedException) {
                                } catch (IOException) {
                                } catch (ThreadInterruptedException) {
                                }
                                ThreadMaster.Remove (Thread.CurrentThread.Name);
                        } catch (Exception ex) {
                                Log.Out ("Error in TelnetClientReceive: " + ex);
                        }

                }

                private void SendThread ()
                {
                        try {
                                while (!IsClosed() && stream.CanWrite) {
                                        try {
                                                string line = toClientQueue.Dequeue ();
                                                if (!IsClosed () && stream.CanWrite) {
                                                        byte[] utfData = Encoding.UTF8.GetBytes (line);
                                                        stream.Write (utfData, 0, utfData.Length);
                                                        stream.WriteByte (13);
                                                        stream.WriteByte (10);
                                                }
                                        } catch (IOException) {
                                        } catch (ThreadInterruptedException) {
                                        } catch (Exception e) {
                                                Log.Out ("Error writing to client: " + e);
                                        }
                                }

                                ThreadMaster.Remove (Thread.CurrentThread.Name);
                        } catch (Exception ex) {
                                Log.Out ("Error in TelnetClientSend: " + ex);
                        }

                }

                public void WriteLine (string s)
                {
                        toClientQueue.Enqueue (s);
                }

                public void Close ()
                {
                        if (receiveThread != null) {
                                receiveThread.Interrupt ();
                        }
                        if (sendThread != null) {
                                sendThread.Interrupt ();
                        }
                        if (client != null)
                                client.Close ();
                        client = null;
                }

                public bool IsClosed ()
                {
                        if (client != null && !client.Connected) {
                                Log.Out ("Telnet connection interrupted: " + endpoint);
                                Close ();
                        }
                        return (client == null) || (!client.Connected);
                }

                public bool IsAuthenticated ()
                {
                        return !authEnabled || authenticated;
                }

        }
}