XmppS2SEndpoint.cs

//#define LogToWebHookTester
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Security.Authentication;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.Sniffers;
using Waher.Networking.XMPP.Server.S2S;
using Waher.Persistence;
using Waher.Runtime.Collections;
using Waher.Runtime.IO;
using Waher.Security;
using Waher.Security.LoginMonitor;
 
namespace Waher.Networking.XMPP.Server
{
    public enum S2sValidationResult
    {
        Valid,
 
        Invalid,
 
        Error
    }
 
    public class XmppS2SEndpoint : ServerConnection
    {
        private const int KeepAliveTimeSeconds = 30;
        private const int MaxFragmentSize = 40000000;
 
        private readonly Dictionary<string, bool> compressionMethods = new Dictionary<string, bool>();
        private readonly X509Certificate localDomainCertificate = null;
        private readonly string errorType = "cancel";
        private readonly string errorXml = "<remote-server-not-found xmlns='" + XmppServer.StanzaNamespace + "'/>";
        private readonly object synchObject = new object();
        private readonly string localStreamId;
        private readonly StringBuilder fragment = new StringBuilder();
        private readonly XmppServer server;
        private readonly DateTime creationTimeUtc = DateTime.UtcNow;
        private readonly int port;
        private readonly bool allowEncryption = true;
        private readonly bool incomingConnection;
        private readonly bool temporary = false;
        private DateTime connectTimeUtc = DateTime.MinValue;
        private DateTime connectedTimeUtc = DateTime.MaxValue;
        private DateTime nextPingUtc = DateTime.MinValue;
        private ChunkedList<QueuedStanza> queue;
        private CaseInsensitiveString[] remoteDomainCertificateDomains = null;
        private TextTcpClient client = null;
        private Timer secondTimer = null;
        private int fragmentLength = 0;
        private XmppS2sState state;
        private XmppS2SEndpoint authConnection = null;
        private LinkedList<Tuple<string, int, int>> stanzasOnHold = null;
        private string authKey = null;
        private string authStreamId = null;
        private string remoteStreamId;
        private CaseInsensitiveString host;
        private string streamHeader;
        private string streamFooter;
        private double version;
        private int keepAliveSeconds = KeepAliveTimeSeconds;
        private int inputState = 0;
        private int inputDepth = 0;
        private int contentStart = 0;
        private int contentEnd = 0;
        private string pingId = string.Empty;
        private bool trustServer = false;
        private bool supportsPing = true;
        private bool pingResponse = true;
        private bool checkConnection = false;
        private bool authResultRequestSent = false;
        private bool authVerifyRequestSent = false;
        private bool bidirectional = false;
        private bool openBracketReceived = false;
        private bool verified = false;
        private bool upgradeToTlsAsClient = false;
        private bool upgradeToTlsAsServer = false;
 
        internal XmppS2SEndpoint(CaseInsensitiveString LocalDomain, CaseInsensitiveString RemoteDomain,
            int Port, X509Certificate DomainCertificate, XmppServer Server, bool TrustRemoteCertificate,
            bool Temporary, QueuedStanza[] QueuedStanzas, params ISniffer[] Sniffers)
            : base(LocalDomain, RemoteDomain, Sniffers)
        {
            this.port = Port;
            this.host = RemoteDomain;
            this.state = XmppS2sState.Connecting;
            this.localDomainCertificate = DomainCertificate;
            this.server = Server;
            this.localStreamId = this.server.GetRandomHexString(16);
            this.remoteStreamId = null;
            this.trustServer = TrustRemoteCertificate;
            this.incomingConnection = false;
            this.temporary = Temporary;
 
            if ((QueuedStanzas?.Length ?? 0) > 0)
            {
                this.queue = new ChunkedList<QueuedStanza>();
                this.queue.AddRange(QueuedStanzas);
            }
        }
 
        public XmppS2SEndpoint(TextTcpClient Client, X509Certificate DomainCertificate, XmppServer Server, bool TrustRemoteCertificate,
            params ISniffer[] Sniffers)
            : base(CaseInsensitiveString.Empty, CaseInsensitiveString.Empty, Sniffers)
        {
            this.client = Client;
            this.server = Server;
            this.localStreamId = this.server.GetRandomHexString(16);
            this.remoteStreamId = null;
            this.localDomainCertificate = DomainCertificate;
            this.trustServer = TrustRemoteCertificate;
            this.incomingConnection = true;
 
            this.state = XmppS2sState.StreamNegotiation;
 
            this.ResetState();
 
            this.client.OnDisconnected += this.Client_OnDisconnected;
            this.client.OnError += this.Client_OnError;
            this.client.OnReceived += this.Client_OnReceived;
            this.client.OnSent += this.Client_OnSent;
            this.client.OnPaused += this.Client_OnPaused;
            this.client.OnInformation += this.Client_OnInformation;
            this.client.OnWarning += this.Client_OnWarning;
        }
 
        public Task<bool> Connect(bool DisposeCurrent)
        {
            return this.Connect(this.host, DisposeCurrent);
        }
 
        public override string Type => "XMPP";
 
        public string RemoteEndPoint => this.client.RemoteEndPoint;
 
        public async Task<bool> Connect(string Host, bool DisposeCurrent)
        {
            try
            {
                if (DisposeCurrent)
                    await this.DisposeClient("Making a new connection to " + Host);
 
                this.connectTimeUtc = DateTime.UtcNow;
                this.host = Host;
                this.checkConnection = true;
                await this.SetState(XmppS2sState.Connecting);
                this.pingResponse = true;
                this.upgradeToTlsAsClient = false;
                this.upgradeToTlsAsServer = false;
 
                this.client = new TextTcpClient(XmppServer.encoding, true);
 
                this.client.OnDisconnected += this.Client_OnDisconnected;
                this.client.OnError += this.Client_OnError;
                this.client.OnReceived += this.Client_OnReceived;
                this.client.OnSent += this.Client_OnSent;
                this.client.OnPaused += this.Client_OnPaused;
                this.client.OnInformation += this.Client_OnInformation;
                this.client.OnWarning += this.Client_OnWarning;
 
                if (!await this.client.ConnectAsync(this.host, this.port))
                    return false;
 
                await this.SetState(XmppS2sState.StreamNegotiation);
 
                if (!await this.BeginWrite("<?xml version='1.0' encoding='utf-8'?><stream:stream id='" + this.localStreamId + "' to='" + XML.Encode(this.remoteDomain) +
                    "' from='" + XML.Encode(this.localDomain) + "' version='1.0' xmlns='jabber:server' xmlns:db='" + DialbackNamespace +
                    "' xmlns:stream='" + XmppClientConnection.StreamNamespace + "'>", null, null))
                {
                    return false;
                }
 
                this.ResetState();
 
                return true;
            }
            catch (Exception ex)
            {
                await this.ConnectionError(ex);
                return false;
            }
        }
 
        public Task Close()
        {
            return this.DisposeClient("Closing connection.");
        }
 
        private void ResetState()
        {
            this.inputState = 0;
            this.inputDepth = 0;
 
            this.compressionMethods.Clear();
        }
 
        private async Task ConnectionError(Exception ex)
        {
            await this.OnConnectionError.Raise(this, EventArgs.Empty);
 
            this.Exception(ex);
 
            this.inputState = -1;
            await this.DisposeClient("Connection Error: " + ex.Message);
            await this.SetState(XmppS2sState.Error, ex.Message);
        }
 
        private async Task Error(Exception Exception)
        {
            Exception = Log.UnnestException(Exception);
 
            if (Exception is AggregateException ex)
            {
                foreach (Exception ex2 in ex.InnerExceptions)
                    await this.Error(ex2);
            }
            else
            {
                this.Error(Exception.Message);
 
                await this.OnError.Raise(this, EventArgs.Empty);
            }
        }
 
        public event EventHandlerAsync OnConnectionError = null;
 
        public event EventHandlerAsync OnError = null;
 
        public bool TrustServer
        {
            get => this.trustServer;
            set => this.trustServer = value;
        }
 
        public X509Certificate RemoteDomainCertificate
        {
            get => this.client?.RemoteCertificate;
        }
 
        public bool ServerCertificateValid
        {
            get => this.client?.RemoteCertificateValid ?? false;
        }
 
        public XmppS2sState State => this.state;
 
        internal Task SetState(XmppS2sState NewState)
        {
            return this.SetState(NewState, null);
        }
 
