XmppClientConnection.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.SASL;
using Waher.Networking.Sniffers;
using Waher.Persistence;
using Waher.Security.LoginMonitor;
 
namespace Waher.Networking.XMPP.Server
{
    public class XmppClientConnection : ClientConnection
    {
        private const int MaxFragmentSize = 40000000;
 
        private TextTcpClient client;
        private readonly StringBuilder fragment = new StringBuilder();
        private int fragmentLength = 0;
        private int inputState = 0;
        private int inputDepth = 0;
        private int contentStart = 0;
        private int contentEnd = 0;
        private string streamId;
        private string streamHeader;
        private string streamFooter;
        private string language;
        private double version;
        private bool openBracketReceived = false;
        private bool upgradeToTls = false;
        private string qlMechanism = null;
        private string qlChallenge = null;
        private string qlResource = null;
 
 
        public XmppClientConnection(TextTcpClient Client, XmppServer Server, params ISniffer[] Sniffers)
            : base(Server, XmppConnectionState.Offline, Sniffers)
        {
            this.client = Client;
 
            this.client.OnDisconnected += this.Client_OnDisconnected;
            this.client.OnError += this.Client_OnError;
            this.client.OnReceived += this.Client_OnReceived;
            this.client.OnPaused += this.Client_OnPaused;
            this.client.OnSent += this.Client_OnSent;
            this.client.OnInformation += this.Client_OnInformation;
            this.client.OnWarning += this.Client_OnWarning;
        }
 
        public override string Binding => "Socket";
 
        public override string RemoteEndpoint
        {
            get { return this.client?.Client?.Client?.RemoteEndPoint?.ToString(); }
        }
 
        public override string Protocol => "XMPP";
 
        internal X509Certificate ClientCertificate => this.client.RemoteCertificate;
 
        internal bool ClientCertificateValid => this.client.RemoteCertificateValid;
 
