FtpClientConnection.cs

using System;
using System.ComponentModel;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking.SASL;
using Waher.Networking.Sniffers;
using Waher.Persistence;
using Waher.Runtime.IO;
using Waher.Security;
using Waher.Security.LoginMonitor;
 
namespace Waher.Networking.FTP.Server
{
    public abstract class FtpClientConnection : CommunicationLayer, ISaslServerSide, IDisposableAsync
    {
        private static readonly Random rnd = new Random();
 
        private readonly Guid id = Guid.NewGuid();
        private readonly UTF8Encoding encoding = new UTF8Encoding(false, false);
        private FtpServer server;
        private BinaryTcpClient client;
        private readonly IFtpServerPersistenceLayer persistence;
        private IAccount account = null;
        private string authId = null;
        private bool disposed = false;
        private CaseInsensitiveString userName = CaseInsensitiveString.Empty;
        private object tag = null;
        private bool upgradeToTls = false;
 
        public FtpClientConnection(BinaryTcpClient Client, FtpServer Server, IFtpServerPersistenceLayer Persistence,
            params ISniffer[] Sniffers)
            : base(false, Sniffers)
        {
            this.client = Client;
            this.server = Server;
            this.persistence = Persistence;
 
            this.client.OnDisconnected += this.Client_OnDisconnected;
            this.client.OnError += this.Client_OnError;
            this.client.OnReceived += this.Client_OnReceived;
            this.client.OnPaused += this.Client_OnPaused;
        }
 
        public bool Disposed => this.disposed;
 
        public Guid ID => this.id;
 
        public string AuthId => this.authId;
 
        public IAccount Account => this.account;
 
        public BinaryTcpClient Client => this.client;
 
        public object Tag
        {
            get => this.tag;
            set => this.tag = value;
        }
 
        public FtpServer Server => this.server;
 
        public CaseInsensitiveString UserName => this.userName;
 
        public string RemoteEndPoint => this.client.RemoteEndPoint;
 
        public bool UpgradeToTls
        {
            get => this.upgradeToTls;
            protected set => this.upgradeToTls = value;
        }
 
        public string Protocol => "FTP";
 
        internal X509Certificate ClientCertificate => this.client.RemoteCertificate;
        internal bool ClientCertificateValid => this.client.RemoteCertificateValid;
 
        [Obsolete("Use the DisposeAsync() method.")]
        public void Dispose()
        {
            this.DisposeAsync().Wait();
        }
 
        public async virtual Task DisposeAsync()
        {
            if (!this.disposed)
            {
                ISniffer[] Sniffers = this.Sniffers;
                if (!(Sniffers is null) && !(this.server is null))
                {
                    await this.RemoveRange(Sniffers, false);
                    await this.client.RemoveRange(Sniffers, false);
                }
 
                this.disposed = true;
                this.server = null;
 
                this.client?.DisposeWhenDone();
                this.client = null;
            }
        }
 
        private async Task<bool> Client_OnReceived(object Sender, bool ConstantBuffer, byte[] Buffer, int Offset, int Count)
        {
            try
            {
                return await this.ParseIncoming(ConstantBuffer, Buffer, Offset, Count);
            }
            catch (Exception ex)
            {
                if (!this.disposed)
                {
                    this.Exception(ex);
                    await this.DisposeAsync();
                }
 
                return false;
            }
        }
 
        private async Task Client_OnError(object Sender, Exception Exception)
        {
            await this.ErrorAndClose();
        }
 
        protected async virtual Task ErrorAndClose()
        {
            await this.DisposeAsync();
        }
 
        private Task Client_OnDisconnected(object Sender, EventArgs e)
        {
            return this.DisposeAsync();
        }
 
        protected abstract Task<bool> ParseIncoming(bool ConstantBuffer, byte[] Data, int Offset, int NrRead);
 