        internal async Task SetState(XmppS2sState NewState, string Reason)
        {
            if (this.state != NewState)
            {
                this.state = NewState;
 
                if (NewState == XmppS2sState.Connected)
                    this.connectedTimeUtc = DateTime.UtcNow;
 
                StringBuilder sb = new StringBuilder();
 
                sb.Append("State changed to ");
                sb.Append(NewState.ToString());
 
                if (!string.IsNullOrEmpty(Reason))
                {
                    sb.Append(" (");
                    sb.Append(Reason);
                    sb.Append(')');
                }
 
                this.Information(sb.ToString());
 
                await this.OnStateChanged.Raise(this, EventArgs.Empty);
            }
        }
 
        public bool IsStale
        {
            get
            {
                if (this.state == XmppS2sState.Connected)
                    return false;
 
                DateTime UtcNow = DateTime.UtcNow;
 
                if ((UtcNow - this.creationTimeUtc).TotalSeconds < 30)
                    return false;
 
                if (this.state == XmppS2sState.Offline || this.state == XmppS2sState.Error)
                    return true;
 
                return (UtcNow - this.connectTimeUtc).TotalSeconds > 90;
            }
        }
 
        public DateTime CreationTimeUtc => this.creationTimeUtc;
 
        public DateTime ConnectTimeUtc => this.connectTimeUtc;
 
        public DateTime ConnectedTimeUtc => this.connectedTimeUtc;
 
        public event EventHandlerAsync OnStateChanged = null;
 
        internal QueuedStanza[] GetAndClearQueuedStanzas()
        {
            lock (this.synchObject)
            {
                if (this.queue is null)
                    return null;
 
                QueuedStanza[] Result = this.queue.ToArray();
 
                this.queue.Clear();
                this.queue = null;
 
                return Result;
            }
        }
 
        public override async Task DisposeAsync(string Reason)
        {
            this.checkConnection = false;
 
            this.secondTimer?.Dispose();
            this.secondTimer = null;
 
            if (this.state == XmppS2sState.Connected ||
                this.state == XmppS2sState.StreamOpened ||
                this.state == XmppS2sState.StartingEncryptionAsClient ||
                this.state == XmppS2sState.StartingEncryptionAsServer ||
                this.state == XmppS2sState.Verifying ||
                this.state == XmppS2sState.Dialback)
            {
                try
                {
                    await this.BeginWrite(this.streamFooter, async (Sender, e) =>
                    {
                        await this.CleanUp(this, XmppS2sState.Offline, Reason);
                    }, null);
                }
                catch (Exception ex)
                {
                    await this.CleanUp(this, XmppS2sState.Offline, ex.Message);
                }
            }
            else
                await this.CleanUp(this, EventArgs.Empty);
        }
 
        public Task HardOffline()
        {
            return this.CleanUp(this, XmppS2sState.Offline, "Goind hard-offline.");
        }
 
        private Task CleanUp(object Sender, EventArgs e)
        {
            return this.CleanUp(Sender, XmppS2sState.Offline, "Closing connection.");
        }
 
        private async Task CleanUp(object _, XmppS2sState State, string Reason)
        {
            await this.SetState(State, Reason);
 
            this.compressionMethods?.Clear();
 
            this.secondTimer?.Dispose();
            this.secondTimer = null;
 
            if (string.IsNullOrEmpty(Reason))
                await this.DisposeClient("Cleaning up connection.");
            else
                await this.DisposeClient("Cleaning up connection: " + Reason);
        }
 
        private async Task DisposeClient(string Reason)
        {
            TextTcpClient c = this.client;
            this.client = null;
 
            if (!(this.authConnection is null))
            {
                try
                {
                    if (string.IsNullOrEmpty(Reason))
                        this.authConnection.KeyAuthenticated(S2sValidationResult.Error, "Disposing connection client.");
                    else
                        this.authConnection.KeyAuthenticated(S2sValidationResult.Error, "Disposing connection client: " + Reason);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
 
                this.authConnection = null;
            }
 
            c?.DisposeWhenDone();
 
            if (!string.IsNullOrEmpty(this.server.DomainSnifferPath))
                await this.server.CacheSniffers(this.Sniffers);
 
            await this.OnDisposed.Raise(this, EventArgs.Empty, false);
            this.OnDisposed = null;
 
            this.server.S2sEndpointDisposed(this);
        }
 
        public event EventHandlerAsync OnDisposed = null;
 
        private Task<bool> BeginWrite(string Xml, EventHandlerAsync<DeliveryEventArgs> Callback, object State)
        {
            this.nextPingUtc = DateTime.UtcNow.AddMilliseconds(this.keepAliveSeconds * 500);
            return this.client?.SendAsync(Xml, Callback, State) ?? Task.FromResult(false);
        }
 
        private Task<bool> Client_OnSent(object Sender, string Text)
        {
            this.server?.DataTransmitted(this.client?.LastTransmittedBytes ?? 0);
            this.TransmitText(Text);
            return Task.FromResult(true);
        }
 
        private string Client_OnWarning(string Text)
        {
            this.Warning(Text);
            return Text;
        }
 
        private string Client_OnInformation(string Text)
        {
            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;
                    this.ReceiveText("<" + Text);
                }
                else if (Text == "<")
                    this.openBracketReceived = true;
                else
                    this.ReceiveText(Text);
 
                return await this.ParseIncoming(Text);
            }
            catch (Exception ex)
            {
                this.Exception(ex);
                await this.DisposeAsync(ex.Message);
 
                return false;
            }
        }
 
        private async Task Client_OnError(object Sender, Exception Exception)
        {
            await this.SetState(XmppS2sState.Error);
            this.Error(Exception.Message);
            await this.DisposeAsync(Exception.Message);
        }
 
        private async Task Client_OnDisconnected(object Sender, EventArgs e)
        {
            await this.SetState(XmppS2sState.Offline);
            await this.DisposeAsync("Client was disconnected.");
        }
 
