Ignore:
Timestamp:
Sep 13, 2014, 12:55:47 PM (10 years ago)
Author:
alloc
Message:

fixes

Location:
binary-improvements/7dtd-server-fixes/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • binary-improvements/7dtd-server-fixes/src/BlockingQueue.cs

    r182 r190  
    77        public class BlockingQueue<T>
    88        {
     9                private bool closing = false;
    910                private Queue<T> queue = new Queue<T> ();
    1011
    … …  
    2122                        lock (queue) {
    2223                                while (queue.Count == 0) {
     24                                        if (closing) {
     25                                                return default(T);
     26                                        }
    2327                                        Monitor.Wait (queue);
    2428                                }
    … …  
    2731                }
    2832
     33                public void Close ()
     34                {
     35                        lock (queue) {
     36                                closing = true;
     37                                Monitor.PulseAll (queue);
     38                        }
     39                }
    2940
    3041        }

  • binary-improvements/7dtd-server-fixes/src/NetConnections/ConsoleOutputSeparator.cs

    r189 r190  
    4848                        } else {
    4949                                if (console.telnetServer != null && issuerOfCurrentCommand != null)
    50                                         NetTelnetServer.WriteToClient_Single (_line, issuerOfCurrentCommand);
     50                                        issuerOfCurrentCommand.SendLine (_line);
    5151                                else if (ControlPanel.IsStarted ())
    5252                                        ControlPanel.AddTextToOutputBuffer (_line);

  • binary-improvements/7dtd-server-fixes/src/NetConnections/IConnection.cs

    r132 r190  
    11using System;
     2using UnityEngine;
    23
    34namespace AllocsFixes.NetConnections
    … …  
    56        public interface IConnection
    67        {
     8                void SendLine (string line);
     9                void SendLog (string text, string trace, LogType type);
     10                string GetDescription ();
    711        }
    812}

  • binary-improvements/7dtd-server-fixes/src/NetConnections/IServer.cs

    r132 r190  
    11using System;
     2using UnityEngine;
    23
    34namespace AllocsFixes.NetConnections
    … …  
    78                void Disconnect ();
    89
    9                 void WriteToClient (string line);
    10 
    11                 void WriteToClient_Single (string line, IConnection client);
     10                void SendLine (string line);
     11                void SendLog (string text, string trace, LogType type);
    1212        }
    1313}

  • binary-improvements/7dtd-server-fixes/src/NetConnections/NetTelnetServer.cs

    r182 r190  
    3232                public static void Disconnect ()
    3333                {
     34                        Log.Out ("Disconnect console clients!");
    3435                        foreach (IServer s in servers)
    3536                                s.Disconnect ();
    … …  
    4243                        }
    4344                        foreach (IServer s in servers)
    44                                 s.WriteToClient (line);
     45                                s.SendLine (line);
    4546                }
    4647
    47                 public static void WriteToClient_Single (string line, IConnection client)
    48                 {
    49                         if (line == null) {
    50                                 return;
    51                         }
    52                         foreach (IServer s in servers)
    53                                 s.WriteToClient_Single (line, client);
    54                 }
    5548        }
    5649}

  • binary-improvements/7dtd-server-fixes/src/NetConnections/Servers/Telnet/Telnet.cs

    r187 r190  
    6363                }
    6464
    65                 public bool RegisterFailedLogin (int addressHash)
    66                 {
    67                         lock (loginAttemptsPerIP) {
    68                                 LoginAttempts la = loginAttemptsPerIP [addressHash];
    69                                 return la.LogAttempt ();
    70                         }
    71                 }
    72 
    7365                private void AcceptClient (IAsyncResult asyncResult)
    7466                {
    … …  
    8072                                if (endpoint is IPEndPoint) {
    8173                                        addressHash = ((IPEndPoint)endpoint).Address.GetHashCode ();
    82                                         //Log.Out ("Hash: " + endpointAddressHash);
    8374                                } else {
     75                                        addressHash = endpoint.GetHashCode ();
    8476                                        Log.Out ("EndPoint is not an IPEndPoint but: " + endpoint.GetType ().ToString ());
    8577                                }
    … …  
    8779                                lock (loginAttemptsPerIP) {
    8880                                        LoginAttempts la = null;
    89                                         if (loginAttemptsPerIP.ContainsKey(addressHash))
     81                                        if (loginAttemptsPerIP.ContainsKey (addressHash))
    9082                                                la = loginAttemptsPerIP [addressHash];
    9183                                        if (la == null) {
    … …  
    9587                                        if (!la.IsBanned ()) {
    9688                                                TelnetConnection con = new TelnetConnection (this, client, authEnabled);
    97                                                 connections.Add (con);
     89                                                lock (connections) {
     90                                                        connections.Add (con);
     91                                                }
    9892                                        } else {
    9993                                                client.Close ();
    … …  
    10296                                }
    10397                                listener.BeginAcceptTcpClient (new AsyncCallback (AcceptClient), null);
     98                        }
     99                }
     100
     101                public bool RegisterFailedLogin (TelnetConnection con)
     102                {
     103                        lock (loginAttemptsPerIP) {
     104                                LoginAttempts la = loginAttemptsPerIP [con.EndPointHash];
     105                                return la.LogAttempt ();
     106                        }
     107                }
     108
     109                public void ConnectionClosed (TelnetConnection con)
     110                {
     111                        lock (connections) {
     112                                connections.Remove (con);
    104113                        }
    105114                }
    … …  
    112121                                        listener = null;
    113122                                }
    114                                 foreach (TelnetConnection c in connections) {
     123                                List<TelnetConnection> cur = new List<TelnetConnection> (connections);
     124                                foreach (TelnetConnection c in cur) {
    115125                                        c.Close ();
    116126                                }
    … …  
    120130                }
    121131
    122                 private void RemoveClosedConnections ()
    123                 {
    124                         try {
    125                                 List<TelnetConnection> toRemove = new List<TelnetConnection> ();
    126                                 foreach (TelnetConnection c in connections) {
    127                                         if (c.IsClosed ())
    128                                                 toRemove.Add (c);
    129                                 }
    130                                 foreach (TelnetConnection c in toRemove) {
    131                                         connections.Remove (c);
    132                                 }
    133                         } catch (Exception e) {
    134                                 Log.Out ("Error in Telnet.RemoveClosedConnections: " + e);
    135                         }
    136                 }
    137 
    138                 public void WriteToClient (string line)
     132                public void SendLine (string line)
    139133                {
    140134                        if (line == null) {
    141135                                return;
    142136                        }
    143                         RemoveClosedConnections ();
    144                         foreach (TelnetConnection c in connections) {
    145                                 if (c.IsAuthenticated ())
    146                                         c.WriteLine (line);
     137                        lock (connections) {
     138                                foreach (TelnetConnection c in connections) {
     139                                        c.SendLine (line);
     140                                }
    147141                        }
    148142                }
    149143
    150                 public void WriteToClient_Single (string line, IConnection client)
     144                public void SendLog (string text, string trace, UnityEngine.LogType type)
    151145                {
    152                         if (line == null) {
    153                                 return;
    154                         }
    155                         RemoveClosedConnections ();
    156                         foreach (TelnetConnection con in connections) {
    157                                 if (con == client) {
    158                                         if (con.IsAuthenticated ())
    159                                                 con.WriteLine (line);
    160                                 }
    161                         }
     146                        throw new System.NotImplementedException ();
    162147                }
    163148

  • binary-improvements/7dtd-server-fixes/src/NetConnections/Servers/Telnet/TelnetConnection.cs

    r189 r190  
    1212        {
    1313                private readonly BlockingQueue<string> toClientQueue = new BlockingQueue<string> ();
    14                 private readonly Telnet owner;
     14                private readonly Telnet telnet;
    1515                private readonly Thread receiveThread = null;
    1616                private readonly Thread sendThread = null;
    1717                private bool authenticated = false;
    1818                private readonly bool authEnabled;
    19                 private TcpClient client;
    20                 private readonly NetworkStream stream;
     19                private readonly TcpClient client;
    2120                private readonly EndPoint endpoint;
    2221                private readonly int endpointAddressHash;
     22                private bool closed = false;
     23
     24                public bool IsClosed { get { return closed; } }
     25
     26                public bool IsAuthenticated { get { return !authEnabled || authenticated; } }
     27
     28                public int EndPointHash { get { return endpointAddressHash; } }
    2329
    2430                public TelnetConnection (Telnet owner, TcpClient client, bool authEnabled)
    2531                {
    26                         this.owner = owner;
     32                        this.telnet = owner;
    2733                        this.authEnabled = authEnabled;
    2834                        this.client = client;
    29                         this.stream = client.GetStream ();
    3035                        this.endpoint = client.Client.RemoteEndPoint;
     36
     37                        if (endpoint is IPEndPoint) {
     38                                endpointAddressHash = ((IPEndPoint)endpoint).Address.GetHashCode ();
     39                        } else {
     40                                endpointAddressHash = endpoint.GetHashCode ();
     41                                Log.Out ("EndPoint is not an IPEndPoint but: " + endpoint.GetType ().ToString ());
     42                        }
    3143
    3244                        Log.Out ("Telnet connection from: " + endpoint);
    3345
    34                         receiveThread = ThreadMaster.Create ("TelnetClientReceive", new ThreadStart (ReceiveThread));
     46                        receiveThread = ThreadMaster.Create ("TelnetClientReceive_" + endpoint.ToString (), new ThreadStart (ReceiveThread));
    3547                        receiveThread.Start ();
    36                         sendThread = ThreadMaster.Create ("TelnetClientSend", new ThreadStart (SendThread));
     48                        sendThread = ThreadMaster.Create ("TelnetClientSend" + endpoint.ToString (), new ThreadStart (SendThread));
    3749                        sendThread.Start ();
    3850
    39                         if (endpoint is IPEndPoint) {
    40                                 endpointAddressHash = ((IPEndPoint)endpoint).Address.GetHashCode ();
    41                                 //Log.Out ("Hash: " + endpointAddressHash);
    42                         } else {
    43                                 Log.Out ("EndPoint is not an IPEndPoint but: " + endpoint.GetType ().ToString ());
    44                         }
    45 
    4651                        if (authEnabled) {
    47                                 WriteLine ("Please enter password:");
     52                                toClientQueue.Enqueue ("Please enter password:");
    4853                        } else {
    4954                                LoginMessage ();
    … …  
    5358                private void LoginMessage ()
    5459                {
    55                         WriteLine ("*** Connected with 7DTD server.");
    56                         WriteLine ("*** Dedicated server only build");
    57                         WriteLine ("*** Allocs server fixes loaded");
    58                         WriteLine (string.Empty);
    59                         WriteLine ("Server IP:   " +
     60                        toClientQueue.Enqueue ("*** Connected with 7DTD server.");
     61                        toClientQueue.Enqueue ("*** Dedicated server only build");
     62                        toClientQueue.Enqueue ("*** Allocs server fixes loaded");
     63                        toClientQueue.Enqueue (string.Empty);
     64                        toClientQueue.Enqueue ("Server IP:   " +
    6065                                ((GamePrefs.GetString (EnumGamePrefs.ServerIP) != null && GamePrefs.GetString (EnumGamePrefs.ServerIP).Length != 0) ? GamePrefs.GetString (EnumGamePrefs.ServerIP) : "Any")
    6166                        );
    62                         WriteLine ("Server port: " + GamePrefs.GetInt (EnumGamePrefs.ServerPort));
    63                         WriteLine ("Max players: " + GamePrefs.GetInt (EnumGamePrefs.ServerMaxPlayerCount));
    64                         WriteLine ("Game mode:   " + GamePrefs.GetString (EnumGamePrefs.GameMode));
    65                         WriteLine ("World:       " + GamePrefs.GetString (EnumGamePrefs.GameWorld));
    66                         WriteLine ("Game name:   " + GamePrefs.GetString (EnumGamePrefs.GameName));
    67                         WriteLine ("Difficulty:  " + GamePrefs.GetInt (EnumGamePrefs.GameDifficulty));
    68                         WriteLine (string.Empty);
    69                         WriteLine ("Press 'help' to get a list of all commands. Press 'exit' to end session.");
    70                         WriteLine (string.Empty);
     67                        toClientQueue.Enqueue ("Server port: " + GamePrefs.GetInt (EnumGamePrefs.ServerPort));
     68                        toClientQueue.Enqueue ("Max players: " + GamePrefs.GetInt (EnumGamePrefs.ServerMaxPlayerCount));
     69                        toClientQueue.Enqueue ("Game mode:   " + GamePrefs.GetString (EnumGamePrefs.GameMode));
     70                        toClientQueue.Enqueue ("World:       " + GamePrefs.GetString (EnumGamePrefs.GameWorld));
     71                        toClientQueue.Enqueue ("Game name:   " + GamePrefs.GetString (EnumGamePrefs.GameName));
     72                        toClientQueue.Enqueue ("Difficulty:  " + GamePrefs.GetInt (EnumGamePrefs.GameDifficulty));
     73                        toClientQueue.Enqueue (string.Empty);
     74                        toClientQueue.Enqueue ("Press 'help' to get a list of all commands. Press 'exit' to end session.");
     75                        toClientQueue.Enqueue (string.Empty);
    7176                }
    7277
    … …  
    7479                {
    7580                        try {
    76                                 StreamReader reader = new StreamReader (stream);
    77                                 try {
    78                                         while (!IsClosed()) {
    79                                                 string line = reader.ReadLine ();
    80                                                 if (line != null && line.Length > 0) {
    81                                                         line = line.Trim ();
    82                                                         if (line.Length > 0) {
    83                                                                 if (!IsAuthenticated ()) {
    84                                                                         if (line.Equals (GamePrefs.GetString (EnumGamePrefs.TelnetPassword))) {
    85                                                                                 authenticated = true;
    86                                                                                 WriteLine ("Logon successful.");
    87                                                                                 WriteLine (string.Empty);
    88                                                                                 WriteLine (string.Empty);
    89                                                                                 WriteLine (string.Empty);
    90                                                                                 LoginMessage ();
    91                                                                         } else {
    92                                                                                 if (owner.RegisterFailedLogin (endpointAddressHash)) {
    93                                                                                         WriteLine ("Password incorrect, please enter password:");
    94                                                                                 } else {
    95                                                                                         WriteLine ("Too many failed login attempts!");
    96                                                                                         Thread.Sleep (100);
    97                                                                                         Close ();
    98                                                                                         Log.Out ("Telnet connection closed for too many login attempts: " + endpoint);
    99                                                                                         break;
    100                                                                                 }
    101                                                                         }
     81                                StreamReader reader = new StreamReader (client.GetStream ());
     82                                while (!closed) {
     83                                        string line = reader.ReadLine ();
     84                                        if (line != null && (line = line.Trim ()).Length > 0) {
     85                                                if (!IsAuthenticated) {
     86                                                        if (line.Equals (GamePrefs.GetString (EnumGamePrefs.TelnetPassword))) {
     87                                                                authenticated = true;
     88                                                                toClientQueue.Enqueue ("Logon successful.");
     89                                                                toClientQueue.Enqueue (string.Empty);
     90                                                                toClientQueue.Enqueue (string.Empty);
     91                                                                toClientQueue.Enqueue (string.Empty);
     92                                                                LoginMessage ();
     93                                                        } else {
     94                                                                if (telnet.RegisterFailedLogin (this)) {
     95                                                                        toClientQueue.Enqueue ("Password incorrect, please enter password:");
    10296                                                                } else {
    103                                                                         if (line.ToLower ().Equals ("exit")) {
    104                                                                                 Log.Out ("Telnet connection closed by client: " + endpoint);
    105                                                                                 Close ();
    106                                                                                 break;
    107                                                                         }
    108                                                                         Log.Out ("Telnet executed \"" + line + "\" from: " + endpoint);
    109                                                                         ConsoleOutputSeparator.QueueNetCommand (line, this);
     97                                                                        toClientQueue.Enqueue ("Too many failed login attempts!");
     98                                                                        Thread.Sleep (100);
     99                                                                        Close (true);
     100                                                                        break;
    110101                                                                }
    111102                                                        }
     103                                                } else {
     104                                                        if (line.ToLower ().Equals ("exit")) {
     105                                                                break;
     106                                                        }
     107                                                        Log.Out ("Telnet executed \"" + line + "\" from: " + endpoint);
     108                                                        ConsoleOutputSeparator.QueueNetCommand (line, this);
    112109                                                }
    113110                                        }
    114                                 } catch (ObjectDisposedException) {
    115                                 } catch (IOException) {
    116                                 } catch (ThreadInterruptedException) {
    117111                                }
    118                                 ThreadMaster.Remove (Thread.CurrentThread.Name);
    119                         } catch (Exception ex) {
    120                                 Log.Out ("Error in TelnetClientReceive: " + ex);
     112                        } catch (Exception) {
    121113                        }
    122114
     115                        if (!closed)
     116                                Close ();
     117                        ThreadMaster.Remove (Thread.CurrentThread.Name);
    123118                }
    124119
    … …  
    126121                {
    127122                        try {
    128                                 while (!IsClosed() && stream.CanWrite) {
    129                                         try {
    130                                                 string line = toClientQueue.Dequeue ();
    131                                                 if (!IsClosed () && stream.CanWrite) {
     123                                while (!closed && client.GetStream ().CanWrite) {
     124                                        string line = toClientQueue.Dequeue ();
     125                                        if (!closed && client.GetStream ().CanWrite) {
     126                                                if (line == null) {
     127                                                        client.GetStream ().WriteByte (0);
     128                                                } else {
    132129                                                        byte[] utfData = Encoding.UTF8.GetBytes (line);
    133                                                         stream.Write (utfData, 0, utfData.Length);
    134                                                         stream.WriteByte (13);
    135                                                         stream.WriteByte (10);
     130                                                        client.GetStream ().Write (utfData, 0, utfData.Length);
     131                                                        client.GetStream ().WriteByte (13);
     132                                                        client.GetStream ().WriteByte (10);
    136133                                                }
    137                                         } catch (IOException) {
    138                                         } catch (ThreadInterruptedException) {
    139                                         } catch (Exception e) {
    140                                                 Log.Out ("Error writing to client: " + e);
    141134                                        }
    142135                                }
    143 
    144                                 ThreadMaster.Remove (Thread.CurrentThread.Name);
    145                         } catch (Exception ex) {
    146                                 Log.Out ("Error in TelnetClientSend: " + ex);
     136                        } catch (Exception) {
    147137                        }
    148138
     139                        if (!closed)
     140                                Close ();
     141                        ThreadMaster.Remove (Thread.CurrentThread.Name);
    149142                }
    150143
    151                 public void WriteLine (string s)
     144                public void Close (bool kickedForLogins = false)
    152145                {
    153                         toClientQueue.Enqueue (s);
     146                        if (!closed) {
     147                                closed = true;
     148                                toClientQueue.Close ();
     149                                client.GetStream ().Close ();
     150                                client.Close ();
     151                                telnet.ConnectionClosed (this);
     152
     153                                if (kickedForLogins)
     154                                        Log.Out ("Telnet connection closed for too many login attempts: " + endpoint);
     155                                else
     156                                        Log.Out ("Telnet connection closed: " + endpoint);
     157                        }
    154158                }
    155159
    156                 public void Close ()
     160                public void SendLine (string line)
    157161                {
    158                         if (receiveThread != null) {
    159                                 receiveThread.Interrupt ();
    160                         }
    161                         if (sendThread != null) {
    162                                 sendThread.Interrupt ();
    163                         }
    164                         if (client != null)
    165                                 client.Close ();
    166                         client = null;
     162                        if (!closed && IsAuthenticated)
     163                                toClientQueue.Enqueue (line);
     164                        else
     165                                toClientQueue.Enqueue (null);
    167166                }
    168167
    169                 public bool IsClosed ()
     168                public void SendLog (string text, string trace, UnityEngine.LogType type)
    170169                {
    171                         if (client != null && !client.Connected) {
    172                                 Log.Out ("Telnet connection interrupted: " + endpoint);
    173                                 Close ();
    174                         }
    175                         return (client == null) || (!client.Connected);
     170                        throw new System.NotImplementedException ();
    176171                }
    177172
    178                 public bool IsAuthenticated ()
     173                public string GetDescription ()
    179174                {
    180                         return !authEnabled || authenticated;
     175                        return "Telnet from " + endpoint;
    181176                }
    182 
    183177        }
    184178}

  • binary-improvements/7dtd-server-fixes/src/NetConnections/Servers/Web/Web.cs

    r185 r190  
    128128                }
    129129
    130                 public void WriteToClient (string line)
     130                public void SendLine (string line)
    131131                {
    132132                        try {
    … …  
    137137                }
    138138
    139                 public void WriteToClient_Single (string line, IConnection client)
     139                public void SendLog (string text, string trace, UnityEngine.LogType type)
    140140                {
    141                         try {
    142                                 //Log.Out ("NOT IMPLEMENTED: Web.WriteToClient_Single");
    143                         } catch (Exception e) {
    144                                 Log.Out ("Error in Web.WriteToClient_Single: " + e);
    145                         }
     141                        throw new System.NotImplementedException ();
    146142                }
    147143
Note: See TracChangeset for help on using the changeset viewer.