Socks5Server.cs

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking.Sniffers;
using Waher.Persistence;
using Waher.Runtime.Cache;
 
namespace Waher.Networking.XMPP.Server.SOCKS5
{
    public class Socks5Server : CommunicationLayer, IDisposable
    {
        public const int DefaultPort = 1080;
 
        public const int DefaultConnectionBacklog = 10;
 
        private LinkedList<TcpListener> listeners = new LinkedList<TcpListener>();
        private Cache<CaseInsensitiveString, Pair> connections;
        private bool disposed = false;
 
        public Socks5Server(params ISniffer[] Sniffers)
            : this(DefaultPort, Sniffers)
        {
        }
 
        public Socks5Server(int Port, params ISniffer[] Sniffers)
            : this(new int[] { Port }, Sniffers)
        {
        }
 
        public Socks5Server(int[] Ports, params ISniffer[] Sniffers)
            : base(false, Sniffers)
        {
            this.connections = new Cache<CaseInsensitiveString, Pair>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromMinutes(1), true);
            this.connections.Removed += this.ClientConnections_Removed;
 
            this.Initialize(Ports);
        }
 
        private async void Initialize(int[] Ports)
        {
            try
            {
                TcpListener Listener;
 
                foreach (NetworkInterface Interface in NetworkInterface.GetAllNetworkInterfaces())
                {
                    if (Interface.OperationalStatus != OperationalStatus.Up)
                        continue;
 
                    IPInterfaceProperties Properties = Interface.GetIPProperties();
 
                    foreach (UnicastIPAddressInformation UnicastAddress in Properties.UnicastAddresses)
                    {
                        if ((UnicastAddress.Address.AddressFamily == AddressFamily.InterNetwork && Socket.OSSupportsIPv4) ||
                            (UnicastAddress.Address.AddressFamily == AddressFamily.InterNetworkV6 && Socket.OSSupportsIPv6))
                        {
                            if (!(Ports is null))
                            {
                                foreach (int C2sPort in Ports)
                                {
                                    try
                                    {
                                        await this.Information("Opening port " + C2sPort.ToString() + " on " + UnicastAddress.Address.ToString() + ".");
 
                                        Listener = new TcpListener(UnicastAddress.Address, C2sPort);
                                        Listener.Start(DefaultConnectionBacklog);
                                        Listener.BeginAcceptTcpClient(this.AcceptTcpClientCallback, Listener);
                                        this.listeners.AddLast(Listener);
 
                                        await this.Information("Port " + C2sPort.ToString() + " on " + UnicastAddress.Address.ToString() + " opened.");
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.Exception(ex, UnicastAddress.Address.ToString() + ":" + C2sPort);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        internal bool RegisterConnection(string StreamId, Socks5Connection Connection)
        {
            if (this.connections.TryGetValue(StreamId, out Pair P))
            {
                if (P.Connection2 is null)
                    P.Connection2 = Connection;
                else
                    return false;
            }
            else
            {
                this.connections[StreamId] = new Pair()
                {
                    Connection1 = Connection
                };
            }
 
            return true;
        }
 
        internal void UnregisterStream(string StreamId, Socks5Connection Connection)
        {
            if (this.connections.TryGetValue(StreamId, out Pair P))
            {
                if (P.Connection1 == Connection)
                {
                    P.Closed1 = true;
                    if (P.Closed2)
                        this.connections.Remove(StreamId);
                    else
                        P.Connection2?.CloseWhenDone();
                }
                else if (P.Connection2 == Connection)
                {
                    P.Closed2 = true;
                    if (P.Closed1)
                        this.connections.Remove(StreamId);
                    else
                        P.Connection1?.CloseWhenDone();
                }
            }
        }
 
        internal bool TryGetRemoteEndpoint(string StreamId, Socks5Connection Sender, out Socks5Connection Receiver)
        {
            if (this.connections.TryGetValue(StreamId, out Pair P))
            {
                if (P.Connection1 == Sender)
                    Receiver = P.Connection2;
                else if (P.Connection2 == Sender)
                    Receiver = P.Connection1;
                else
                    Receiver = null;
            }
            else
                Receiver = null;
 
            return !(Receiver is null);
        }
 
        internal bool Activate(string StreamId)
        {
            if (!this.connections.TryGetValue(StreamId, out Pair P))
                return false;
 
            if (P.Connection1 is null ||
                P.Connection2 is null ||
                !P.Connection1.WaitingForActivation ||
                !P.Connection2.WaitingForActivation)
            {
                return false;
            }
 
            P.Connection1.Activate();
            P.Connection2.Activate();
 
            return true;
        }
 
        private class Pair
        {
            public Socks5Connection Connection1 = null;
            public Socks5Connection Connection2 = null;
            public bool Closed1 = false;
            public bool Closed2 = false;
        }
 
        private Task ClientConnections_Removed(object Sender, CacheItemEventArgs<CaseInsensitiveString, Pair> e)
        {
            e.Value.Connection1?.Dispose();
            e.Value.Connection2?.Dispose();
 
            return Task.CompletedTask;
        }
 
        public void Dispose()
        {
            this.disposed = true;
 
            this.connections?.Clear();
            this.connections?.Dispose();
            this.connections = null;
 
            if (!(this.listeners is null))
            {
                LinkedList<TcpListener> Listeners = this.listeners;
                this.listeners = null;
 
                foreach (TcpListener Listener in Listeners)
                    Listener.Stop();
            }
        }
 
        public int[] OpenC2SPorts
        {
            get
            {
                SortedDictionary<int, bool> Open = new SortedDictionary<int, bool>();
 
                if (!(this.listeners is null))
                {
                    IPEndPoint IPEndPoint;
 
                    foreach (TcpListener Listener in this.listeners)
                    {
                        IPEndPoint = Listener.LocalEndpoint as IPEndPoint;
                        if (!(IPEndPoint is null))
                            Open[IPEndPoint.Port] = true;
                    }
                }
 
                int[] Result = new int[Open.Count];
                Open.Keys.CopyTo(Result, 0);
 
                return Result;
            }
        }
 
        public bool IsOpen
        {
            get
            {
                return !(this.listeners?.First is null);
            }
        }
 
        private async void AcceptTcpClientCallback(IAsyncResult ar)
        {
            try
            {
                if (this.disposed || NetworkingModule.Stopping)
                    return;
 
                TcpListener Listener = (TcpListener)ar.AsyncState;
 
                if (!this.disposed)
                {
                    try
                    {
                        TcpClient Client = Listener.EndAcceptTcpClient(ar);
                        await this.Information("Connection accepted from " + Client.Client.RemoteEndPoint.ToString() + ".");
 
                        BinaryTcpClient BinaryTcpClient = new BinaryTcpClient(Client, false);
                        BinaryTcpClient.Bind(true);
 
                        new Socks5Connection(BinaryTcpClient, this);
 
                        BinaryTcpClient.Continue();
                    }
                    finally
                    {
                        if (!this.disposed)
                            Listener.BeginAcceptTcpClient(this.AcceptTcpClientCallback, Listener);
                    }
                }
            }
            catch (SocketException)
            {
                // Ignore
            }
            catch (ObjectDisposedException)
            {
                // Ignore
            }
            catch (NullReferenceException)
            {
                // Ignore
            }
            catch (Exception ex)
            {
                if (this.listeners is null)
                    return;
 
                Log.Exception(ex);
            }
        }
 
    }
}