        private const string FragmentTooBig = "Fragment too big.";
        private const string IllegalCharacterReceived = "Illegal character received.";
 
        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.ToError(FragmentTooBig);
                                return false;
                            }
                            else
                                this.inputState++;
                        }
                        else if (ch > ' ')
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 1:     // Waiting for ? or >
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '?')
                            this.inputState++;
                        else if (ch == '>')
                        {
                            this.inputState = 5;
                            this.inputDepth = 1;
                            if (!await this.ProcessStream(this.fragment.ToString()))
                                Result = false;
                            this.fragment.Clear();
                            this.fragmentLength = this.contentStart = this.contentEnd = 0;
                        }
                        break;
 
                    case 2:     // In processing instruction. Waiting for ?>
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '>')
                        {
                            this.fragment.Clear();
                            this.inputState++;
                        }
                        break;
 
                    case 3:     // Waiting for <stream
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '<')
                            this.inputState++;
                        else if (ch > ' ')
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 4:     // Waiting for >
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '>')
                        {
                            this.inputState++;
                            this.inputDepth = 1;
                            if (!await this.ProcessStream(this.fragment.ToString()))
                                Result = 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.ToError(FragmentTooBig);
                                return false;
                            }
                            else
                                this.inputState++;
                        }
                        else if (this.inputDepth > 1)
                        {
                            this.fragment.Append(ch);
                            if (++this.fragmentLength > MaxFragmentSize)
                            {
                                await this.ToError(FragmentTooBig);
                                return false;
                            }
                        }
                        else if (ch > ' ')
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 6: // Second character in tag
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '/')
                        {
                            if (this.inputDepth == 2)
                                this.contentEnd = this.fragmentLength - 2;
 
                            this.inputState++;
                        }
                        else if (ch == '?') // Unexpected processing instruction. Treat as if sender reinitiates connection on a reused connection without a graceful shutdown.
                        {
                            if (this.State != XmppS2sState.Connected && this.State != XmppS2sState.Verifying && this.State != XmppS2sState.Dialback)
                            {
                                this.Warning("Processing instruction received. Assuming connection reused. Resetting state.");
                                await this.SetState(XmppS2sState.StreamNegotiation);
                            }
 
                            this.inputState = 2;
                            this.inputDepth = 0;
                        }
                        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.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '>')
                        {
                            this.inputDepth--;
                            if (this.inputDepth < 1)
                            {
                                this.inputState = -1;
                                await this.CleanUp(this, XmppS2sState.Offline, "Closing tag.");
                                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.ToError(FragmentTooBig);
                            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.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '>')
                        {
                            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;
                        }
                        else
                            this.inputState--;
                        break;
 
                    case 10:    // Check for attributes.
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            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.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '"')
                            this.inputState--;
                        break;
 
                    case 12:    // Single quote attribute.
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            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.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '-')
                            this.inputState++;
                        else if (ch == '[')
                            this.inputState = 18;
                        else
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 14:    // Fourth character in start of comment
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '-')
                            this.inputState++;
                        else
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 15:    // In comment
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            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.ToError(FragmentTooBig);
                            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.ToError(FragmentTooBig);
                            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.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == 'C')
                            this.inputState++;
                        else
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 19:    // Fifth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == 'D')
                            this.inputState++;
                        else
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 20:    // Sixth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == 'A')
                            this.inputState++;
                        else
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 21:    // Seventh character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == 'T')
                            this.inputState++;
                        else
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 22:    // Eighth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == 'A')
                            this.inputState++;
                        else
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 23:    // Ninth character in start of CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '[')
                            this.inputState++;
                        else
                        {
                            await this.ToError(IllegalCharacterReceived);
                            return false;
                        }
                        break;
 
                    case 24:    // In CDATA
                        this.fragment.Append(ch);
                        if (++this.fragmentLength > MaxFragmentSize)
                        {
                            await this.ToError(FragmentTooBig);
                            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.ToError(FragmentTooBig);
                            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.ToError(FragmentTooBig);
                            return false;
                        }
                        else if (ch == '>')
                            this.inputState = 5;
                        else if (ch != ']')
                            this.inputState -= 2;
                        break;
 
                    default:
                        break;
                }
            }
 
            return Result;
        }
 
        private Task ToError(string Reason)
        {
            this.inputState = -1;
            return this.CleanUp(this, XmppS2sState.Error, Reason);
        }
 
        private async Task<bool> ProcessStream(string Xml)
        {
            try
            {
                this.streamHeader = Xml;
 
                if (Xml.StartsWith("</"))
                {
                    await this.ConnectionError(new Exception("Connection closed by the remote endpoint."));
                    return false;
                }
 
                int i = Xml.IndexOf(":stream");
                if (i < 0)
                    this.streamFooter = "</stream>";
                else
                    this.streamFooter = "</" + Xml[1..i] + ":stream>";
 
                XmlDocument Doc = XML.ParseXml(Xml + this.streamFooter, true);
 
                if (Doc.DocumentElement.LocalName != "stream")
                    throw new Exception("Invalid stream.");
 
                XmlElement Stream = Doc.DocumentElement;
 
                this.version = XML.Attribute(Stream, "version", 0.0);
                if (this.version < 1.0)
                    throw new Exception("Version not supported.");
 
                this.remoteStreamId = XML.Attribute(Stream, "id");
 
                if (this.incomingConnection)
                {
                    this.remoteDomain = XML.Attribute(Stream, "from");
 
                    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.server.AddS2SSniffers(this, this.remoteDomain);
                        InMemorySniffer.Replay(this);
                    }
 
                    string To = XML.Attribute(Stream, "to");
                    if (!this.server.IsServerDomain(To, true))
                    {
                        if (string.IsNullOrEmpty(To))
                            throw new Exception("No to attribute in S2S connection stream. From: " + XML.Attribute(Stream, "from"));
                        else
                            throw new Exception("Unexpected domain: " + To);
                    }
 
                    if (string.IsNullOrEmpty(this.localDomain))
                        this.localDomain = To;
 
                    this.trustServer = XmppServer.TrustCertificate(this.remoteDomain);
                }
                else if (this.state == XmppS2sState.Connected)
                {
                    string From = XML.Attribute(Stream, "from");
                    if (this.remoteDomain != From)
                        throw new Exception("Unexpected domain: " + From + ". Expected: " + this.remoteDomain);
                }
 
                if (this.state == XmppS2sState.Connected ||
                    this.state == XmppS2sState.Verifying ||
                    this.state == XmppS2sState.Dialback)
                {
                    if (this.incomingConnection)
                    {
                        StringBuilder sb = new StringBuilder();
 
                        sb.Append("<?xml version='1.0' encoding='utf-8'?><stream:stream id='");
                        sb.Append(this.localStreamId);
                        sb.Append("' to='");
                        sb.Append(XML.Encode(this.remoteDomain));
                        sb.Append("' from='");
                        sb.Append(XML.Encode(this.localDomain));
                        sb.Append("' version='1.0' xmlns='jabber:server' xmlns:db='");
                        sb.Append(DialbackNamespace);
                        sb.Append("' xmlns:stream='");
                        sb.Append(XmppClientConnection.StreamNamespace);
                        sb.Append("'><stream:features><dialback xmlns='");
                        sb.Append(DialbackFeaturesNamespace);
                        sb.Append("'/></stream:features>");
 
                        if (!await this.BeginWrite(sb.ToString(), null, null))
                            return false;
                    }
 
                    if (this.verified)
                    {
                        if (!await this.SendQueued())
                            return false;
                    }
 
                    return true;
                }
 
                if (this.incomingConnection)
                {
                    StringBuilder sb = new StringBuilder();
 
                    sb.Append("<?xml version='1.0' encoding='utf-8'?><stream:stream id='");
                    sb.Append(this.localStreamId);
                    sb.Append("' to='");
                    sb.Append(XML.Encode(this.remoteDomain));
                    sb.Append("' from='");
                    sb.Append(XML.Encode(this.localDomain));
                    sb.Append("' version='1.0' xmlns='jabber:server' xmlns:db='");
                    sb.Append(DialbackNamespace);
                    sb.Append("' xmlns:stream='");
                    sb.Append(XmppClientConnection.StreamNamespace);
                    sb.Append("'><stream:features>");
 
                    if (this.client.IsEncrypted)
                    {
                        if (this.client.RemoteCertificateValid)
                        {
                            if (!(this.remoteDomainCertificateDomains is null) &&
                                Array.IndexOf(this.remoteDomainCertificateDomains, this.remoteDomain) >= 0)
                            {
                                sb.Append("<mechanisms xmlns='");
                                sb.Append(XmppServer.SaslNamespace);
                                sb.Append("'><mechanism>EXTERNAL</mechanism></mechanisms>");
                            }
                        }
 
                        sb.Append("<dialback xmlns='");
                        sb.Append(DialbackFeaturesNamespace);
                        sb.Append("'><errors/></dialback>");
                    }
                    else
                    {
                        sb.Append("<starttls xmlns='");
                        sb.Append(XmppClientConnection.TlsNamespace);
                        sb.Append("'><required/></starttls>");
                    }
 
                    sb.Append("<bidi xmlns='");
                    sb.Append(BidirectionalFeatureNamespaces);
                    sb.Append("'/></stream:features>");
 
                    if (!await this.BeginWrite(sb.ToString(), null, null))
                        return false;
                }
 
                await this.SetState(XmppS2sState.StreamOpened);
            }
            catch (Exception ex)
            {
                await this.ConnectionError(ex);
            }
 
            return true;
        }
 
        private async Task<bool> SendQueued()
        {
            QueuedStanza Stanza;
            Tuple<string, int, int> OnHold;
            bool First = true;
 
            do
            {
                lock (this.synchObject)
                {
                    if (this.queue is null || !this.queue.HasFirstItem)
                    {
                        this.queue = null;
                        break;
                    }
 
                    Stanza = this.queue.RemoveFirst();
                    if (!this.queue.HasFirstItem)
                        this.queue = null;
                }
 
                if (First)
                {
                    First = false;
                    this.Information("Sending queued stanzas.");
                }
 
                if (!await this.BeginWrite(Stanza.StanzaType, Stanza.Type, Stanza.Id, Stanza.To, Stanza.From, Stanza.Language, Stanza.ContentXml))
                {
                    lock (this.synchObject)
                    {
                        this.queue ??= new ChunkedList<QueuedStanza>();
                        this.queue.Add(Stanza);
                    }
 
                    return false;
                }
            }
            while (!(Stanza is null));
 
            First = true;
 
            do
            {
                lock (this.synchObject)
                {
                    if (this.stanzasOnHold is null || this.stanzasOnHold.First is null)
                    {
                        this.stanzasOnHold = null;
                        break;
                    }
 
                    OnHold = this.stanzasOnHold.First.Value;
                    this.stanzasOnHold.RemoveFirst();
                    if (this.stanzasOnHold.First is null)
                        this.stanzasOnHold = null;
                }
 
                if (First)
                {
                    First = false;
                    this.Information("Processing incoming stanzas put on hold.");
                }
 
                this.Information(OnHold.Item1.Substring(OnHold.Item2, OnHold.Item3));
 
                if (!await this.ProcessFragment(OnHold.Item1, OnHold.Item2, OnHold.Item3))
                {
                    lock (this.synchObject)
                    {
                        this.stanzasOnHold ??= new LinkedList<Tuple<string, int, int>>();
                        this.stanzasOnHold.AddFirst(OnHold);
                    }
 
                    return false;
                }
            }
            while (!(OnHold is null));
 
            return true;
        }
 
        private async Task<bool> ProcessFragment(string Xml, int ContentStart, int ContentLen)
        {
            Stanza Stanza;
            XmlDocument Doc;
            XmlElement E;
            StringBuilder sb;
 
            try
            {
                this.server.TouchServerConnection(this.remoteDomain);
 
                Doc = XML.ParseXml(this.streamHeader + Xml + this.streamFooter, true);
 
                Stanza = new Stanza(Doc.DocumentElement, Xml, ContentStart, ContentLen);
                E = Stanza.StanzaElement;
                if (E is null)
                    return true;
 
                switch (E.LocalName)
                {
                    case "iq":
                        if (this.state != XmppS2sState.Connected)
                        {
                            if (this.state == XmppS2sState.Dialback || this.state == XmppS2sState.Verifying)
                            {
                                lock (this.synchObject)
                                {
                                    this.stanzasOnHold ??= new LinkedList<Tuple<string, int, int>>();
                                    this.stanzasOnHold.AddLast(new Tuple<string, int, int>(Xml, ContentStart, ContentLen));
                                }
 
                                this.Warning("Keeping stanza on hold while performing verification.");
                            }
 
                            break;
                        }
 
                        string Type = XML.Attribute(E, "type");
                        string Id = XML.Attribute(E, "id");
                        XmppAddress To = new XmppAddress(XML.Attribute(E, "to"));
                        XmppAddress From = new XmppAddress(XML.Attribute(E, "from"));
                        string Language = XML.Attribute(E, "xml:lang");
 
                        this.server.IncCounters("iq", Type, From, To, E);
 
                        if (!await this.CheckFrom(From))
                            return true;
 
                        if (To.Address == this.localDomain && From.Address == this.remoteDomain && (Type == "result" || Type == "error") && Id == this.pingId)
                        {
                            this.pingResponse = true;
 
                            if (Type == "error")
                                this.supportsPing = false;
 
                            break;
                        }
 
                        this.ProcessIq(Id, To, From, Type, Language, Stanza);
                        break;
 
                    case "message":
                        if (this.state != XmppS2sState.Connected)
                        {
                            if (this.state == XmppS2sState.Dialback || this.state == XmppS2sState.Verifying)
                            {
                                lock (this.synchObject)
                                {
                                    this.stanzasOnHold ??= new LinkedList<Tuple<string, int, int>>();
                                    this.stanzasOnHold.AddLast(new Tuple<string, int, int>(Xml, ContentStart, ContentLen));
                                }
 
                                this.Warning("Keeping stanza on hold while performing verification");
                            }
 
                            break;
                        }
 
                        Type = XML.Attribute(E, "type");
                        Id = XML.Attribute(E, "id");
                        To = new XmppAddress(XML.Attribute(E, "to"));
                        From = new XmppAddress(XML.Attribute(E, "from"));
                        Language = XML.Attribute(E, "xml:lang");
 
                        this.server.IncCounters("message", Type, From, To, E);
 
                        if (!await this.CheckFrom(From))
                            return true;
 
                        this.ProcessMessage(Type, Id, To, From, Language, Stanza);
                        break;
 
                    case "presence":
                        if (this.state != XmppS2sState.Connected)
                        {
                            if (this.state == XmppS2sState.Dialback || this.state == XmppS2sState.Verifying)
                            {
                                lock (this.synchObject)
                                {
                                    this.stanzasOnHold ??= new LinkedList<Tuple<string, int, int>>();
                                    this.stanzasOnHold.AddLast(new Tuple<string, int, int>(Xml, ContentStart, ContentLen));
                                }
 
                                this.Warning("Keeping stanza on hold while performing verification");
                            }
 
                            break;
                        }
 
                        Type = XML.Attribute(E, "type");
                        Id = XML.Attribute(E, "id");
                        To = new XmppAddress(XML.Attribute(E, "to"));
                        From = new XmppAddress(XML.Attribute(E, "from"));
                        Language = XML.Attribute(E, "xml:lang");
 
                        this.server.IncCounters("presence", Type, From, To, E);
 
                        if (!await this.CheckFrom(From))
                            return true;
 
                        this.ProcessPresence(Type, Id, To, From, Language, Stanza);
                        break;
 
                    case "features":
                        if (E.FirstChild is null)
                            this.DialbackCompleted(false, false, "No features available.");
                        else
                        {
                            bool StartTls = false;
                            bool Dialback = false;
                            bool Bidirectional = false;
                            bool ExternalAuth = false;
 
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                switch (N2.LocalName)
                                {
                                    case "starttls":
                                        StartTls = true;
                                        break;
 
                                    case "compression":
                                        foreach (XmlNode N3 in N2.ChildNodes)
                                        {
                                            if (N3.LocalName == "method")
                                                this.compressionMethods[N3.InnerText.Trim().ToUpper()] = true;
                                        }
                                        break;
 
                                    case "bidi":
                                        Bidirectional = true;
                                        break;
 
                                    case "dialback":
                                        Dialback = true;
                                        break;
 
                                    case "mechanisms":
                                        foreach (XmlNode N3 in N2.ChildNodes)
                                        {
                                            if (N3.LocalName == "mechanism")
                                            {
                                                switch (N3.InnerText)
                                                {
                                                    case "EXTERNAL":
                                                        ExternalAuth = true;
                                                        break;
                                                }
                                            }
                                        }
                                        break;
 
                                    default:
                                        break;
                                }
                            }
 
                            if (StartTls && this.allowEncryption)
                                return await this.BeginWrite("<starttls xmlns='" + XmppClientConnection.TlsNamespace + "'/>", null, null);
                            else if (ExternalAuth)
                            {
                                sb = new StringBuilder();
 
                                if (Bidirectional)
                                {
                                    sb.Append("<bidi xmlns='");
                                    sb.Append(BidirectionalNamespace);
                                    sb.Append("'/>");
                                }
 
                                sb.Append("<auth xmlns='");
                                sb.Append(XmppServer.SaslNamespace);
                                sb.Append("' mechanism='EXTERNAL'>");
                                sb.Append(Convert.ToBase64String(Encoding.UTF8.GetBytes(this.localDomain)));
                                sb.Append("</auth>");
 
                                return await this.BeginWrite(sb.ToString(), null, null);
                            }
                            else if (Dialback && !this.verified)
                            {
                                await this.SetState(XmppS2sState.Verifying);
 
                                sb = new StringBuilder();
 
                                if (!string.IsNullOrEmpty(this.authKey))
                                {
                                    sb.Append("<db:verify from='");
                                    sb.Append(XML.Encode(this.localDomain));
                                    sb.Append("' to='");
                                    sb.Append(XML.Encode(this.remoteDomain));
                                    sb.Append("' id='");
                                    sb.Append(XML.Encode(this.authStreamId));
                                    sb.Append("'>");
                                    sb.Append(XML.Encode(this.authKey));
                                    sb.Append("</db:verify>");
#if LogToWebHookTester
                                    _ = Task.Run(async () =>
                                    {
                                        try
                                        {
                                            await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.localDomain.Value),
                                                new Dictionary<string, object>()
                                                {
                                                    { "id", this.Id.ToString() },
                                                    { "event", "Requesting verification" },
                                                    { "local", this.localDomain.Value },
                                                    { "remote", this.remoteDomain.Value },
                                                    { "key", this.authKey },
                                                    { "authStreamId", this.authStreamId },
                                                    { "xml", sb.ToString() }
                                                },
                                                new KeyValuePair<string, string>("Accept", "application/json"));
                                        }
                                        catch (Exception ex)
                                        {
                                            Log.Exception(ex);
                                        }
                                    });
#endif
                                    this.authVerifyRequestSent = true;
                                }
                                else
                                {
                                    this.authKey = this.server.GetDialbackKey(this.remoteDomain, this.localDomain, this.remoteStreamId);
                                    this.authResultRequestSent = true;
 
                                    if (Bidirectional)
                                    {
                                        sb.Append("<bidi xmlns='");
                                        sb.Append(BidirectionalNamespace);
                                        sb.Append("'/>");
                                    }
 
                                    sb.Append("<db:result from='");
                                    sb.Append(XML.Encode(this.localDomain));
                                    sb.Append("' to='");
                                    sb.Append(XML.Encode(this.remoteDomain));
                                    sb.Append("'>");
                                    sb.Append(this.authKey);
                                    sb.Append("</db:result>");
 
#if LogToWebHookTester
                                    // TODO: Remove
                                    _ = Task.Run(async () =>
                                    {
                                        try
                                        {
                                            await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.localDomain.Value),
                                                new Dictionary<string, object>()
                                                {
                                                    { "id", this.Id.ToString() },
                                                    { "event", "Verification result" },
                                                    { "local", this.localDomain.Value },
                                                    { "remote", this.remoteDomain.Value },
                                                    { "key", this.authKey },
                                                    { "bidirectional", Bidirectional },
                                                    { "xml", sb.ToString() }
                                                },
                                                new KeyValuePair<string, string>("Accept", "application/json"));
                                        }
                                        catch (Exception ex)
                                        {
                                            Log.Exception(ex);
                                        }
                                    });
#endif
                                }
 
                                return await this.BeginWrite(sb.ToString(), null, null);
                            }
                        }
                        break;
 
                    case "proceed":
                        this.upgradeToTlsAsClient = true;
                        return false;
 
                    case "starttls":
                        if (await this.BeginWrite("<proceed xmlns='" + XmppClientConnection.TlsNamespace + "'/>", null, null))
                            this.upgradeToTlsAsServer = true;
                        return false;
 
                    case "bidi":
                        if (E.NamespaceURI == BidirectionalNamespace)
                            this.bidirectional = true;
                        break;
 
                    case "success":
                        sb = new StringBuilder();
 
                        sb.Append("<?xml version='1.0' encoding='utf-8'?><stream:stream id='");
                        sb.Append(this.localStreamId);
                        sb.Append("' to='");
                        sb.Append(XML.Encode(this.remoteDomain));
                        sb.Append("' from='");
                        sb.Append(XML.Encode(this.localDomain));
                        sb.Append("' version='1.0' xmlns='jabber:server' xmlns:db='");
                        sb.Append(DialbackNamespace);
                        sb.Append("' xmlns:stream='");
                        sb.Append(XmppClientConnection.StreamNamespace);
                        sb.Append("'>");
 
                        if (!await this.BeginWrite(sb.ToString(), null, null))
                            return false;
 
                        this.verified = true;
                        this.DialbackCompleted(true, false, null);
                        break;
 
                    case "failure":
                        this.DialbackCompleted(false, false, "Authentication failed.");
                        break;
 
                    case "auth":
                        if (E.NamespaceURI == XmppServer.SaslNamespace && XML.Attribute(E, "mechanism") == "EXTERNAL")
                        {
                            string s = E.InnerText;
                            CaseInsensitiveString Domain;
 
                            if (s == "=")
                                Domain = this.remoteDomain;
                            else
                            {
                                byte[] Bin = Convert.FromBase64String(s);
                                Domain = Encoding.UTF8.GetString(Bin);
                            }
 
                            bool RemoteCertificateValid = this.client.RemoteCertificateValid;
                            bool ValidDomain = (string.IsNullOrEmpty(Domain) || Domain == this.remoteDomain);
                            bool RemoteDomainsInCertificate = !(this.remoteDomainCertificateDomains is null);
                            bool DomainInCertificate = Array.IndexOf(this.remoteDomainCertificateDomains, this.remoteDomain) >= 0;
 
                            if (RemoteCertificateValid && 
                                ValidDomain && 
                                RemoteDomainsInCertificate && 
                                DomainInCertificate)
                            {
                                if (!await this.BeginWrite("<success xmlns='" + XmppServer.SaslNamespace + "'/>", null, null))
                                    return false;
 
                                this.verified = true;
                                this.DialbackCompleted(true, false, null);
                            }
                            else
                            {
                                if (!await this.BeginWrite("<failure xmlns='" + XmppServer.SaslNamespace + "'><not-authorized/></failure>", null, null))
                                    return false;
 
                                if (!RemoteCertificateValid)
                                    this.DialbackCompleted(false, false, "Remote certificate is not valid.");
                                else if (!ValidDomain)
                                    this.DialbackCompleted(false, false, "Presented domain not valid.");
                                else if (!RemoteDomainsInCertificate)
                                    this.DialbackCompleted(false, false, "Remote domains not available in certificate.");
                                else if (!DomainInCertificate)
                                    this.DialbackCompleted(false, false, "Presented domain not in certificate.");
                                else
                                    this.DialbackCompleted(false, false, "Something went wrong.");
                            }
                        }
                        break;
 
                    case "result":
                        if (E.NamespaceURI == DialbackNamespace)
                        {
                            Type = XML.Attribute(E, "type");
                            if (string.IsNullOrEmpty(Type))
                            {
#if LogToWebHookTester
                                // TODO: Remove
                                _ = Task.Run(async () =>
                                {
                                    try
                                    {
                                        await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.localDomain.Value),
                                            new Dictionary<string, object>()
                                            {
                                                { "id", this.Id.ToString() },
                                                { "event", "Verification result received" },
                                                { "local", this.localDomain.Value },
                                                { "remote", this.remoteDomain.Value },
                                                { "key", this.authKey },
                                                { "verified", this.verified }
                                            },
                                            new KeyValuePair<string, string>("Accept", "application/json"));
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.Exception(ex);
                                    }
                                });