        public async override Task DisposeAsync()
        {
            try
            {
                if (!this.disposed)
                {
                    if (this.State != XmppConnectionState.Error)
                        await this.SetState(XmppConnectionState.Offline);
 
                    if (this.isBound && !(this.server is null))
                    {
                        this.isBound = false;
                        await this.ProcessFragment("<presence type=\"unavailable\"/>", 0, 0);
                        this.server?.ConnectionClosed(this);
                    }
 
                    ISniffer[] Sniffers = this.Sniffers;
                    if (!(Sniffers is null))
                        this.server?.CacheSniffers(Sniffers);
 
                    this.client?.Dispose();
                    this.client = null;
 
                    await base.DisposeAsync();
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async Task<bool> Client_OnSent(object Sender, string Text)
        {
            this.server?.DataTransmitted(this.client?.LastTransmittedBytes ?? 0);
            await this.TransmitText(Text);
            return true;
        }
 
        private async Task<string> Client_OnWarning(string Text)
        {
            await this.Warning(Text);
            return Text;
        }
 
        private async Task<string> Client_OnInformation(string Text)
        {
            await this.Information(Text);
            return Text;
        }
 
        private async Task<bool> Client_OnReceived(object Sender, string Text)
        {
            try
            {
                this.server?.DataReceived(this.client?.LastReceivedBytes ?? 0);
 
                if (this.openBracketReceived)
                {
                    this.openBracketReceived = false;
                    await this.ReceiveText("<" + Text);
                }
                else if (Text == "<")
                    this.openBracketReceived = true;
                else
                    await this.ReceiveText(Text);
 
                return await this.ParseIncoming(Text);
            }
            catch (Exception ex)
            {
                if (!this.disposed)
                    await this.Client_OnError(this, ex);
 
                return false;
            }
        }
 
        private async Task Client_OnError(object Sender, Exception Exception)
        {
            await this.SetState(XmppConnectionState.Error);
            await this.Error(Exception.Message);
            await this.DisposeAsync();
        }
 
        private async Task Client_OnDisconnected(object Sender, EventArgs e)
        {
            await this.SetState(XmppConnectionState.Offline);
            await this.DisposeAsync();
        }
 
        private async Task<bool> ParseIncoming(string s)
        {
            bool Result = true;
 
            foreach (char ch in s)
            {
                switch (this.inputState)
                {
                    case 0:     // Waiting for first <
                        if (ch == '<')
                        {
                            this.fragment.Append(ch);
                            if (++this.fragmentLength > MaxFragmentSize)
                            {
                                await this.StreamErrorResourceConstraint();
                                return false;
                            }
                            else
                                this.inputState++;
                        }
                        else if (ch > ' ')
                        {
                            await this.StreamErrorNotWellFormed();
                            return false;
                        }
                        break;
 
                    case 1:     // Waiting for ? or >
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '?')
                            this.inputState++;
                        else if (ch == '>')
                        {
                            this.inputState = 5;
                            this.inputDepth = 1;
 
                            if (!await this.ProcessStream(this.fragment.ToString()))
                                return false;
 
                            this.fragment.Clear();
                            this.fragmentLength = this.contentStart = this.contentEnd = 0;
                        }
                        break;
 
                    case 2:     // In processing instruction. Waiting for ?>
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '>')
                            this.inputState++;
                        break;
 
                    case 3:     // Waiting for <stream
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '<')
                            this.inputState++;
                        else if (ch > ' ')
                        {
                            await this.StreamErrorNotWellFormed();
                            return false;
                        }
                        break;
 
                    case 4:     // Waiting for >
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '>')
                        {
                            this.inputState++;
                            this.inputDepth = 1;
                            if (!await this.ProcessStream(this.fragment.ToString()))
                                return false;
 
                            this.fragment.Clear();
                            this.fragmentLength = this.contentStart = this.contentEnd = 0;
                        }
                        break;
 
                    case 5: // Waiting for start element.
                        if (ch == '<')
                        {
                            this.fragment.Append(ch);
                            if (++this.fragmentLength > MaxFragmentSize)
                            {
                                await this.StreamErrorResourceConstraint();
                                return false;
                            }
                            else
                                this.inputState++;
                        }
                        else if (this.inputDepth > 1)
                        {
                            this.fragment.Append(ch);
                            if (++this.fragmentLength > MaxFragmentSize)
                            {
                                await this.StreamErrorResourceConstraint();
                                return false;
                            }
                        }
                        else if (ch > ' ')
                        {
                            await this.StreamErrorNotWellFormed();
                            return false;
                        }
                        break;
 
                    case 6: // Second character in tag
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '/')
                        {
                            if (this.inputDepth == 2)
                                this.contentEnd = this.fragmentLength - 2;
 
                            this.inputState++;
                        }
                        else if (ch == '!')
                            this.inputState = 13;
                        else
                            this.inputState += 2;
                        break;
 
                    case 7: // Waiting for end of closing tag
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '>')
                        {
                            this.inputDepth--;
                            if (this.inputDepth < 1)
                            {
                                await this.DisposeAsync();
                                return false;
                            }
                            else
                            {
                                if (this.inputDepth == 1)
                                {
                                    if (!await this.ProcessFragment(this.fragment.ToString(), this.contentStart, this.contentEnd - this.contentStart))
                                        Result = false;
 
                                    this.fragment.Clear();
                                    this.fragmentLength = this.contentStart = this.contentEnd = 0;
                                }
 
                                if (this.inputState > 0)
                                    this.inputState = 5;
                            }
                        }
                        break;
 
                    case 8: // Wait for end of start tag
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '>')
                        {
                            if (this.inputDepth == 1)
                                this.contentStart = this.fragmentLength;
 
                            this.inputDepth++;
                            this.inputState = 5;
                        }
                        else if (ch == '/')
                            this.inputState++;
                        else if (ch <= ' ')
                            this.inputState += 2;
                        break;
 
