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 => this.client.RemoteEndPoint;
 
        [Obsolete("Use the DisposeAsync() method.")]
        public void Dispose()
        {
            this.DisposeAsync().Wait();
        }
 
        public async Task DisposeAsync()
        {
            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;
 
                if (!(this.client is null))
                {
                    await this.client.DisposeAsync();
                    this.client = null;
                }
            }
        }
 
        public void CloseWhenDone()
        {
            this.client?.DisposeWhenDone();
        }
 
        private async Task<bool> Client_OnReceived(object _, bool ConstantBuffer, byte[] Buffer, int Offset, int Count)
        {
            try
            {
                if (this.server.HasSniffers)
                    this.server.ReceiveBinary(ConstantBuffer, Buffer, Offset, Count);
 
                return await this.ParseIncoming(ConstantBuffer, Buffer, Offset, Count);
            }
            catch (Exception ex)
            {
                if (!this.disposed)
                    this.server.Exception(ex);
 
                return false;
            }
        }
 
        private Task Client_OnError(object Sender, Exception Exception)
        {
            return this.DisposeAsync();
        }
 
        private Task Client_OnDisconnected(object Sender, EventArgs e)
        {
            return this.DisposeAsync();
        }
 
        private async Task<bool> ParseIncoming(bool ConstantBuffer, byte[] Buffer, int Offset, int Count)
        {
            byte b;
 
            while (Count-- > 0)
            {
                b = Buffer[Offset++];
 
                switch (this.inputState)
                {
                    case 0:     // Version
                        if (b != 5)
                        {
                            await this.DisposeAsync();
                            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.nr] = b;
                        this.nr--;
                        if (this.nr == 0)
                        {
                            this.inputState++;
                            if (!await this.SendAuthenticationMethod())
                                return false;
                        }
                        break;
 
                    case 3:     // Version
                        if (b != 5)
                        {
                            await this.DisposeAsync();
                            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:
                                await this.DisposeAsync();
                                return false;
                        }
                        break;
 
                    case 7: // Address length
                        this.nr = b;
                        this.addr = new byte[b];
                        this.inputState++;
                        break;
 
                    case 8: // Address
                        this.addr[^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())
                        {
                            await this.DisposeAsync();
                            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(ConstantBuffer, Buffer, Offset - 1, Count + 1, null, null);
                        else
                        {
                            await this.DisposeAsync();
                            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(true, new byte[] { 5, 0 }, null, null);
            }
 
            return this.client.SendAsync(true, new byte[] { 5, 0xff }, (Sender, e) =>
            {
                return this.DisposeAsync();
            }, null);
        }
 
        private async 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;
                    await this.DisposeAsync();
                    return 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 await this.client.SendAsync(true, Response.ToArray(), null, null);
        }
 
    }
}