#endif
                                if (this.verified)
                                {
                                    sb = new StringBuilder();
 
                                    sb.Append("<db:result to='");
                                    sb.Append(XML.Encode(this.remoteDomain));
                                    sb.Append("' from='");
                                    sb.Append(XML.Encode(this.localDomain));
                                    sb.Append("' valid='true'/>");
                                }
                                else
                                {
                                    this.Information("Performing dialback to validate domain name claim.");
                                    await this.SetState(XmppS2sState.Dialback);
 
                                    try
                                    {
#if LogToWebHookTester
                                        // TODO: Remove
                                        _ = Task.Run(async () =>
                                        {
                                            try
                                            {
                                                await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.localDomain.Value),
                                                    new Dictionary<string, object>()
                                                    {
                                                        { "id", this.Id.ToString() },
                                                        { "event", "Performing dialback" },
                                                        { "local", this.localDomain.Value },
                                                        { "remote", this.remoteDomain.Value },
                                                        { "key", E.InnerText },
                                                        { "authStreamId", this.localStreamId }
                                                    },
                                                    new KeyValuePair<string, string>("Accept", "application/json"));
                                            }
                                            catch (Exception ex)
                                            {
                                                Log.Exception(ex);
                                            }
                                        });
#endif
                                        IS2SEndpoint AuthEndpoint = await this.server.GetS2sEndpoint(this.localDomain, this.remoteDomain,
                                        false, "Performing dialback to validate domain name claim.");
 
                                        if (AuthEndpoint is XmppS2SEndpoint XmppS2SEndpoint)
                                        {
                                            XmppS2SEndpoint.authKey = E.InnerText;
                                            XmppS2SEndpoint.authStreamId = this.localStreamId;
                                            XmppS2SEndpoint.authConnection = this;
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.Exception(ex);
 
                                        sb = new StringBuilder();
 
                                        XmppServer.GetErrorInformation(ex, out string ErrorType, out string ErrorXml);
 
#if LogToWebHookTester
                                        // TODO: Remove
                                        _ = Task.Run(async () =>
                                        {
                                            try
                                            {
                                                await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.localDomain.Value),
                                                    new Dictionary<string, object>()
                                                    {
                                                        { "id", this.Id.ToString() },
                                                        { "event", "Verification error" },
                                                        { "local", this.localDomain.Value },
                                                        { "remote", this.remoteDomain.Value },
                                                        { "key", this.authKey },
                                                        { "errorType", ErrorType },
                                                        { "errorXml", ErrorXml },
                                                        { "exceptionMessage", ex.Message }
                                                    },
                                                    new KeyValuePair<string, string>("Accept", "application/json"));
                                            }
                                            catch (Exception ex2)
                                            {
                                                Log.Exception(ex2);
                                            }
                                        });
