Socks5Connection.cs

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
 
namespace Waher.Networking.XMPP.Server.SOCKS5
{
    public class Socks5Connection : IDisposable
    {
        private Socks5Server server;
        private BinaryTcpClient client;
        private byte[] addr = null;
        private string streamId = null;
        private bool disposed = false;
        private int inputState = 0;
        private ushort port;
        private byte nr;
        private byte command;
        private byte addrType;
        private byte[] methods;
 
        public Socks5Connection(BinaryTcpClient Client, Socks5Server Server)
        {
            this.client = Client;
            this.server = Server;
 
            this.client.OnDisconnected += this.Client_OnDisconnected;
            this.client.OnError += this.Client_OnError;
            this.client.OnReceived += this.Client_OnReceived;
        }
 
        public Socks5Server Server
        {
            get => this.server;
        }
 
        public string RemoteEndpoint
        {
            get { return this.client.Client.Client.RemoteEndPoint.ToString(); }
        }
 
        public void Dispose()
        {
            if (!this.disposed)
            {
                this.disposed = true;
 
                if (!(this.streamId is null))
                {
                    this.server.UnregisterStream(this.streamId, this);
                    this.streamId = null;
                }
 
                this.server = null;
                this.inputState = -1;
 
                this.client?.Dispose();
                this.client = null;
            }
        }
 
        public void CloseWhenDone()
        {
            this.client?.DisposeWhenDone();
        }
 
        private async Task<bool> Client_OnReceived(object Sender, byte[] Buffer, int Offset, int Count)
        {
            try
            {
                if (this.server.HasSniffers)
                    await this.server.ReceiveBinary(BinaryTcpClient.ToArray(Buffer, Offset, Count));
 
                return await this.ParseIncoming(Buffer, Offset, Count);
            }
            catch (Exception ex)
            {
                if (!this.disposed)
                    await this.server.Exception(ex);
 
                return false;
            }
        }
 
        private Task Client_OnError(object Sender, Exception Exception)
        {
            this.Dispose();
            return Task.CompletedTask;
        }
 
        private Task Client_OnDisconnected(object Sender, EventArgs e)
        {
            this.Dispose();
            return Task.CompletedTask;
        }
 
        private async Task<bool> ParseIncoming(byte[] Buffer, int Offset, int Count)
        {
            byte b;
 
            while (Count-- > 0)
            {
                b = Buffer[Offset++];
 
                switch (this.inputState)
                {
                    case 0:     // Version
                        if (b != 5)
                        {
                            this.Dispose();
                            return false;
                        }
                        this.inputState++;
                        break;
 
                    case 1:     // Nr methods.
                        this.nr = b;
                        this.methods = new byte[b];
 
                        if (this.nr == 0)
                        {
                            this.inputState += 2;
                            if (!await this.SendAuthenticationMethod())
                                return false;
                        }
                        else
                            this.inputState++;
                        break;
 
                    case 2:     // Method
                        this.methods[this.methods.Length - this.nr] = b;
                        this.nr--;
                        if (this.nr == 0)
                        {
                            this.inputState++;
                            if (!await this.SendAuthenticationMethod())
                                return false;
                        }
                        break;
 
                    case 3:     // Version
                        if (b != 5)
                        {
                            this.Dispose();
                            return false;
                        }
                        this.inputState++;
                        break;
 
                    case 4: // Command
                        this.command = b;
                        this.inputState++;
                        break;
 
                    case 5: // Reserved
                        this.inputState++;
                        break;
 
                    case 6: // Address type
                        switch (this.addrType = b)
                        {
                            case 1:
                                this.nr = 4;
                                this.addr = new byte[4];
                                this.inputState += 2;
                                break;
 
                            case 3:
                                this.inputState++;
                                break;
 
                            case 4:
                                this.nr = 16;
                                this.addr = new byte[16];
                                this.inputState += 2;
                                break;
 
                            default:
                                this.Dispose();
                                return false;
                        }
                        break;
 
                    case 7: // Address length
                        this.nr = b;
                        this.addr = new byte[b];
                        this.inputState++;
                        break;
 
                    case 8: // Address
                        this.addr[this.addr.Length - this.nr] = b;
                        this.nr--;
                        if (this.nr == 0)
                            this.inputState++;
                        break;
 
                    case 9: // Port, MSB
                        this.port = b;
                        this.inputState++;
                        break;
 
                    case 10: // Port, LSB
                        this.port <<= 8;
                        this.port |= b;
                        this.inputState = 3;
                        if (!await this.ExecuteCommand())
                        {
                            this.Dispose();
                            return false;
                        }
                        break;
 
                    case 11:    // Wait for activation
                        break;
 
                    case 12:    // Data through active channel.
                        if (this.server.TryGetRemoteEndpoint(this.streamId, this, out Socks5Connection RemoteEndpoint))
                            return await RemoteEndpoint.client.SendAsync(Buffer, Offset - 1, Count + 1, null, null);
                        else
                        {
                            this.Dispose();
                            return false;
                        }
                }
            }
 
            return true;
        }
 
        internal bool WaitingForActivation
        {
            get { return this.inputState == 11; }
        }
 
        internal void Activate()
        {
            this.inputState = 12;
        }
 
        private Task<bool> SendAuthenticationMethod()
        {
            foreach (byte b in this.methods)
            {
                if (b == 0)
                    return this.client.SendAsync(new byte[] { 5, 0 }, null, null);
            }
 
            return this.client.SendAsync(new byte[] { 5, 0xff }, (Sender, e) =>
            {
                this.Dispose();
                return Task.CompletedTask;
            }, null);
        }
 
        private Task<bool> ExecuteCommand()
        {
            using (MemoryStream Response = new MemoryStream())
            {
                Response.WriteByte(5);
 
                if (this.addrType != 3)
                    Response.WriteByte(8);
                else if (this.command != 1)
                    Response.WriteByte(7);
                else
                {
                    Response.WriteByte(0);
 
                    this.inputState = 11;
                    this.streamId = Encoding.ASCII.GetString(this.addr);
 
                    if (!this.server.RegisterConnection(this.streamId, this))
                    {
                        this.streamId = null;
                        this.Dispose();
                        return Task.FromResult(false);
                    }
                }
 
                Response.WriteByte(0);
                Response.WriteByte(this.addrType);
 
                if (this.addrType == 3)
                    Response.WriteByte((byte)this.addr.Length);
 
                Response.Write(this.addr, 0, this.addr.Length);
                Response.WriteByte((byte)(this.port >> 8));
                Response.WriteByte((byte)(this.port & 0xff));
 
                return this.client.SendAsync(Response.ToArray(), null, null);
            }
        }
 
    }
}