        private async Task Client_OnPaused(object Sender, EventArgs e)
        {
            if (this.upgradeToTls)
            {
                this.upgradeToTls = false;
 
                string RemoteEndPoint = this.client.RemoteEndPoint.RemovePortNumber();
 
                if (LoginAuditor.CanStartTls(RemoteEndPoint))
                {
                    try
                    {
                        object Bak = await this.BeforeUpgradeToTls();
 
                        await this.client.UpgradeToTlsAsServer(this.server.ServerCertificate, Crypto.SecureTls, ClientCertificates.Optional);
 
                        await this.AfterUpgradeToTls(Bak);
 
                        this.client.Continue();
                    }
                    catch (AuthenticationException ex)
                    {
                        await this.LoginFailure(ex, RemoteEndPoint);
                    }
                    catch (Win32Exception ex)
                    {
                        await this.LoginFailure(ex, RemoteEndPoint);
                    }
                    catch (Exception ex)
                    {
                        this.Exception(ex);
                        await this.ToError(null);
                    }
                }
                else
                    await this.ToError(null);
            }
        }
 
        protected abstract Task<object> BeforeUpgradeToTls();
 
        protected abstract Task AfterUpgradeToTls(object Item);
 
        private async Task LoginFailure(Exception ex, string RemoteIpEndpoint)
        {
            Exception ex2 = Log.UnnestException(ex);
            LoginAuditor.ReportTlsHackAttempt(RemoteIpEndpoint, "TLS handshake failed: " + ex2.Message, "FTP");
 
            await this.ToError(null);
        }
 
        private async Task ToError(string ClosingCommand)
        {
            if (string.IsNullOrEmpty(ClosingCommand))
                await this.ErrorAndClose();
            else
            {
                await this.BeginWrite(ClosingCommand, async (Sender, e) =>
                {
                    await this.ErrorAndClose();
                }, null);
            }
        }
 
        public Task<bool> BeginWrite(string Text, EventHandlerAsync<DeliveryEventArgs> Callback, object State)
        {
            if (this.disposed)
                return Task.FromResult(false);
 
            return this.client.SendAsync(true, this.encoding.GetBytes(Text), async (Sender, e) =>
            {
                this.TransmitText(Text);
 
                if (!(Callback is null))
                    await Callback.Raise(this, e);
            }, State);
        }
 
        public bool IsEncrypted => this.client.IsEncrypted;
 
        public void SetUserIdentity(CaseInsensitiveString UserName)
        {
            this.userName = UserName;
            this.authId = UserName + "@" + this.server.Domain;
        }
 
        public virtual Task SetAccount(IAccount Account)
        {
            this.account = Account;
            this.userName = Account.UserName;
 
            this.server.PersistenceLayer.AccountLogin(this.userName, this.client.RemoteEndPoint);
 
            return Task.CompletedTask;
        }
 
        public abstract Task<bool> SaslErrorNotAuthorized();
 
        public abstract Task<bool> SaslErrorAccountDisabled();
 
        public abstract Task<bool> SaslErrorMalformedRequest();
 
        public abstract Task<bool> SaslChallenge(string ChallengeBase64);
 
        public abstract Task<bool> SaslSuccess(string ProofBase64);
 
        public virtual bool CheckLive()
        {
            try
            {
                if (this.disposed)
                    return false;
 
                if (!this.client.Connected)
                    return false;
 
                // https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.connected.aspx
 
                bool BlockingBak = this.client.Client.Client.Blocking;
                try
                {
                    byte[] Temp = new byte[1];
 
                    this.client.Client.Client.Blocking = false;
                    this.client.Client.Client.Send(Temp, 0, 0);
 
                    return true;
                }
                catch (SocketException e)
                {
                    if (e.NativeErrorCode.Equals(10035))    // WSAEWOULDBLOCK
                        return true;
                    else
                        return false;
                }
                finally
                {
                    this.client.Client.Client.Blocking = BlockingBak;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }
 
        public void ResetState()
        {
            this.ResetState(!(this.account is null));
        }
 
        public virtual void ResetState(bool Authenticated)
        {
        }
 
        internal static int Next(int MaxValue)
        {
            lock (rnd)
            {
                return rnd.Next(MaxValue);
            }
        }
 
    }
}