#endif
                                        sb.Append("<db:result to='");
                                        sb.Append(XML.Encode(this.remoteDomain));
                                        sb.Append("' from='");
                                        sb.Append(XML.Encode(this.localDomain));
                                        sb.Append("' type='error'><error type='");
                                        sb.Append(ErrorType);
                                        sb.Append("'>");
                                        sb.Append(ErrorXml);
                                        sb.Append("<text xmlns='");
                                        sb.Append(XmppServer.StanzaNamespace);
                                        sb.Append("'>");
                                        sb.Append(XML.Encode(ex.Message));
                                        sb.Append("</text></error></db:result>");
 
                                        if (!await this.BeginWrite(sb.ToString(), null, null))
                                            return false;
                                    }
                                }
                            }
                            else if (this.authResultRequestSent)
                            {
                                XmppS2SEndpoint Endpoint = this.authConnection ?? this;
 
                                if (Type == "valid")
                                {
                                    Endpoint.verified = true;
                                    Endpoint.DialbackCompleted(true, true, null);
                                }
                                else
                                    Endpoint.DialbackCompleted(false, true, "Remote end rejects authentication result.");
 
                                if (!(this.authConnection is null))
                                {
                                    this.authConnection = null;
                                    await this.CleanUp(this, XmppS2sState.Offline, "Dialback check completed.");
                                }
                            }
                        }
                        break;
 
                    case "verify":
                        if (E.NamespaceURI == DialbackNamespace)
                        {
                            From = new XmppAddress(XML.Attribute(E, "from"));
                            To = new XmppAddress(XML.Attribute(E, "to"));
                            Id = XML.Attribute(E, "id");
                            Type = XML.Attribute(E, "type");
 
                            if (string.IsNullOrEmpty(Type))
                            {
                                string Key = this.server.GetDialbackKey(From.Address, To.Address, Id);
                                sb = new StringBuilder();
 
                                this.verified = Key == E.InnerText;
 
                                sb.Append("<db:verify to='");
                                sb.Append(XML.Encode(From.Address));
                                sb.Append("' from='");
                                sb.Append(XML.Encode(To.Address));
                                sb.Append("' id='");
                                sb.Append(XML.Encode(Id));
                                sb.Append("' type='");
                                sb.Append(this.verified ? "valid" : "invalid");
                                sb.Append("'/>");
 
#if LogToWebHookTester
                                // TODO: Remove
                                _ = Task.Run(async () =>
                                {
                                    try
                                    {
                                        await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.localDomain.Value),
                                            new Dictionary<string, object>()
                                            {
                                                { "id", this.Id.ToString() },
                                                { "event", "verify stanza" },
                                                { "local", this.localDomain.Value },
                                                { "remote", this.remoteDomain.Value },
                                                { "verified", this.verified },
                                                { "key", Key },
                                                { "receivedKey", E.InnerText },
                                                { "xml", sb.ToString() }
                                            },
                                            new KeyValuePair<string, string>("Accept", "application/json"));
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.Exception(ex);
                                    }
                                });