                    case 9: // Check for end of childless tag.
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '>')
                        {
                            if (this.inputDepth == 1)
                            {
                                if (!await this.ProcessFragment(this.fragment.ToString(), 0, 0))
                                    Result = false;
 
                                this.fragment.Clear();
                                this.fragmentLength = this.contentStart = this.contentEnd = 0;
                            }
 
                            if (this.inputState != 0)
                                this.inputState = 5;
                        }
                        else
                            this.inputState--;
                        break;
 
                    case 10:    // Check for attributes.
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '>')
                        {
                            if (this.inputDepth == 1)
                                this.contentStart = this.fragmentLength;
 
                            this.inputDepth++;
                            this.inputState = 5;
                        }
                        else if (ch == '/')
                            this.inputState--;
                        else if (ch == '"')
                            this.inputState++;
                        else if (ch == '\'')
                            this.inputState += 2;
                        break;
 
                    case 11:    // Double quote attribute.
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '"')
                            this.inputState--;
                        break;
 
                    case 12:    // Single quote attribute.
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '\'')
                            this.inputState -= 2;
                        break;
 
                    case 13:    // Third character in start of comment
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '-')
                            this.inputState++;
                        else if (ch == '[')
                            this.inputState = 18;
                        else
                        {
                            await this.StreamErrorInvalidXml();
                            return false;
                        }
                        break;
 
                    case 14:    // Fourth character in start of comment
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '-')
                            this.inputState++;
                        else
                        {
                            await this.StreamErrorInvalidXml();
                            return false;
                        }
                        break;
 
                    case 15:    // In comment
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '-')
                            this.inputState++;
                        break;
 
                    case 16:    // Second character in end of comment
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '-')
                            this.inputState++;
                        else
                            this.inputState--;
                        break;
 
                    case 17:    // Third character in end of comment
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '>')
                            this.inputState = 5;
                        else
                            this.inputState -= 2;
                        break;
 
                    case 18:    // Fourth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == 'C')
                            this.inputState++;
                        else
                        {
                            await this.StreamErrorInvalidXml();
                            return false;
                        }
                        break;
 
                    case 19:    // Fifth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == 'D')
                            this.inputState++;
                        else
                        {
                            await this.StreamErrorInvalidXml();
                            return false;
                        }
                        break;
 
                    case 20:    // Sixth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == 'A')
                            this.inputState++;
                        else
                        {
                            await this.StreamErrorInvalidXml();
                            return false;
                        }
                        break;
 
                    case 21:    // Seventh character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == 'T')
                            this.inputState++;
                        else
                        {
                            await this.StreamErrorInvalidXml();
                            return false;
                        }
                        break;
 
                    case 22:    // Eighth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == 'A')
                            this.inputState++;
                        else
                        {
                            await this.StreamErrorInvalidXml();
                            return false;
                        }
                        break;
 
                    case 23:    // Ninth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '[')
                            this.inputState++;
                        else
                        {
                            await this.StreamErrorInvalidXml();
                            return false;
                        }
                        break;
 
                    case 24:    // In CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == ']')
                            this.inputState++;
                        break;
 
                    case 25:    // Second character in end of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == ']')
                            this.inputState++;
                        else
                            this.inputState--;
                        break;
 
                    case 26:    // Third character in end of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.StreamErrorResourceConstraint();
                            return false;
                        }
                        else if (ch == '>')
                            this.inputState = 5;
                        else if (ch != ']')
                            this.inputState -= 2;
                        break;
 
                    default:
                        break;
                }
 
            }
 
            return Result;
        }
 
        public override Task<bool> StreamError(string ErrorXml, string Reason)
        {
            return this.ToError("<stream:error>" + ErrorXml + "</stream:error>", Reason);
        }
 
        private async Task<bool> ToError(string ErrorXml, string Reason)
        {
            if (string.IsNullOrEmpty(ErrorXml))
            {
                this.inputState = -1;
 
                await this.Client_OnError(this, new Exception(Reason));
 
                return false;
            }
            else
            {
                return await this.BeginWrite(ErrorXml + this.streamFooter, async (Sender, e) =>
                {
                    this.inputState = -1;
 
                    await this.SetState(XmppConnectionState.Error);
                    await this.DisposeAsync();
                }, null);
            }
        }
 
        private async Task<bool> ProcessStream(string Xml)
        {
            StringBuilder ToSend = new StringBuilder();
 
            try
            {
                int i = Xml.IndexOf("?>");
                if (i >= 0)
                    Xml = Xml.Substring(i + 2).TrimStart();
 
                this.streamHeader = Xml;
 
                i = Xml.IndexOf(":stream");
                if (i < 0)
                    this.streamFooter = "</stream>";
                else
                    this.streamFooter = "</" + Xml.Substring(1, i - 1) + ":stream>";
 
                XmlDocument Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                Doc.LoadXml(Xml + this.streamFooter);
 
                XmlElement Stream = Doc.DocumentElement;
 
                this.bareJid = XML.Attribute(Stream, "from", this.bareJid);
                string TentativeDomain = XML.Attribute(Stream, "to");
                this.version = XML.Attribute(Stream, "version", 0.0);
                this.language = XML.Attribute(Stream, "xml:lang", "en");
 
                this.bareAddress = new XmppAddress(this.bareJid);
 
                if (string.IsNullOrEmpty(this.streamId))
                    this.streamId = this.server.GetRandomHexString(16);
 
                bool IsServerDomain = this.server.IsServerDomain(TentativeDomain, true);
 
                this.domain = IsServerDomain ? (CaseInsensitiveString)TentativeDomain : this.server.Domain;
 
                ToSend.Append("<?xml version='1.0' encoding='utf-8'?>");
                ToSend.Append("<stream:stream from='");
                ToSend.Append(XML.Encode(this.domain));
                ToSend.Append("' version='1.0' xml:lang='");
                ToSend.Append(XML.Encode(this.language));
                ToSend.Append("' id='");
                ToSend.Append(this.streamId);
                ToSend.Append("' xmlns='jabber:client' xmlns:stream='");
                ToSend.Append(StreamNamespace);
                ToSend.Append("'>");
 
                if (Doc.DocumentElement.NamespaceURI != StreamNamespace)
                {
                    await this.BeginWrite(ToSend);
                    await this.StreamErrorInvalidNamespace();
                    return false;
                }
 
                if (Doc.DocumentElement.Prefix != "stream")
                {
                    await this.BeginWrite(ToSend);
                    await this.StreamError("<bad-namespace-prefix xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", "Bad namespace prefix.");
                    return false;
                }
 
                if (Doc.DocumentElement.LocalName != "stream")
                {
                    await this.BeginWrite(ToSend);
                    await this.StreamError("<bad-format xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", "Bad format.");
                    return false;
                }
 
                if (!this.server.IsServerDomain(this.domain, true) && (!string.IsNullOrEmpty(this.server.Domain) || !IPAddress.TryParse(this.domain, out IPAddress _)))
                {
                    await this.BeginWrite(ToSend);
                    await this.StreamError("<host-unknown xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", "Domain unknown.");
                    return false;
                }
 
                if (this.version != 1.0)
                {
                    await this.BeginWrite(ToSend);
                    await this.ToError("<unsupported-version xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", "Unsupported version.");
                    return false;
                }
 
                bool IsEncrypted = this.client.IsEncrypted;
                if (!IsEncrypted)
                    await this.SetState(XmppConnectionState.StreamNegotiation);
 
                ToSend.Append("<stream:features>");
 
                this.qlMechanism = null;
                this.qlChallenge = null;
                this.qlResource = null;
 
                if (!IsEncrypted && !this.isAuthenticated && !(this.server.ServerCertificate is null))
                {
                    ToSend.Append("<ql xmlns='");
                    ToSend.Append(QuickLoginNamespace);
                    ToSend.Append("'/>");
                }
 
                if (!IsEncrypted && !(this.server.ServerCertificate is null))
                {
                    ToSend.Append("<starttls xmlns='");
                    ToSend.Append(TlsNamespace);
                    ToSend.Append('\'');
 
                    if (this.server.EncryptionRequired)
                        ToSend.Append("><required/></starttls>");
                    else
                        ToSend.Append("/>");
                }
                else if (!this.isAuthenticated)
                {
                    await this.SetState(XmppConnectionState.Authenticating);
 
                    ToSend.Append("<mechanisms xmlns='" + XmppServer.SaslNamespace + "'>");
 
                    SslStream SslStream = this.client.Stream as SslStream;
                    foreach (IAuthenticationMechanism Mechanism in XmppServer.mechanisms)
                    {
                        if (Mechanism.Allowed(SslStream))
                        {
                            ToSend.Append("<mechanism>");
                            ToSend.Append(Mechanism.Name);
                            ToSend.Append("</mechanism>");
                        }
                    }
 
                    ToSend.Append("</mechanisms>");
 
                    if (await this.server.CanRegister(this))
                        ToSend.Append("<register xmlns='http://jabber.org/features/iq-register'/>");
                }
                else if (!this.isBound)
                {
                    await this.SetState(XmppConnectionState.Binding);
 
                    ToSend.Append("<bind xmlns='");
                    ToSend.Append(BindNamespace);
                    ToSend.Append("'/>");
                    ToSend.Append("<session xmlns='urn:ietf:params:xml:ns:xmpp-session'/>");
                }
 
                ToSend.Append("</stream:features>");
                await this.BeginWrite(ToSend);
 
                return true;
            }
            catch (Exception ex)
            {
                StringBuilder Msg = new StringBuilder();
 
                Msg.Append("Incoming XMPP stream rejected: ");
                Msg.AppendLine(ex.Message);
 
                if (!string.IsNullOrEmpty(Xml))
                {
                    Xml = XML.PrettyXml(Xml);
                    if (Xml.Length > 1000)
                        Xml = Xml.Substring(0, 1000) + "...";
 
                    Msg.AppendLine();
                    Msg.AppendLine("```xml");
                    Msg.AppendLine(Xml);
                    Msg.AppendLine("```");
                }
 
                string s = Msg.ToString();
 
                Log.Warning(s, new KeyValuePair<string, object>("RemoteEP", this.RemoteEndpoint));
                
                await this.Warning(s);
 
                await this.BeginWrite(ToSend);
                await this.StreamError("<bad-format xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", "Bad format.");
                return false;
            }
        }
 
        public override Task<bool> BeginWrite(string Xml, EventHandlerAsync<DeliveryEventArgs> Callback, object State)
        {
            return this.client?.SendAsync(Xml, Callback, State) ?? Task.FromResult(false);
        }
 
        private Task<bool> BeginWrite(StringBuilder ToSend)
        {
            string Xml = ToSend.ToString();
            if (string.IsNullOrEmpty(Xml))
                return Task.FromResult(true);
 
            ToSend.Clear();
 
            return this.BeginWrite(Xml, null, null);
        }
 
        private async Task<bool> ProcessFragment(string Xml, int ContentStart, int ContentLen)
        {
            Stanza Stanza;
            XmlDocument Doc;
 
            try
            {
                if (this.disposed)
                    return false;
 
                if (!string.IsNullOrEmpty(this.fullJid))
                    this.server.TouchClientConnection(this.fullJid);
 
                Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                Doc.LoadXml(this.streamHeader + Xml + this.streamFooter);
 
                Stanza = new Stanza(Doc.DocumentElement, Xml, ContentStart, ContentLen);
 
                return await this.ProcessStanza(Stanza);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                await this.Exception(ex);
                await this.StreamError("<bad-format xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", ex.Message);
                return false;
            }
        }
 
        private async Task Client_OnPaused(object Sender, EventArgs e)
        {
            if (this.upgradeToTls)
            {
                this.upgradeToTls = false;
 
                string RemoteIpEndpoint;
                EndPoint EP = this.client.Client.Client.RemoteEndPoint;
 
                if (EP is IPEndPoint IpEP)
                    RemoteIpEndpoint = IpEP.Address.ToString();
                else
                    RemoteIpEndpoint = EP.ToString();
 
                if (LoginAuditor.CanStartTls(RemoteIpEndpoint))
                {
                    try
                    {
                        await this.SetState(XmppConnectionState.StartingEncryption);
 
                        await this.client.UpgradeToTlsAsServer(this.server.ServerCertificate, SslProtocols.Tls12, ClientCertificates.Optional);
 
                        bool QuickLogin = !string.IsNullOrEmpty(this.qlMechanism);
 
                        this.ResetState(false, !QuickLogin);
                        this.client.Continue();
 
                        if (QuickLogin)
                        {
                            DateTime? Next = await this.server.GetEarliestLoginOpportunity(this);
 
                            if (Next.HasValue)
                            {
                                StringBuilder sb = new StringBuilder();
                                DateTime TP = Next.Value;
                                DateTime Today = DateTime.Today;
 
                                if (Next.Value == DateTime.MaxValue)
                                {
                                    sb.Append("This endpoint (");
                                    sb.Append(this.RemoteEndpoint);
                                    sb.Append(") has been blocked from the system.");
                                }
                                else
                                {
                                    sb.Append("Too many failed login attempts in a row registered. Try again after ");
                                    sb.Append(TP.ToLongTimeString());
 
                                    if (TP.Date != Today)
                                    {
                                        if (TP.Date == Today.AddDays(1))
                                            sb.Append(" tomorrow");
                                        else
                                        {
                                            sb.Append(", ");
                                            sb.Append(TP.ToShortDateString());
                                        }
                                    }
 
                                    sb.Append(". Remote Endpoint: ");
                                    sb.Append(this.RemoteEndpoint);
                                }
 
                                await this.SaslErrorTemporaryAuthFailure(sb.ToString(), "en");
 
                                await this.DisposeAsync();
                                return;
                            }
 
                            bool Found = false;
 
                            foreach (IAuthenticationMechanism M in XmppServer.mechanisms)
                            {
                                if (M.Name == this.qlMechanism)
                                {
                                    if (!M.Allowed(this.GetSslStream()))
                                    {
                                        await this.SaslErrorMechanismTooWeak();
                                        await this.DisposeAsync();
                                        return;
                                    }
 
                                    this.SetMechanism(M);
                                    Found = true;
 
                                    try
                                    {
                                        bool? AuthResult = await M.AuthenticationRequest(this.qlChallenge, this, this.server.PersistenceLayer);
                                        if (AuthResult.HasValue)
                                        {
                                            if (AuthResult.Value)
                                            {
                                                await this.SaslSuccess(string.Empty);
                                                this.ResetState(true, false);
                                                return;
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        await this.Exception(ex);
                                        await this.StreamErrorInvalidXml();
                                        await this.DisposeAsync();
                                        return;
                                    }
                                    break;
                                }
                            }
 
                            if (!Found)
                            {
                                await this.SaslErrorInvalidMechanism();
                                await this.DisposeAsync();
                                return;
                            }
                        }
                    }
                    catch (AuthenticationException ex)
                    {
                        await this.LoginFailure(ex, RemoteIpEndpoint);
                    }
                    catch (Win32Exception ex)
                    {
                        await this.LoginFailure(ex, RemoteIpEndpoint);
                    }
                    catch (Exception ex)
                    {
                        await this.Exception(ex);
                        await this.DisposeAsync();
                    }
                }
                else
                    await this.DisposeAsync();
            }
        }
 
        public override async Task<bool> SaslSuccess(string ProofBase64)
        {
            if (!string.IsNullOrEmpty(this.qlMechanism))
            {
                string FullJid = null;
 
                if (!string.IsNullOrEmpty(this.qlResource))
                {
                    FullJid = this.bareJid + "/" + this.qlResource;
                    if (!await this.server.RegisterFullJid(FullJid, this))
                        FullJid = null;
                }
 
                if (FullJid is null)
                    this.fullJid = await this.server.RegisterBareJid(this.bareJid, this);
                else
                    this.fullJid = FullJid;
 
                this.address = new XmppAddress(this.fullJid);
                this.isBound = true;
 
                await this.SetState(XmppConnectionState.RequestingSession);
                this.hasSession = true;
 
                await this.SetState(XmppConnectionState.AwaitingPresence);
            }
 
            return await base.SaslSuccess(ProofBase64);
        }
 
        private async Task LoginFailure(Exception ex, string RemoteIpEndpoint)
        {
            Exception ex2 = Log.UnnestException(ex);
            await LoginAuditor.ReportTlsHackAttempt(RemoteIpEndpoint, "TLS handshake failed: " + ex2.Message, "XMPP");
 
            await this.DisposeAsync();
        }
 
        public override async Task SetUserIdentity(CaseInsensitiveString UserName)
        {
            await base.SetUserIdentity(UserName);
 
            InMemorySniffer InMemorySniffer = null;
 
            foreach (ISniffer Sniffer in this.Sniffers)
            {
                InMemorySniffer = Sniffer as InMemorySniffer;
                if (!(InMemorySniffer is null))
                    break;
            }
 
            if (!(InMemorySniffer is null))
            {
                this.Remove(InMemorySniffer);
                this.Add(this.server.GetSniffer(UserName, false));
                await InMemorySniffer.ReplayAsync(this);
            }
        }
 
        public override void ResetState(bool Authenticated)
        {
            this.ResetState(Authenticated, string.IsNullOrEmpty(this.qlMechanism));
        }
 
        public void ResetState(bool Authenticated, bool ExpectStream)
        {
            this.isAuthenticated = Authenticated;
 
            if (ExpectStream)
            {
                this.inputState = 0;
                this.inputDepth = 0;
            }
            else
            {
                this.inputState = 5;
                this.inputDepth = 1;
            }
        }
 
        public override bool CheckLive()
        {
            try
            {
                if (this.disposed || this.State == XmppConnectionState.Error || this.State == XmppConnectionState.Offline)
                    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;
            }
        }
 
        protected override SslStream GetSslStream()
        {
            return this.client.Stream as SslStream;
        }
 
        protected override async Task<bool> ProcessBindingSpecificStanza(Stanza Stanza, XmlElement StanzaElement)
        {
            switch (StanzaElement.LocalName)
            {
                case "starttls":
                    if (StanzaElement.NamespaceURI != TlsNamespace)
                    {
                        await this.StreamErrorInvalidNamespace();
                        return false;
                    }
 
                    if (this.server.ServerCertificate is null)
                    {
                        await this.StreamError("<failure xmlns='" + TlsNamespace + "'/>", "Encryption not enabled.");
                        return false;
                    }
 
                    if (await this.BeginWrite("<proceed xmlns='" + TlsNamespace + "'/>", null, null))
                        this.upgradeToTls = true;
 
                    return false;
 
                case "ql":
                    if (StanzaElement.NamespaceURI != QuickLoginNamespace)
                    {
                        await this.StreamErrorInvalidNamespace();
                        return false;
                    }
 
                    if (this.server.ServerCertificate is null)
                    {
                        await this.StreamError("<failure xmlns='" + TlsNamespace + "'/>", "Encryption not enabled.");
                        return false;
                    }
 
                    this.qlMechanism = XML.Attribute(StanzaElement, "m");
                    this.qlChallenge = XML.Attribute(StanzaElement, "c");
                    this.qlResource = XML.Attribute(StanzaElement, "r");
 
                    this.upgradeToTls = true;
                    return false;
 
                default:
                    if (!await this.StreamError("<unsupported-stanza-type xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", "Unsupported stanza: " + StanzaElement.LocalName))
                        return false;
                    break;
            }
 
            return true;
        }
 
    }
}