#endif
                                if (this.temporary)
                                {
                                    await this.BeginWrite(sb.ToString(), (Sender, e) => this.DisposeAsync("Verification failed."), null);
                                    return false;
                                }
                                else
                                {
                                    if (!await this.BeginWrite(sb.ToString(), null, null))
                                        return false;
 
                                    if (this.verified && this.state == XmppS2sState.Connected)
                                    {
                                        if (!await this.SendQueued())
                                            return false;
                                    }
                                }
                            }
                            else
                            {
                                this.verified = Type == "valid";
 
                                if (!(this.authConnection is null))
                                {
                                    try
                                    {
                                        if (this.verified)
                                        {
                                            this.authConnection.KeyAuthenticated(
                                                S2sValidationResult.Valid, null);
                                        }
                                        else
                                        {
                                            this.authConnection.KeyAuthenticated(
                                                S2sValidationResult.Invalid,
                                                "Remote validation failed.");
 
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.Exception(ex);
                                    }
 
                                    this.authConnection = null;
                                }
 
                                if (this.authVerifyRequestSent)
                                {
                                    await this.DisposeAsync("Verification request already sent.");
                                    return false;
                                }
                                else if (this.verified)
                                {
                                    if (!await this.SendQueued())
                                        return false;
                                }
                            }
                        }
                        break;
 
                    default:
                        break;
                }
            }
            catch (Exception ex)
            {
                await this.ConnectionError(ex);
                return false;
            }
 
            return true;
        }
 
        private async void ProcessIq(string Id, XmppAddress To, XmppAddress From, string Type, string Language, Stanza Stanza)
        {
            try
            {
                await this.server.ProcessIq(Id, To, From, Type, Language, Stanza, this);
            }
            catch (Exception ex)
            {
                this.Exception(ex);
            }
        }
 
        private async void ProcessMessage(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza)
        {
            try
            {
                await this.server.Message(Type, Id, To, From, Language, Stanza, this);
            }
            catch (Exception ex)
            {
                this.Exception(ex);
            }
        }
 
        private async void ProcessPresence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza)
        {
            try
            {
                await this.server.Presence(Type, Id, To, From, Language, Stanza, this);
            }
            catch (Exception ex)
            {
                this.Exception(ex);
            }
        }
 
        private async Task Client_OnPaused(object Sender, EventArgs e)
        {
            if (this.upgradeToTlsAsClient || this.upgradeToTlsAsServer)
            {
                bool AsClient = this.upgradeToTlsAsClient;
 
                this.upgradeToTlsAsClient = false;
                this.upgradeToTlsAsServer = false;
 
                string RemoteEndPoint = this.client.RemoteEndPoint.RemovePortNumber();
 
                if (AsClient || LoginAuditor.CanStartTls(RemoteEndPoint))
                {
                    try
                    {
                        if (AsClient)
                        {
                            await this.SetState(XmppS2sState.StartingEncryptionAsClient);
                            await this.client.UpgradeToTlsAsClient(this.localDomainCertificate, Crypto.SecureTls, null, this.trustServer, this.remoteDomain, "xmpp-server");
                        }
                        else
                        {
                            await this.SetState(XmppS2sState.StartingEncryptionAsServer);
                            await this.client.UpgradeToTlsAsServer(this.localDomainCertificate, Crypto.SecureTls, ClientCertificates.Optional, null, this.trustServer, "xmpp-server");
                        }
 
                        if (!(this.client.RemoteCertificate is null))
                        {
                            this.remoteDomainCertificateDomains = this.GetIdentities(this.client.RemoteCertificate);
 
                            if (this.HasSniffers)
                            {
                                StringBuilder sb = new StringBuilder();
                                string Subject = this.client.RemoteCertificate.Subject;
 
                                sb.Append("Remote Certificate received. Valid: ");
                                sb.Append(this.client.RemoteCertificateValid.ToString());
                                sb.Append(", SslPolicyErrors: ");
                                sb.Append(this.client.RemoteSslPolicyErrors.ToString());
                                sb.Append(", Subject: ");
                                sb.Append(Subject);
 
                                if (Subject.StartsWith("CN="))
                                    Subject = Subject[3..];
 
                                bool First = true;
 
                                foreach (CaseInsensitiveString Name in this.remoteDomainCertificateDomains)
                                {
                                    if (Name != Subject)
                                    {
                                        if (First)
                                        {
                                            sb.Append(", Alternative Names: ");
                                            First = false;
                                        }
                                        else
                                            sb.Append("; ");
 
                                        sb.Append(Name);
                                    }
                                }
 
                                sb.Append(", Issuer: ");
                                sb.Append(this.client.RemoteCertificate.Issuer);
                                sb.Append(", S/N: ");
                                sb.Append(this.client.RemoteCertificate.GetSerialNumberString());
                                sb.Append(", Hash: ");
                                sb.Append(this.client.RemoteCertificate.GetCertHashString());
 
                                if (!this.client.RemoteCertificateValid)
                                {
                                    try
                                    {
                                        byte[] Bin = this.client.RemoteCertificate.GetRawCertData();
                                        sb.AppendLine();
                                        sb.AppendLine();
                                        sb.Append(Convert.ToBase64String(Bin, Base64FormattingOptions.InsertLineBreaks));
                                    }
                                    catch (Exception)
                                    {
                                        sb.Append(" No raw data in certificate.");
                                    }
                                }
 
                                string Msg = sb.ToString();
 
                                this.Information(Msg);
 
                                if (!this.client.RemoteCertificateValid)
                                    Log.Warning(sb.ToString());
                            }
                        }
 
                        this.ResetState();
                        this.client.Continue();
 
                        if (AsClient)
                        {
                            await this.BeginWrite("<?xml version='1.0' encoding='utf-8'?><stream:stream id='" + this.localStreamId +
                                "' from='" + XML.Encode(this.localDomain) + "' to='" + XML.Encode(this.remoteDomain) +
                                "' version='1.0' xmlns='jabber:server' xmlns:db='" + DialbackNamespace + "' xmlns:stream='" +
                                XmppClientConnection.StreamNamespace + "'>", null, null);
                        }
                    }
                    catch (AuthenticationException ex)
                    {
                        await this.LoginFailure(ex, AsClient, RemoteEndPoint);
                    }
                    catch (Win32Exception ex)
                    {
                        await this.LoginFailure(ex, AsClient, RemoteEndPoint);
                    }
                    catch (Exception ex)
                    {
                        await this.ConnectionError(ex);
                    }
                }
                else
                    await this.ConnectionError(new Exception("Remote endpoint rejected due to suspected TLS hacking."));
            }
        }
 
        private async Task LoginFailure(Exception ex, bool AsClient, string RemoteIpEndpoint)
        {
            if (!AsClient)
            {
                Exception ex2 = Log.UnnestException(ex);
                LoginAuditor.ReportTlsHackAttempt(RemoteIpEndpoint, "TLS handshake failed: " + ex2.Message, "XMPP S2S");
 
                await this.ConnectionError(ex);
            }
        }
 
        private async Task<bool> CheckFrom(XmppAddress From)
        {
            if (this.remoteDomain is null)
                return true;
 
            CaseInsensitiveString FromDomain = From.Domain;
 
            if (FromDomain == this.remoteDomain)
                return true;
 
            if (FromDomain.EndsWith("." + this.remoteDomain, StringComparison.CurrentCultureIgnoreCase))
                return true;
 
            await this.BeginWrite("<stream:error><invalid-from xmlns='urn:ietf:params:xml:ns:xmpp-streams'/></stream:error></stream:stream>", async (Sender, e) =>
            {
                await this.CleanUp(this, XmppS2sState.Error, "Invalid from attribute value.");
            }, null);
 
            return false;
        }
 
        private async void KeyAuthenticated(S2sValidationResult ValidationResult, string Reason)
        {
            try
            {
                if (this.client?.Connected ?? false)
                {
                    if (string.IsNullOrEmpty(this.authKey))
                    {
                        StringBuilder Xml = new StringBuilder();
 
                        Xml.Append("<db:result from='");
                        Xml.Append(XML.Encode(this.localDomain));
                        Xml.Append("' to='");
                        Xml.Append(XML.Encode(this.remoteDomain));
                        Xml.Append("' type='");
 
                        switch (ValidationResult)
                        {
                            case S2sValidationResult.Valid:
                                Xml.Append("valid'/>");
                                break;
 
                            case S2sValidationResult.Invalid:
                                Xml.Append("invalid'/>");
                                break;
 
                            case S2sValidationResult.Error:
                            default:
                                Xml.Append("error'><error type='wait'>");
                                Xml.Append("<internal-server-error xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>");
 
                                if (!string.IsNullOrEmpty(Reason))
                                {
                                    Xml.Append("<text xmlns='");
                                    Xml.Append(XmppServer.StanzaNamespace);
                                    Xml.Append("'>");
                                    Xml.Append(XML.Encode(Reason));
                                    Xml.Append("</text>");
                                }
                                
                                Xml.Append("</error></db:result>");
                                break;
                        }
 
#if LogToWebHookTester
                        // TODO: Remove
                        _ = Task.Run(async () =>
                        {
                            try
                            {
                                await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.localDomain.Value),
                                    new Dictionary<string, object>()
                                    {
                                        { "id", this.Id.ToString() },
                                        { "event", "KeyAuthenticated" },
                                        { "local", this.localDomain.Value },
                                        { "remote", this.remoteDomain.Value },
                                        { "type", ValidationResult },
                                        { "reason", Reason },
                                        { "xml", Xml.ToString() }
                                    },
                                    new KeyValuePair<string, string>("Accept", "application/json"));
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                            }
                        });
#endif
                        await this.BeginWrite(Xml.ToString(), null, null);
                    }
 
                    if (ValidationResult == S2sValidationResult.Valid)
                    {
                        await this.SetState(XmppS2sState.Connected);
 
                        Log.Informational("XMPP S2S connection accepted.", this.remoteDomain, this.localDomain, "XmppIncomingS2SSuccess", EventLevel.Minor,
                            new KeyValuePair<string, object>("RemoteEndPoint", this.client.RemoteEndPoint));
 
                        if (this.bidirectional && !this.temporary)
                            this.server.RegisterS2SEndpoint(this);
 
                        await this.SendQueued();
                    }
                    else
                    {
                        Log.Warning("XMPP S2S connection failed.", this.remoteDomain, this.localDomain,
                            "XmppIncomingS2SFailure", EventLevel.Minor,
                            new KeyValuePair<string, object>("RemoteEndPoint", this.client.RemoteEndPoint),
                            new KeyValuePair<string, object>("Reason", Reason));
                    }
                }
            }
            catch (Exception ex)
            {
                this.Exception(ex);
            }
        }
 
        internal static Exception GetStreamExceptionObject(XmlElement E)
        {
            return GetExceptionObject(E, XmppServer.StreamsNamespace);
        }
 
        internal static Exception GetExceptionObject(XmlElement E, string Namespace)
        {
            string Msg = string.Empty;
 
            foreach (XmlNode N2 in E.ChildNodes)
            {
                if (N2.LocalName == "text")
                    Msg = N2.InnerText.Trim();
            }
 
            foreach (XmlNode N2 in E.ChildNodes)
            {
                if (N2.NamespaceURI == Namespace)
                {
                    if (string.IsNullOrEmpty(Msg))
                        Msg = N2.LocalName;
 
                    return new Exception(Msg);
                }
            }
 
            return new Exception(string.IsNullOrEmpty(Msg) ? "Unspecified error returned." : Msg);
        }
 
        internal static Exception GetStanzaExceptionObject(XmlElement E)
        {
            return GetExceptionObject(E, XmppServer.StanzaNamespace);
        }
 
        internal static Exception GetSaslExceptionObject(XmlElement E)
        {
            return GetExceptionObject(E, XmppServer.SaslNamespace);
        }
 
        internal CaseInsensitiveString[] GetIdentities(X509Certificate certificate)
        {
            List<CaseInsensitiveString> Domains = new List<CaseInsensitiveString>();
            bool HasAlternativeNames = false;
 
            try
            {
                foreach (string Part in certificate.Subject.Split(certificateSubjectSeparator, StringSplitOptions.None))
                {
                    if (Part.StartsWith("CN="))
                        Domains.Add(Part[3..]);
                    else if (Part.StartsWith("SAN="))
                    {
                        Domains.Add(Part[4..]);
                        HasAlternativeNames = true;
                    }
                }
 
                if (!HasAlternativeNames)
                {
                    if (!(certificate is X509Certificate2 Cert2))
                    {
                        byte[] Bin = certificate.GetRawCertData();
                        Cert2 = new X509Certificate2(Bin);
                    }
 
                    foreach (X509Extension Extension in Cert2.Extensions)
                    {
                        if (Extension.Oid.Value == "2.5.29.17")     // Subject Alternative Name
                        {
                            AsnEncodedData Parsed = new AsnEncodedData(Extension.Oid, Extension.RawData);
                            string[] SAN = Parsed.Format(true).Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);
 
                            foreach (string Name in SAN)
                            {
                                int i = Name.LastIndexOf('=');
                                if (i > 0)
                                    Domains.Add(Name[(i + 1)..]);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                StringBuilder sb = new StringBuilder();
 
                sb.Append("Unable to extract domain names from certificate subject (");
                sb.Append(ex.Message);
                sb.Append(").");
 
                try
                {
                    byte[] Bin = certificate.GetRawCertData();
                    sb.AppendLine();
                    sb.AppendLine();
                    sb.Append(Convert.ToBase64String(Bin, Base64FormattingOptions.InsertLineBreaks));
                }
                catch (Exception)
                {
                    sb.Append(" No raw data in certificate.");
                }
 
                this.Error(sb.ToString());
            }
 
            return Domains.ToArray();
        }
 
        private readonly static string[] certificateSubjectSeparator = new string[] { ", " };
 
        private async void DialbackCompleted(bool Successful, bool SendQueued, string Reason)
        {
            try
            {
                if (Successful)
                {
                    await this.SetState(XmppS2sState.Connected);
                    this.supportsPing = true;
                    this.secondTimer = new Timer(this.SecondTimerCallback, null, 1000, 1000);
 
                    this.Information("XMPP S2S connection successful.");
                    Log.Informational("XMPP S2S connection successful.", this.remoteDomain, this.localDomain, "XmppOutgoingS2SSuccess", EventLevel.Minor,
                        new KeyValuePair<string, object>("RemoteEndPoint", this.client.RemoteEndPoint));
 
                    if (SendQueued)
                        await this.SendQueued();
                }
                else
                {
                    await this.SetState(XmppS2sState.Error, "Dialback failed.");
 
                    this.Information("XMPP S2S connection failed: " + Reason);
                    Log.Warning("XMPP S2S connection failed.", this.remoteDomain, this.localDomain, "XmppOutgoingS2SFailure", EventLevel.Minor,
                        new KeyValuePair<string, object>("RemoteEndPoint", this.client.RemoteEndPoint),
                        new KeyValuePair<string, object>("Reason", Reason));
 
                    if (SendQueued)
                    {
                        lock (this.synchObject)
                        {
                            this.queue = null;
                            this.stanzasOnHold = null;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                this.Exception(ex);
            }
        }
 
        public int KeepAliveSeconds
        {
            get => this.keepAliveSeconds;
            set
            {
                if (value <= 0)
                    throw new ArgumentException("Value must be positive.", nameof(this.KeepAliveSeconds));
 
                this.keepAliveSeconds = value;
            }
        }
 
        private async void SecondTimerCallback(object State)
        {
            try
            {
                if (!this.checkConnection)
                    return;
 
                DateTime UtcNow = DateTime.UtcNow;
 
                if (UtcNow >= this.nextPingUtc && this.state == XmppS2sState.Connected)
                {
                    this.server.TouchServerConnection(this.remoteDomain);
 
                    this.nextPingUtc = DateTime.UtcNow.AddMilliseconds(this.keepAliveSeconds * 500);
                    try
                    {
                        if (this.supportsPing)
                        {
                            if (this.pingResponse)
                            {
                                this.pingResponse = false;
                                await this.SendPing();
                            }
                            else
                                await this.DisposeAsync("No ping response.");
                        }
                        else
                            await this.BeginWrite(" ", null, null);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                        this.Exception(ex);
                        await this.DisposeAsync(ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public Task<bool> SendPing()
        {
            StringBuilder Xml = new StringBuilder();
 
            this.pingId = this.server.NewId(16);
 
            Xml.Append("<iq type='get' id='");
            Xml.Append(this.pingId);
            Xml.Append("' from='");
            Xml.Append(XML.Encode(this.localDomain));
            Xml.Append("' to='");
            Xml.Append(XML.Encode(this.remoteDomain));
            Xml.Append("'><ping xmlns='");
            Xml.Append(XmppServer.PingNamespace);
            Xml.Append("'/></iq>");
 
            return this.BeginWrite(Xml.ToString(), null, null);
        }
 
        #region IRecipient
 
        public override Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.SendStanza("iq", Type, Id, To, From, Language, Stanza?.Content, Sender);
        }
 
        public override Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.SendStanza("iq", Type, Id, To, From, Language, ContentXml, Sender);
        }
 
        internal async Task<bool> SendStanza(string StanzaType, string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            bool Error;
 
            lock (this.synchObject)
            {
                if (this.state == XmppS2sState.Error)
                    Error = true;
                else if (this.state == XmppS2sState.Connected)
                    Error = false;
                else
                {
                    this.queue ??= new ChunkedList<QueuedStanza>();
                    this.queue.Add(new QueuedStanza()
                    {
                        StanzaType = StanzaType,
                        Type = Type,
                        Id = Id,
                        To = To,
                        From = From,
                        Language = Language,
                        ContentXml = ContentXml,
                        Sender = Sender
                    });
 
                    return true;
                }
            }
 
            if (Error)
            {
                if (!(Sender is null))
                {
                    switch (StanzaType.ToLower())
                    {
                        case "iq":
                            if (Sender is null)
                                return true;
                            else
                                return !(await Sender.IqError(Id, From, To, this.errorType, this.errorXml, "S2S connection failed.", "en") is null);
 
                        case "message":
                            if (!await (Sender?.MessageError(Id, From, To, this.errorType, this.errorXml, "S2S connection failed.", "en") ?? Task.FromResult(true)))
                                return false;
                            break;
 
                        case "presence":
                            if (!await (Sender?.PresenceError(Id, From, To, this.errorType, this.errorXml, "S2S connection failed.", "en") ?? Task.FromResult(true)))
                                return false;
                            break;
                    }
                }
            }
            else
            {
                try
                {
                    if (!await this.BeginWrite(StanzaType, Type, Id, To, From, Language, ContentXml))
                        return false;
                }
                catch (Exception ex)
                {
                    if (!(Sender is null))
                    {
                        try
                        {
                            switch (StanzaType.ToLower())
                            {
                                case "iq":
                                    if (Sender is null)
                                        return true;
                                    else
                                        return !(await Sender.IqError(Id, From, To, this.errorType, this.errorXml, "S2S connection failed: " + ex.Message, "en") is null);
 
                                case "message":
                                    if (!await (Sender?.MessageError(Id, From, To, this.errorType, this.errorXml, "S2S connection failed: " + ex.Message, "en") ?? Task.FromResult(true)))
                                        return false;
                                    break;
 
                                case "presence":
                                    if (!await (Sender?.PresenceError(Id, From, To, this.errorType, this.errorXml, "S2S connection failed: " + ex.Message, "en") ?? Task.FromResult(true)))
                                        return false;
                                    break;
                            }
                        }
                        catch (Exception ex2)
                        {
                            Log.Exception(ex2);
                        }
                    }
                }
            }
 
            return true;
        }
 
        private Task<bool> BeginWrite(string StanzaType, string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append('<');
            Xml.Append(StanzaType);
 
            if (!From.IsEmpty)
            {
                Xml.Append(" from='");
                Xml.Append(XML.Encode(From.Address));
            }
 
            if (!To.IsEmpty)
            {
                Xml.Append("' to='");
                Xml.Append(XML.Encode(To.Address));
            }
 
            if (!string.IsNullOrEmpty(Type))
            {
                Xml.Append("' type='");
                Xml.Append(Type);
            }
 
            if (!string.IsNullOrEmpty(Id))
            {
                Xml.Append("' id='");
                Xml.Append(XML.Encode(Id));
            }
 
            if (!string.IsNullOrEmpty(Language))
            {
                Xml.Append("' xml:lang='");
                Xml.Append(XML.Encode(Language));
            }
 
            if (string.IsNullOrEmpty(ContentXml))
                Xml.Append("'/>");
            else
            {
                Xml.Append("'>");
                Xml.Append(ContentXml);
                Xml.Append("</");
                Xml.Append(StanzaType);
                Xml.Append('>');
            }
 
            return this.BeginWrite(Xml.ToString(), null, null);
        }
 
        public override Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.SendStanza("message", Type, Id, To, From, Language, Stanza?.Content, Sender);
        }
 
        public override Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.SendStanza("message", Type, Id, To, From, Language, ContentXml, Sender);
        }
 
        public override Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            return this.SendStanza("presence", Type, Id, To, From, Language, Stanza?.Content, Sender);
        }
 
        public override Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.SendStanza("presence", Type, Id, To, From, Language, ContentXml, Sender);
        }
 
        #endregion
 
        #region ISender
 
        public override Task<bool> IqError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<iq");
            XmppClientConnection.AppendParameters(Xml, "error", Id, To, From, string.Empty, (Stanza)null);
            Xml.Append('>');
            Xml.Append(ErrorXml);
            Xml.Append("</iq>");
 
            return this.BeginWrite(Xml.ToString(), null, null);
        }
 
        public override Task<string> IqError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            XmppServer.GetErrorInformation(ex, out string Type, out string Xml);
            return this.IqError(Id, To, From, Type, Xml, ex.Message + "\r\n\r\n" + Log.CleanStackTrace(ex.StackTrace), string.Empty);
        }
 
        public override Task<bool> IqResult(string Id, XmppAddress To, XmppAddress From, string ResultXml)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<iq");
            XmppClientConnection.AppendParameters(Xml, "result", Id, To, From, string.Empty, (Stanza)null);
            Xml.Append('>');
            Xml.Append(ResultXml);
            Xml.Append("</iq>");
 
            return this.BeginWrite(Xml.ToString(), null, null);
        }
 
        public override Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            return this.SendStanza("presence", Type, Id, To, From, Language, ContentXml, null);
            // TODO: Errors in SendStanza should be returned, which does not happen since last parameter is null.
        }
 
        public override Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<presence id='");
            Xml.Append(Id);
            Xml.Append("' from='");
            Xml.Append(From);
            Xml.Append("' to='");
            Xml.Append(To);
            Xml.Append("' type='error'>");
            Xml.Append(ErrorXml);
            Xml.Append("</presence>");
 
            return this.BeginWrite(Xml.ToString(), null, null);
        }
 
        public override Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            XmppServer.GetErrorInformation(ex, out string Type, out string Xml);
            return this.PresenceError(Id, To, From, Type, Xml, ex.Message + "\r\n\r\n" + Log.CleanStackTrace(ex.StackTrace), string.Empty);
        }
 
        public override Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            return this.Message(Type, Id, To, From, Language, ContentXml, null);
        }
 
        public override Task<bool> MessageError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            XmppServer.GetErrorInformation(ex, out string Type, out string Xml);
            return this.MessageError(Id, To, From, Type, Xml, ex.Message + "\r\n\r\n" + Log.CleanStackTrace(ex.StackTrace), string.Empty);
        }
 
        #endregion
 
    }
}