XmppServer.cs

//#define LogToWebHookTester  
 
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Mail;
using System.Net.NetworkInformation;
using System.Net.Security;
using System.Net.Sockets;
using System.Reflection;
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.Html;
using Waher.Content.Markdown;
using Waher.Content.Multipart;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Events.Statistics;
using Waher.Networking.DNS;
using Waher.Networking.DNS.ResourceRecords;
using Waher.Networking.HTTP;
using Waher.Networking.SASL;
using Waher.Networking.SMTP.Server;
using Waher.Networking.Sniffers;
using Waher.Networking.XMPP.Server.Mail;
using Waher.Networking.XMPP.Server.PrivateXmlStorage;
using Waher.Networking.XMPP.Server.PushNotification;
using Waher.Networking.XMPP.Server.S2S;
using Waher.Networking.XMPP.Server.ServiceDiscovery;
using Waher.Networking.XMPP.Server.Statistics;
using Waher.Networking.XMPP.StanzaErrors;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Cache;
using Waher.Runtime.Counters;
using Waher.Runtime.Inventory;
using Waher.Runtime.Settings;
using Waher.Runtime.Threading;
using Waher.Runtime.Timing;
using Waher.Script;
using Waher.Script.Content;
using Waher.Script.Content.Functions.Encoding;
using Waher.Script.Data.Functions;
using Waher.Script.Fractals;
using Waher.Script.FullTextSearch.Functions;
using Waher.Script.Functions.Runtime;
using Waher.Script.Model;
using Waher.Script.Networking.Functions;
using Waher.Script.Operators;
using Waher.Script.Operators.Assignments;
using Waher.Script.Operators.Membership;
using Waher.Script.Persistence.Functions;
using Waher.Script.System.Functions;
using Waher.Security;
using Waher.Security.LoginMonitor;
 
namespace Waher.Networking.XMPP.Server
{
    public class XmppServer : IDisposable, IRecipient, ISender, ITlsCertificateEndpoint
    {
        public const int DefaultC2sPort = 5222;
 
        public const int DefaultS2sPort = 5269;
 
        public const int DefaultConnectionBacklog = 10;
 
        public const int DefaultBufferSize = 16384;
 
        public const int MaxGroupLength = 1000;
 
        public const int MaxNameLength = 1000;
 
        public const string StanzaNamespace = "urn:ietf:params:xml:ns:xmpp-stanzas";
 
        public const string StreamsNamespace = "urn:ietf:params:xml:ns:xmpp-streams";
 
        public const string SaslNamespace = "urn:ietf:params:xml:ns:xmpp-sasl";
 
        public const string RosterNamespace = "jabber:iq:roster";
 
        public const string DataFormsNamespace = "jabber:x:data";
 
        public const string AvatarStorageNamespace = "storage:client:avatar";
 
        public const string DiscoveryNamespace = "http://jabber.org/protocol/disco#info";
 
        public const string DiscoveryItemsNamespace = "http://jabber.org/protocol/disco#items";
 
        public const string ExtendedAddressingNamespace = "http://jabber.org/protocol/address";
 
        public const string PrivateXmlStorageNamespace = "jabber:iq:private";
 
        public const string VCardNamespace = "vcard-temp";
 
        public const string RegisterNamespace = "jabber:iq:register";
 
        public const string SoftwareVersionNamespace = "jabber:iq:version";
 
        public const string OfflineMessagesNamespace = "msgoffline";
 
        public const string BlockingCommandNamespace = "urn:xmpp:blocking";
 
        public const string BlockingCommandErrorNamespace = "urn:xmpp:blocking:errors";
 
        public const string PingNamespace = "urn:xmpp:ping";
 
        public const string TimeNamespace = "urn:xmpp:time";
 
        public const string DelayedDeliveryNamespace = "urn:xmpp:delay";
 
        public const string OAuth1FormSignatureNamespace = "urn:xmpp:xdata:signature:oauth1";
 
        public const string ReportingNamespace = "urn:xmpp:reporting:0";
 
        public const string AbuseReportingNamespace = "urn:xmpp:reporting:reason:abuse:0";
 
        public const string SpamReportingNamespace = "urn:xmpp:reporting:reason:spam:0";
 
        public const string MailNamespace = "urn:xmpp:smtp";
 
        public const string ContentNamespace = "urn:xmpp:content";
 
        public const string MessagePushNamespace = "http://waher.se/Schema/PushNotification.xsd";
 
        public const string AlternativesNamespace = "http://waher.se/Schema/Alternatives.xsd";
 
        private static readonly RandomNumberGenerator rnd = RandomNumberGenerator.Create();
        private static readonly Dictionary<CaseInsensitiveString, S2SRec> remoteDomainLookup = new Dictionary<CaseInsensitiveString, S2SRec>();
        private static Scheduler scheduler = new Scheduler();
        internal static readonly UTF8Encoding encoding = new UTF8Encoding(false, false);
        private static readonly Cache<CaseInsensitiveString, PushNotificationToken> tokens =
            new Cache<CaseInsensitiveString, PushNotificationToken>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromDays(62));
        private static readonly Cache<string, PushNotificationRule> rules =
            new Cache<string, PushNotificationRule>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromDays(62));
 
        private readonly SmtpServer smtpServer = null;
        private readonly HttpServer httpServer = null;
        private RequestWhiteList requestWhiteList = null;
        private LinkedList<TcpListener> c2sListeners = new LinkedList<TcpListener>();
        private LinkedList<TcpListener> s2sListeners = new LinkedList<TcpListener>();
        private Cache<CaseInsensitiveString, IClientConnection> clientConnections;
        private Cache<CaseInsensitiveString, CaseInsensitiveString> services = new Cache<CaseInsensitiveString, CaseInsensitiveString>(int.MaxValue, TimeSpan.FromDays(1), TimeSpan.FromDays(1), true);
        private readonly Dictionary<CaseInsensitiveString, List<IClientConnection>> connectionsPerBareJid = new Dictionary<CaseInsensitiveString, List<IClientConnection>>();
        private readonly Dictionary<string, EventHandlerAsync<IqEventArgs>> iqGetHandlers = new Dictionary<string, EventHandlerAsync<IqEventArgs>>();
        private readonly Dictionary<string, EventHandlerAsync<IqEventArgs>> iqSetHandlers = new Dictionary<string, EventHandlerAsync<IqEventArgs>>();
        private readonly Dictionary<string, EventHandlerAsync<MessageEventArgs>> messageHandlers = new Dictionary<string, EventHandlerAsync<MessageEventArgs>>();
        private readonly SortedDictionary<string, bool> features = new SortedDictionary<string, bool>();
        private readonly SortedDictionary<CaseInsensitiveString, IComponent> componentsBySubdomain = new SortedDictionary<CaseInsensitiveString, IComponent>();
        private readonly SortedDictionary<CaseInsensitiveString, IComponent> componentsByFulldomain = new SortedDictionary<CaseInsensitiveString, IComponent>();
        private readonly Dictionary<string, PendingRequest> pendingRequestsById = new Dictionary<string, PendingRequest>();
        private readonly SortedDictionary<DateTime, PendingRequest> pendingRequestsByTimeout = new SortedDictionary<DateTime, PendingRequest>();
        private readonly IqResponses responses = new IqResponses(TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(10));
        private readonly SortedDictionary<CaseInsensitiveString, S2sEndpointStatistics> s2sStatistics = new SortedDictionary<CaseInsensitiveString, S2sEndpointStatistics>();
        private Dictionary<string, Statistic> stanzasPerStanzaType = new Dictionary<string, Statistic>();
        private Dictionary<string, Statistic> stanzasPerFromDomain = new Dictionary<string, Statistic>();
        private Dictionary<string, Statistic> stanzasPerToDomain = new Dictionary<string, Statistic>();
        private Dictionary<string, Statistic> stanzasPerFromBareJid = new Dictionary<string, Statistic>();
        private Dictionary<string, Statistic> stanzasPerToBareJid = new Dictionary<string, Statistic>();
        private Dictionary<string, Statistic> stanzasPerNamespace = new Dictionary<string, Statistic>();
        private Dictionary<string, Statistic> stanzasPerFqn = new Dictionary<string, Statistic>();
        private readonly object statSync = new object();
        private DateTime lastStat = DateTime.Now;
        private IComponent[] componentsStatic = Array.Empty<IComponent>();
        private Cache<CaseInsensitiveString, IS2SEndpoint> s2sEndpoints;
        private Cache<CaseInsensitiveString, XmlFileSniffer> sniffers;
        private Cache<string, IqResultEventArgs> shortTermCache = new Cache<string, IqResultEventArgs>(int.MaxValue, TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
        private SortedDictionary<DateTime, IS2SEndpoint> temporaryConnections = null;
        private X509Certificate serverCertificate;
        private readonly IXmppServerPersistenceLayer persistenceLayer;
        private Accounts accounts;
        private Timer secondTimer = null;
        private readonly byte[] sha256DialbackSecret;
        private readonly object synchObject = new object();
        private readonly XmppAddress domainAddress;
        private readonly Random gen = new Random();
        private readonly CaseInsensitiveString domain;
        private readonly CaseInsensitiveString[] alternativeDomains;
        private readonly string serverName;
        private readonly string serverVersion;
        private readonly string serverOS;
        private string domainSnifferPath = null;
        private string clientSnifferPath = null;
        private readonly bool encryptionRequired;
        private bool disposed = false;
        private readonly CommunicationLayer c2sSniffers = new CommunicationLayer(true);
        private readonly CommunicationLayer s2sSniffers = new CommunicationLayer(true);
        private readonly int defaultRetryTimeout = 5000;
        private readonly int defaultNrRetries = 5;
        private readonly int defaultMaxRetryTimeout = int.MaxValue;
        private readonly bool defaultDropOff = true;
        private long nrBytesRx = 0;
        private long nrBytesTx = 0;
        private long nrStanzas = 0;
 
        #region Constructors
 
        static XmppServer()
        {
            Log.Terminating += (Sender, e) =>
            {
                scheduler?.Dispose();
                scheduler = null;
                return Task.CompletedTask;
            };
        }
 
        public static Task<XmppServer> Create(CaseInsensitiveString Domain, CaseInsensitiveString[] AlternativeDomains,
            X509Certificate ServerCertificate, bool EncryptionRequired, IXmppServerPersistenceLayer PersistenceLayer)
        {
            return Create(Domain, AlternativeDomains, DefaultC2sPort, DefaultS2sPort, ServerCertificate, EncryptionRequired, PersistenceLayer);
        }
 
        public static Task<XmppServer> Create(CaseInsensitiveString Domain, CaseInsensitiveString[] AlternativeDomains,
            int ClientToServerPort, int ServerToServerPort, X509Certificate ServerCertificate, bool EncryptionRequired,
            IXmppServerPersistenceLayer PersistenceLayer)
        {
            return Create(Domain, AlternativeDomains, new int[] { ClientToServerPort }, new int[] { ServerToServerPort },
                ServerCertificate, EncryptionRequired, PersistenceLayer);
        }
 
        public static Task<XmppServer> Create(CaseInsensitiveString Domain, CaseInsensitiveString[] AlternativeDomains,
            int[] ClientToServerPorts, int[] ServerToServerPorts, X509Certificate ServerCertificate, bool EncryptionRequired,
            IXmppServerPersistenceLayer PersistenceLayer)
        {
            return Create(Domain, AlternativeDomains, ClientToServerPorts, ServerToServerPorts, ServerCertificate, EncryptionRequired,
                PersistenceLayer, null, null);
        }
 
        public static async Task<XmppServer> Create(CaseInsensitiveString Domain, CaseInsensitiveString[] AlternativeDomains,
            int[] ClientToServerPorts, int[] ServerToServerPorts, X509Certificate ServerCertificate, bool EncryptionRequired,
            IXmppServerPersistenceLayer PersistenceLayer, SmtpServer SmtpServer, HttpServer HttpServer)
        {
            byte[] DialbackSecret = await PersistenceLayer.GetDialbackSecret();
 
            if (mechanisms is null)
            {
                lock (synchObj)
                {
                    if (first)
                    {
                        first = false;
                        Types.OnInvalidated += Types_OnInvalidated;
                    }
                }
 
                mechanisms = await GetMechanisms();
            }
 
            return new XmppServer(Domain, AlternativeDomains, ClientToServerPorts, ServerToServerPorts, ServerCertificate,
                EncryptionRequired, PersistenceLayer, DialbackSecret, SmtpServer, HttpServer);
        }
 
        internal static IAuthenticationMechanism[] mechanisms = null;
        private static readonly object synchObj = new object();
        private static bool first = true;
 
        private static async Task<IAuthenticationMechanism[]> GetMechanisms()
        {
            Dictionary<string, bool> MechanismsFound = new Dictionary<string, bool>();
            List<IAuthenticationMechanism> Result = new List<IAuthenticationMechanism>();
            ConstructorInfo CI;
            IAuthenticationMechanism Mechanism;
 
            foreach (Type T in Types.GetTypesImplementingInterface(typeof(IAuthenticationMechanism)))
            {
                if (T.IsAbstract)
                    continue;
 
                CI = T.GetConstructor(Types.NoTypes);
                if (CI is null)
                    continue;
 
                try
                {
                    Mechanism = (IAuthenticationMechanism)CI.Invoke(Types.NoParameters);
 
                    if (MechanismsFound.ContainsKey(Mechanism.Name))
                        throw new Exception("Authentication mechanism collision." + T.FullName + ": " + Mechanism.Name);
 
                    await Mechanism.Initialize();
 
                    MechanismsFound[Mechanism.Name] = true;
                    Result.Add(Mechanism);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
 
            Result.Sort((m1, m2) => m2.Weight - m1.Weight);
 
            return Result.ToArray();
        }
 
        private static async void Types_OnInvalidated(object Sender, EventArgs e)
        {
            try
            {
                mechanisms = await GetMechanisms();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private XmppServer(CaseInsensitiveString Domain, CaseInsensitiveString[] AlternativeDomains, int[] ClientToServerPorts,
            int[] ServerToServerPorts, X509Certificate ServerCertificate, bool EncryptionRequired,
            IXmppServerPersistenceLayer PersistenceLayer, byte[] DialbackSecret, SmtpServer SmtpServer, HttpServer HttpServer)
        {
            this.persistenceLayer = PersistenceLayer;
            this.serverCertificate = ServerCertificate;
            this.encryptionRequired = EncryptionRequired;
            this.domain = Domain;
            this.alternativeDomains = AlternativeDomains ?? Array.Empty<CaseInsensitiveString>();
            this.domainAddress = new XmppAddress(this.domain);
            this.accounts = new Accounts(this);
            this.smtpServer = SmtpServer;
            this.httpServer = HttpServer;
 
            this.httpServer?.Register(this.requestWhiteList = new RequestWhiteList(this));
 
            this.sha256DialbackSecret = Hashes.ComputeSHA256Hash(DialbackSecret);
 
            if (EncryptionRequired && this.serverCertificate is null)
                throw new ArgumentException("Server Certificate must be provided, if encryption is required.", nameof(ServerCertificate));
 
            this.clientConnections = new Cache<CaseInsensitiveString, IClientConnection>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromMinutes(2), true);
            this.clientConnections.Removed += this.ClientConnections_Removed;
 
            this.s2sEndpoints = new Cache<CaseInsensitiveString, IS2SEndpoint>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromDays(1), true);
            this.s2sEndpoints.Removed += this.S2sEndpoints_Removed;
 
            Assembly ThisAssembly = typeof(XmppServer).Assembly;
            StackTrace Trace = new StackTrace();
            StackFrame[] Frames = Trace.GetFrames();
            StackFrame Frame;
            MethodBase Method;
            Assembly Assembly;
            int i = 1;
            int c = Frames.Length;
 
            do
            {
                Frame = Frames[i++];
                Method = Frame.GetMethod();
                Assembly = Method.DeclaringType.Assembly;
            }
            while (Assembly == ThisAssembly);
 
            AssemblyName Name = Assembly.GetName();
            string Title = string.Empty;
            string Product = string.Empty;
            string AssemblyName = Name.Name;
 
            foreach (object Attribute in Assembly.GetCustomAttributes())
            {
                if (Attribute is AssemblyTitleAttribute AssemblyTitleAttribute)
                    Title = AssemblyTitleAttribute.Title;
                else if (Attribute is AssemblyProductAttribute AssemblyProductAttribute)
                    Product = AssemblyProductAttribute.Product;
            }
 
            if (!string.IsNullOrEmpty(Title))
                this.serverName = Title;
            else if (!string.IsNullOrEmpty(Product))
                this.serverName = Product;
            else
                this.serverName = AssemblyName;
 
            this.serverVersion = Name.Version.ToString();
            this.serverOS = Environment.OSVersion.ToString();
 
            this.RegisterIqGetHandler("query", RosterNamespace, this.RosterQuery, true);
            this.RegisterIqSetHandler("query", RosterNamespace, this.RosterSet, false);
            this.RegisterIqGetHandler("query", DiscoveryNamespace, this.DiscoveryQueryGet, true);   // XEP-0030
            this.RegisterIqGetHandler("query", DiscoveryItemsNamespace, this.DiscoveryQueryItemsGet, true);   // XEP-0030
            this.RegisterIqGetHandler("query", PrivateXmlStorageNamespace, this.PrivateXmlStorageGet, true);    // XEP-0049
            this.RegisterIqSetHandler("query", PrivateXmlStorageNamespace, this.PrivateXmlStorageSet, false);   // XEP-0049
            this.RegisterIqGetHandler("vCard", VCardNamespace, this.VCardGet, true);   // XEP-0054
            this.RegisterIqSetHandler("vCard", VCardNamespace, this.VCardSet, false);   // XEP-0054
            this.RegisterIqGetHandler("query", RegisterNamespace, this.RegisterGet, true); // XEP-0077
            this.RegisterIqSetHandler("query", RegisterNamespace, this.RegisterSet, false); // XEP-0077
            this.RegisterIqGetHandler("query", SoftwareVersionNamespace, this.SoftwareVersionGet, true); // XEP-0092
            this.RegisterIqGetHandler("blocklist", BlockingCommandNamespace, this.BlockListGet, true);   // XEP-0191
            this.RegisterIqSetHandler("block", BlockingCommandNamespace, this.BlockSet, false);   // XEP-0191
            this.RegisterIqSetHandler("unblock", BlockingCommandNamespace, this.UnblockSet, false);   // XEP-0191
            this.RegisterIqGetHandler("ping", PingNamespace, this.PingGet, true);   // XEP-0199
            this.RegisterIqGetHandler("time", TimeNamespace, this.TimeGet, true);   // XEP-0202
            this.RegisterIqGetHandler("get", MailNamespace, this.GetMailContent, true); // TODO: Write Mail XEP
            this.RegisterIqSetHandler("delete", MailNamespace, this.DeleteMailContent, false);
            this.RegisterIqSetHandler("newToken", MessagePushNamespace, this.NewTokenHandler, true);
            this.RegisterIqSetHandler("removeToken", MessagePushNamespace, this.RemoveTokenHandler, false);
            this.RegisterIqSetHandler("clearRules", MessagePushNamespace, this.ClearRulesHandler, false);
            this.RegisterIqSetHandler("addRule", MessagePushNamespace, this.AddRuleHandler, false);
            this.RegisterIqSetHandler("removeRule", MessagePushNamespace, this.RemoveRuleHandler, false);
            this.features[OfflineMessagesNamespace] = true; // XEP-0160
            this.features[OAuth1FormSignatureNamespace] = true; // XEP-0348
            this.features[ReportingNamespace] = true; // XEP-0377
            this.features[SpamReportingNamespace] = true; // XEP-0377
            this.features[AbuseReportingNamespace] = true; // XEP-0377
 
            this.Initialize(ClientToServerPorts, ServerToServerPorts);
        }
 
        private void Initialize(int[] ClientToServerPorts, int[] ServerToServerPorts)
        {
            try
            {
                TcpListener Listener;
 
                foreach (NetworkInterface Interface in NetworkInterface.GetAllNetworkInterfaces())
                {
                    if (Interface.OperationalStatus != OperationalStatus.Up)
                        continue;
 
                    IPInterfaceProperties Properties = Interface.GetIPProperties();
 
                    foreach (UnicastIPAddressInformation UnicastAddress in Properties.UnicastAddresses)
                    {
                        if ((UnicastAddress.Address.AddressFamily == AddressFamily.InterNetwork && Socket.OSSupportsIPv4) ||
                            (UnicastAddress.Address.AddressFamily == AddressFamily.InterNetworkV6 && Socket.OSSupportsIPv6))
                        {
                            if (!(ClientToServerPorts is null))
                            {
                                foreach (int C2sPort in ClientToServerPorts)
                                {
                                    try
                                    {
                                        this.c2sSniffers.Information("Opening port " + C2sPort.ToString() + " on " + UnicastAddress.Address.ToString() + ".");
 
                                        Listener = new TcpListener(UnicastAddress.Address, C2sPort);
                                        Listener.Start(DefaultConnectionBacklog);
                                        Listener.BeginAcceptTcpClient(this.AcceptTcpClientCallback, new object[] { Listener, false });
                                        this.c2sListeners.AddLast(Listener);
 
                                        this.c2sSniffers.Information("Port " + C2sPort.ToString() + " on " + UnicastAddress.Address.ToString() + " opened.");
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.Exception(ex, UnicastAddress.Address.ToString() + ":" + C2sPort);
                                    }
                                }
                            }
 
                            if (!(ServerToServerPorts is null))
                            {
                                foreach (int S2sPort in ServerToServerPorts)
                                {
                                    try
                                    {
                                        this.s2sSniffers.Information("Opening port " + S2sPort.ToString() + " on " + UnicastAddress.Address.ToString() + ".");
 
                                        Listener = new TcpListener(UnicastAddress.Address, S2sPort);
                                        Listener.Start(DefaultConnectionBacklog);
                                        Listener.BeginAcceptTcpClient(this.AcceptTcpClientCallback, new object[] { Listener, true });
                                        this.s2sListeners.AddLast(Listener);
 
                                        this.s2sSniffers.Information("Port " + S2sPort.ToString() + " on " + UnicastAddress.Address.ToString() + " opened.");
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.Exception(ex, UnicastAddress.Address.ToString() + ":" + S2sPort);
                                    }
                                }
                            }
                        }
                    }
                }
 
                this.secondTimer = new Timer(this.SecondTimerCallback, null, 1000, 1000);
 
                if (!(this.smtpServer is null))
                    this.smtpServer.MessageReceived += this.SmtpServer_MessageReceived;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public Accounts Accounts => this.accounts;
 
        public CommunicationLayer C2sSniffers => this.c2sSniffers;
 
        public CommunicationLayer S2sSniffers => this.s2sSniffers;
 
        public static Scheduler Scheduler => scheduler;
 
        public string NewId(int NrBytes)
        {
            return Hashes.BinaryToString(GetRandomNumbers(NrBytes));
        }
 
        public static byte[] GetRandomNumbers(int NrBytes)
        {
            byte[] Result = new byte[NrBytes];
 
            lock (rnd)
            {
                rnd.GetBytes(Result);
            }
 
            return Result;
        }
 
        public string GetRandomHexString(int NrBytes)
        {
            return Hashes.BinaryToString(GetRandomNumbers(NrBytes));
        }
 
        private async Task ClientConnections_Removed(object Sender, CacheItemEventArgs<CaseInsensitiveString, IClientConnection> e)
        {
            this.ConnectionClosed(e.Value);
 
            await this.ClientConnectionRemoved.Raise(this, new ClientConnectionEventArgs(e.Key, e.Value));
            await e.Value.DisposeAsync();
        }
 
        public bool TryGetS2sStatistics(CaseInsensitiveString Endpoint, out S2sEndpointStatistics Stat)
        {
            lock (this.s2sStatistics)
            {
                return this.s2sStatistics.TryGetValue(Endpoint, out Stat);
            }
        }
 
        public S2sEndpointStatistics GetS2sStatistics(CaseInsensitiveString Endpoint, string Type)
        {
            S2sEndpointStatistics Result;
 
            lock (this.s2sStatistics)
            {
                if (!this.s2sStatistics.TryGetValue(Endpoint, out Result))
                {
                    Result = new S2sEndpointStatistics(Endpoint, Type);
                    this.s2sStatistics[Endpoint] = Result;
                }
            }
 
            return Result;
        }
 
        internal void S2sEndpointDisposed(IS2SEndpoint Endpoint)
        {
            CaseInsensitiveString Domain = Endpoint?.RemoteDomain;
 
            if (!(this.s2sEndpoints is null) &&
                !(Endpoint is null) &&
                !CaseInsensitiveString.IsNullOrEmpty(Domain) &&
                this.s2sEndpoints.TryGetValue(Domain, out IS2SEndpoint Endpoint2) &&
                Endpoint == Endpoint2)
            {
                this.s2sEndpoints?.Remove(Domain);
            }
        }
 
        private async Task S2sEndpoints_Removed(object Sender, CacheItemEventArgs<CaseInsensitiveString, IS2SEndpoint> e)
        {
#if LogToWebHookTester
            // TODO: Remove
            _ = Task.Run(async () =>
            {
                try
                {
                    await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.domain.Value),
                        new Dictionary<string, object>()
                        {
                            { "id", e.Value.Id.ToString() },
                            { "event", "S2sEndpoints_Removed" },
                            { "remote", e.Key.Value },
                            { "value", JSON.Encode(e.Value, true) },
                            { "reason", e.Reason }
                        },
                        new KeyValuePair<string, string>("Accept", "application/json"));
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
#endif
            Log.Informational("Removing S2S connection.",
                e.Value.RemoteDomain, string.Empty, "XmppCloseS2s",
                new KeyValuePair<string, object>("Reason", e.Reason));
 
            EndpointStatistics Stat = this.GetS2sStatistics(e.Key, e.Value.Type);
            Stat.EndpointDisconnected(e.Value, (long)((DateTime.Now - e.Value.Connected).TotalMilliseconds + 0.5));
 
            if (e.Value is XmppS2SEndpoint XmppS2SEndpoint)
            {
                XmppS2SEndpoint.OnStateChanged -= this.Endpoint_OnStateChanged;
                await this.S2sEndpointRemoved.Raise(this, new XmppS2SEndpointEventArgs(XmppS2SEndpoint));
            }
 
            await e.Value.DisposeAsync("S2S connection removed: " + e.Reason.ToString());
 
            if (e.Reason != RemovedReason.Replaced)
                await this.ServerConnectionRemoved.Raise(this, new ServerConnectionEventArgs(e.Key, e.Value));
        }
 
        public CaseInsensitiveString[] RemoteConnections
        {
            get
            {
                return this.s2sEndpoints.GetKeys();
            }
        }
 
        public int NrClientConnections
        {
            get => this.clientConnections.Count;
        }
 
        public IClientConnection[] GetClientConnections()
        {
            IClientConnection[] Connections = this.clientConnections.GetValues();
 
            Array.Sort(Connections, (c1, c2) =>
            {
                return c1.FullJid.CompareTo(c2.FullJid);
            });
 
            return Connections;
        }
 
        public bool TryGetClientConnection(string FullJID, out IClientConnection Connection)
        {
            return this.clientConnections.TryGetValue(FullJID, out Connection);
        }
 
        public bool TryGetClientConnections(string BareJID, out IClientConnection[] Connections)
        {
            lock (this.connectionsPerBareJid)
            {
                if (this.connectionsPerBareJid.TryGetValue(BareJID, out List<IClientConnection> Connections2))
                {
                    Connections = Connections2.ToArray();
                    return true;
                }
            }
 
            Connections = null;
            return false;
        }
 
        public int NrServerConnections
        {
            get => this.s2sEndpoints.Count;
        }
 
        public S2sEndpointStatistics[] GetServerConnectionStatistics()
        {
            lock (this.s2sStatistics)
            {
                S2sEndpointStatistics[] Result = new S2sEndpointStatistics[this.s2sStatistics.Count];
                this.s2sStatistics.Values.CopyTo(Result, 0);
                return Result;
            }
        }
 
        public bool IsServerDomain(CaseInsensitiveString Domain, bool IncludeAlternativeDomains)
        {
            if (Domain == this.domain)
                return true;
 
            if (IncludeAlternativeDomains)
            {
                foreach (CaseInsensitiveString s in this.alternativeDomains)
                {
                    if (s == Domain)
                        return true;
                }
            }
 
            if (!this.HasDomain && CaseInsensitiveString.IsNullOrEmpty(Domain))
                return true;
 
            return false;
        }
 
        public CaseInsensitiveString Domain
        {
            get => this.domain;
        }
 
        public CaseInsensitiveString[] AlternativeDomains
        {
            get => this.alternativeDomains;
        }
 
        public X509Certificate ServerCertificate
        {
            get => this.serverCertificate;
        }
 
        public void UpdateCertificate(X509Certificate ServerCertificate)
        {
            this.serverCertificate = ServerCertificate;
        }
 
        public bool EncryptionRequired
        {
            get => this.encryptionRequired;
        }
 
        public string DomainSnifferPath
        {
            get => this.domainSnifferPath;
            set => this.domainSnifferPath = value;
        }
 
        public string ClientSnifferPath
        {
            get => this.clientSnifferPath;
            set => this.clientSnifferPath = value;
        }
 
        public IXmppServerPersistenceLayer PersistenceLayer => this.persistenceLayer;
 
        public void Dispose()
        {
            this.disposed = true;
 
            if (!(this.httpServer is null))
            {
                this.httpServer.Unregister(this.requestWhiteList);
                this.requestWhiteList = null;
            }
 
            if (!(this.smtpServer is null))
                this.smtpServer.MessageReceived -= this.SmtpServer_MessageReceived;
 
            this.secondTimer?.Dispose();
            this.secondTimer = null;
 
            this.s2sEndpoints?.Clear();
            this.s2sEndpoints?.Dispose();
            this.s2sEndpoints = null;
 
            this.clientConnections?.Clear();
            this.clientConnections?.Dispose();
            this.clientConnections = null;
 
            this.sniffers?.Clear();
            this.sniffers?.Dispose();
            this.sniffers = null;
 
            this.shortTermCache?.Clear();
            this.shortTermCache?.Dispose();
            this.shortTermCache = null;
 
            if (!(this.componentsBySubdomain is null))
            {
                foreach (IComponent Component in this.componentsStatic)
                    Component.Dispose();
 
                this.componentsBySubdomain.Clear();
                this.componentsByFulldomain.Clear();
                this.componentsStatic = Array.Empty<IComponent>();
            }
 
            this.accounts?.Dispose();
            this.accounts = null;
 
            this.services?.Dispose();
            this.services = null;
 
            this.responses.Dispose();
 
            if (!(this.c2sListeners is null))
            {
                LinkedList<TcpListener> Listeners = this.c2sListeners;
                this.c2sListeners = null;
 
                foreach (TcpListener Listener in Listeners)
                    Listener.Stop();
            }
 
            if (!(this.s2sListeners is null))
            {
                LinkedList<TcpListener> Listeners = this.s2sListeners;
                this.s2sListeners = null;
 
                foreach (TcpListener Listener in Listeners)
                    Listener.Stop();
            }
 
            if (!(this.c2sSniffers is null))
            {
                foreach (ISniffer Sniffer in this.c2sSniffers)
                    (Sniffer as IDisposable)?.Dispose();
            }
 
            if (!(this.s2sSniffers is null))
            {
                foreach (ISniffer Sniffer in this.s2sSniffers)
                    (Sniffer as IDisposable)?.Dispose();
            }
        }
 
        public bool Disposed => this.disposed;
 
        public int[] OpenC2SPorts
        {
            get
            {
                return this.GetOpenPorts(this.c2sListeners);
            }
        }
 
        public int[] OpenS2SPorts
        {
            get
            {
                return this.GetOpenPorts(this.s2sListeners);
            }
        }
 
        public IComponent[] Components => this.componentsStatic;
 
        private int[] GetOpenPorts(LinkedList<TcpListener> Listeners)
        {
            SortedDictionary<int, bool> Open = new SortedDictionary<int, bool>();
 
            if (!(Listeners is null))
            {
                IPEndPoint IPEndPoint;
 
                foreach (TcpListener Listener in Listeners)
                {
                    IPEndPoint = Listener.LocalEndpoint as IPEndPoint;
                    if (!(IPEndPoint is null))
                        Open[IPEndPoint.Port] = true;
                }
            }
 
            int[] Result = new int[Open.Count];
            Open.Keys.CopyTo(Result, 0);
 
            return Result;
        }
 
        #endregion
 
        #region Components
 
        public bool RegisterComponent(IComponent Component)
        {
            lock (this.synchObject)
            {
                if (this.componentsBySubdomain.ContainsKey(Component.Subdomain))
                    return false;
 
                this.componentsBySubdomain[Component.Subdomain] = Component;
                this.componentsByFulldomain[Component.Subdomain + "." + this.domain] = Component;
 
                foreach (CaseInsensitiveString cis in this.alternativeDomains)
                    this.componentsByFulldomain[Component.Subdomain + "." + cis] = Component;
 
                this.RebuildComponentsStaticLocked();
            }
 
            return true;
        }
 
        private void RebuildComponentsStaticLocked()
        {
            IComponent[] Static = new IComponent[this.componentsBySubdomain.Count];
            this.componentsBySubdomain.Values.CopyTo(Static, 0);
 
            this.componentsStatic = Static;
        }
 
        public bool UnregisterComponent(IComponent Component)
        {
            bool Result = false;
 
            lock (this.synchObject)
            {
                if (this.componentsBySubdomain.TryGetValue(Component.Subdomain, out IComponent Component2) &&
                    Component == Component2)
                {
                    Result = this.componentsBySubdomain.Remove(Component.Subdomain);
 
                    if (Result)
                    {
                        this.componentsByFulldomain.Remove(Component.Subdomain + "." + this.domain);
 
                        foreach (CaseInsensitiveString cis in this.alternativeDomains)
                            this.componentsByFulldomain.Remove(Component.Subdomain + "." + cis);
 
                        this.RebuildComponentsStaticLocked();
                    }
                }
            }
 
            return Result;
        }
 
        #endregion
 
        #region Connections
 
        private void AcceptTcpClientCallback(IAsyncResult ar)
        {
            try
            {
                if (this.disposed ||
                    !(ar?.AsyncState is object[] P) ||
                    P.Length < 2 ||
                    !(P[0] is TcpListener Listener) ||
                    !(P[1] is bool S2S) ||
                    NetworkingModule.Stopping)
                {
                    return;
                }
 
                try
                {
                    TcpClient Client = Listener.EndAcceptTcpClient(ar);
                    ICommunicationLayer ComLayer;
 
                    TextTcpClient TextTcpClient = new TextTcpClient(Client, encoding, false, true);
                    TextTcpClient.Bind(true);
 
                    if (S2S)
                    {
                        XmppS2SEndpoint Endpoint = new XmppS2SEndpoint(TextTcpClient, 
                            this.serverCertificate, this, false, new InMemorySniffer("XMPP S2S In-memory Sniffer"));
                        ComLayer = Endpoint;
 
                        Task.Run(async () =>
                        {
                            await this.S2sEndpointCreated.Raise(this, new XmppS2SEndpointEventArgs(Endpoint));
                        });
                    }
                    else
                    {
                        ISniffer[] Sniffers;
 
                        if (!string.IsNullOrEmpty(this.clientSnifferPath))
                            Sniffers = new ISniffer[] { new InMemorySniffer("XMPP S2S In-memory Sniffer") };
                        else if (this.c2sSniffers.HasSniffers)
                            Sniffers = this.c2sSniffers.Sniffers;
                        else
                            Sniffers = Array.Empty<ISniffer>();
 
                        ComLayer = new XmppClientConnection(TextTcpClient, this, Sniffers);
                    }
 
                    TextTcpClient.Continue();
 
                    ComLayer.Information("Connection accepted from " + TextTcpClient.RemoteEndPoint + ".");
                }
                finally
                {
                    if (!this.disposed)
                        Listener.BeginAcceptTcpClient(this.AcceptTcpClientCallback, P);
                }
            }
            catch (SocketException)
            {
                // Ignore
            }
            catch (ObjectDisposedException)
            {
                // Ignore
            }
            catch (NullReferenceException)
            {
                // Ignore
            }
            catch (Exception ex)
            {
                if (this.c2sListeners is null)
                    return;
 
                Log.Exception(ex);
            }
        }
 
        internal string GetTransformPath(bool S2S)
        {
            foreach (ISniffer Sniffer in S2S ? this.s2sSniffers.Sniffers : this.c2sSniffers.Sniffers)
            {
                if (Sniffer is XmlFileSniffer XmlFileSniffer)
                    return XmlFileSniffer.Transform;
            }
 
            return null;
        }
 
        public string GetDialbackKey(string ReceivingServer, string OriginatingServer, string ReceivingStreamId)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(ReceivingServer);
            sb.Append(' ');
            sb.Append(OriginatingServer);
            sb.Append(' ');
            sb.Append(ReceivingStreamId);
 
            byte[] Bin = Encoding.UTF8.GetBytes(sb.ToString());
            string Key = Hashes.ComputeHMACSHA256HashString(this.sha256DialbackSecret, Bin);
 
            return Key;
        }
 
        #endregion
 
        #region Accounts
 
        internal Task<IAccount> GetAccount(CaseInsensitiveString UserName)
        {
            return this.persistenceLayer.GetAccount(UserName);
        }
 
        internal bool TryGetConnection(CaseInsensitiveString FullJid, out IClientConnection Connection)
        {
            return this.clientConnections.TryGetValue(FullJid, out Connection);
        }
 
        internal bool TouchClientConnection(CaseInsensitiveString FullJid)
        {
            return this.clientConnections?.ContainsKey(FullJid) ?? false;
        }
 
        internal bool TouchServerConnection(CaseInsensitiveString Domain)
        {
            return this.s2sEndpoints?.ContainsKey(Domain) ?? false;
        }
 
        internal async Task<bool> RegisterFullJid(CaseInsensitiveString FullJid, IClientConnection Connection)
        {
            if (this.clientConnections.TryGetValue(FullJid, out IClientConnection Connection2))
            {
                if (!Connection2.CheckLive())
                    this.clientConnections.Remove(FullJid);
                else
                    return false;
            }
 
            this.clientConnections[FullJid] = Connection;
 
            CaseInsensitiveString BareJid = GetBareJID(FullJid);
 
            lock (this.connectionsPerBareJid)
            {
                if (!this.connectionsPerBareJid.TryGetValue(BareJid, out List<IClientConnection> Connections))
                {
                    Connections = new List<IClientConnection>();
                    this.connectionsPerBareJid[BareJid] = Connections;
                }
 
                Connections.Add(Connection);
            }
 
            await this.ClientConnectionAdded.Raise(this, new ClientConnectionEventArgs(FullJid, Connection));
 
            return true;
        }
 
        public event EventHandlerAsync<ClientConnectionEventArgs> ClientConnectionAdded = null;
 
        public event EventHandlerAsync<ClientConnectionEventArgs> ClientConnectionUpdated = null;
 
        public event EventHandlerAsync<ClientConnectionEventArgs> ClientConnectionRemoved = null;
 
        public event EventHandlerAsync<ServerConnectionEventArgs> ServerConnectionAdded = null;
 
        public event EventHandlerAsync<ServerConnectionEventArgs> ServerConnectionUpdated = null;
 
        public event EventHandlerAsync<ServerConnectionEventArgs> ServerConnectionRemoved = null;
 
        internal async Task<CaseInsensitiveString> RegisterBareJid(CaseInsensitiveString BareJid, IClientConnection Connection)
        {
            CaseInsensitiveString FullJid;
 
            do
            {
                FullJid = BareJid + "/" + this.NewId(16);
            }
            while (!this.disposed && this.clientConnections.ContainsKey(FullJid));
 
            if (!this.disposed)
            {
                this.clientConnections[FullJid] = Connection;
 
                lock (this.connectionsPerBareJid)
                {
                    if (!this.connectionsPerBareJid.TryGetValue(BareJid, out List<IClientConnection> Connections))
                    {
                        Connections = new List<IClientConnection>();
                        this.connectionsPerBareJid[BareJid] = Connections;
                    }
 
                    Connections.Add(Connection);
                }
 
                await this.ClientConnectionAdded.Raise(this, new ClientConnectionEventArgs(FullJid, Connection));
            }
 
            return FullJid;
        }
 
        internal void ConnectionClosed(IClientConnection Connection)
        {
            CaseInsensitiveString FullJid = Connection.FullJid;
            CaseInsensitiveString BareJid = Connection.BareJid;
 
            this.clientConnections?.Remove(FullJid);
 
            lock (this.connectionsPerBareJid)
            {
                if (this.connectionsPerBareJid.TryGetValue(BareJid, out List<IClientConnection> Connections))
                {
                    int i, c = Connections.Count;
 
                    for (i = 0; i < c; i++)
                    {
                        if (Connections[i].FullJid == FullJid)
                        {
                            Connections.RemoveAt(i);
                            c--;
 
                            if (c == 0)
                                this.connectionsPerBareJid.Remove(BareJid);
 
                            break;
                        }
                    }
                }
            }
        }
 
        internal IClientConnection[] GetClientConnections(CaseInsensitiveString BareJid)
        {
            lock (this.connectionsPerBareJid)
            {
                if (this.connectionsPerBareJid.TryGetValue(BareJid, out List<IClientConnection> Connections))
                    return Connections.ToArray();
                else
                    return null;
            }
        }
 
        public static CaseInsensitiveString GetBareJID(CaseInsensitiveString JID)
        {
            int i = JID.IndexOf('/');
            if (i > 0)
                return JID.Substring(0, i);
            else
                return JID;
        }
 
        public Task<DateTime?> GetEarliestLoginOpportunity(IClientConnection Connection)
        {
            if (Connection is null)
                return null;
 
            LoginAuditor Auditor = this.persistenceLayer.Auditor;
 
            if (Auditor is null)
                return Task.FromResult<DateTime?>(null);
            else
                return Auditor.GetEarliestLoginOpportunity(Connection.RemoteEndPoint, Connection.Protocol);
        }
 
        internal async Task<bool> Authenticate(string Mechanism, SslStream SslStream, IClientConnection Connection, string Data)
        {
            DateTime? Next = await this.GetEarliestLoginOpportunity(Connection);
 
            if (Next.HasValue)
            {
                StringBuilder sb = new StringBuilder();
                DateTime TP = Next.Value;
                DateTime Today = DateTime.Today;
 
                if (Next.Value == DateTime.MaxValue)
                {
                    sb.Append("This endpoint (");
                    sb.Append(Connection.RemoteEndPoint);
                    sb.Append(") has been blocked from the system.");
                }
                else
                {
                    sb.Append("Too many failed login attempts in a row registered. Try again after ");
                    sb.Append(TP.ToLongTimeString());
 
                    if (TP.Date != Today)
                    {
                        if (TP.Date == Today.AddDays(1))
                            sb.Append(" tomorrow");
                        else
                        {
                            sb.Append(", ");
                            sb.Append(TP.ToShortDateString());
                        }
                    }
 
                    sb.Append(". Remote Endpoint: ");
                    sb.Append(Connection.RemoteEndPoint);
                }
 
                return await Connection.SaslErrorTemporaryAuthFailure(sb.ToString(), "en");
            }
 
            bool Found = false;
 
            foreach (IAuthenticationMechanism M in mechanisms)
            {
                if (M.Name == Mechanism)
                {
                    if (!M.Allowed(SslStream))
                        return await Connection.SaslErrorMechanismTooWeak();
 
                    Connection.SetMechanism(M);
                    Found = true;
 
                    try
                    {
                        bool? AuthResult = await M.AuthenticationRequest(Data, Connection, this.PersistenceLayer);
                        if (AuthResult.HasValue)
                        {
                            if (AuthResult.Value)
                            {
                                if (!await Connection.BeginWrite("<success xmlns='" + SaslNamespace + "'/>", null, null))
                                    return false;
 
                                Connection.ResetState(true);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Connection.Exception(ex);
                        if (!await Connection.StreamErrorInvalidXml())
                            return false;
                    }
                    break;
                }
            }
 
            if (!Found && !await Connection.SaslErrorInvalidMechanism())
                return false;
 
            return true;
        }
 
        #endregion
 
        #region Recipients
 
        public async Task<IRecipient> TryGetRecipient(XmppAddress To, XmppAddress From)
        {
            try
            {
                CaseInsensitiveString ToCI = To?.Address;
 
                if (this.disposed)
                    return null;
 
                if (CaseInsensitiveString.IsNullOrEmpty(ToCI) || this.IsServerDomain(ToCI, true))
                    return this;
 
                if (this.clientConnections.TryGetValue(ToCI, out IClientConnection Connection))
                    return Connection;
 
                if (this.IsServerDomain(To.Domain, true))
                {
                    if (To.IsFullJID)
                        return null;
 
                    if (To.HasAccount)
                    {
                        IAccount Account = await this.persistenceLayer.GetAccount(To.Account);
                        if (Account is null)
                            return null;
                        else
                            return new AccountRecipient(this.accounts, Account);
                    }
                }
 
                IComponent Component;
 
                lock (this.synchObject)
                {
                    if (!this.componentsByFulldomain.TryGetValue(To.Domain, out Component))
                        Component = null;
                }
 
                if (!(Component is null))
                {
                    if (!To.HasAccount || Component.SupportsAccounts)
                        return Component;
                    else
                        return null;
                }
 
                IS2SEndpoint Endpoint = await this.GetS2sEndpoint(From.Domain, To.Domain,
                    true, From.Address + " wants to send a stanza to " + To.Address);
 
                return Endpoint;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return null;
            }
        }
 
        #endregion
 
        #region Stanzas
 
        public void RegisterIqGetHandler(string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler, bool PublishNamespaceAsFeature)
        {
            this.RegisterIqHandler(this.iqGetHandlers, LocalName, Namespace, Handler, PublishNamespaceAsFeature);
        }
 
        public void RegisterIqSetHandler(string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler, bool PublishNamespaceAsFeature)
        {
            this.RegisterIqHandler(this.iqSetHandlers, LocalName, Namespace, Handler, PublishNamespaceAsFeature);
        }
 
        private void RegisterIqHandler(Dictionary<string, EventHandlerAsync<IqEventArgs>> Handlers, string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler,
            bool PublishNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (Handlers.ContainsKey(Key))
                    throw new ArgumentException("Handler already registered.", nameof(LocalName));
 
                Handlers[Key] = Handler;
 
                if (PublishNamespaceAsFeature)
                    this.features[Namespace] = true;
            }
        }
 
        public void RegisterMessageHandler(string LocalName, string Namespace, EventHandlerAsync<MessageEventArgs> Handler, bool PublishNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (this.messageHandlers.ContainsKey(Key))
                    throw new ArgumentException("Handler already registered.", nameof(LocalName));
 
                this.messageHandlers[Key] = Handler;
 
                if (PublishNamespaceAsFeature)
                    this.features[Namespace] = true;
            }
        }
 
        public bool UnregisterIqGetHandler(string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler, bool RemoveNamespaceAsFeature)
        {
            return this.UnregisterIqHandler(this.iqGetHandlers, LocalName, Namespace, Handler, RemoveNamespaceAsFeature);
        }
 
        public bool UnregisterIqSetHandler(string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler, bool RemoveNamespaceAsFeature)
        {
            return this.UnregisterIqHandler(this.iqSetHandlers, LocalName, Namespace, Handler, RemoveNamespaceAsFeature);
        }
 
        private bool UnregisterIqHandler(Dictionary<string, EventHandlerAsync<IqEventArgs>> Handlers, string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler,
            bool RemoveNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (!Handlers.TryGetValue(Key, out EventHandlerAsync<IqEventArgs> h))
                    return false;
 
                if (h != Handler)
                    return false;
 
                Handlers.Remove(Key);
 
                if (RemoveNamespaceAsFeature)
                    this.features.Remove(Namespace);
            }
 
            return true;
        }
 
        public bool UnregisterMessageHandler(string LocalName, string Namespace, EventHandlerAsync<MessageEventArgs> Handler, bool RemoveNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (!this.messageHandlers.TryGetValue(Key, out EventHandlerAsync<MessageEventArgs> h))
                    return false;
 
                if (h != Handler)
                    return false;
 
                this.messageHandlers.Remove(Key);
 
                if (RemoveNamespaceAsFeature)
                    this.features.Remove(Namespace);
            }
 
            return true;
        }
 
        internal async Task<bool> ProcessIq(string Id, XmppAddress To, XmppAddress From, string Type, string Language, Stanza Stanza, ISender Sender)
        {
            IRecipient Recipient = await this.TryGetRecipient(To, From);
 
            if (Recipient is null)
            {
                if (Sender is null)
                    return true;
                else
                {
                    string Message = "Recipient not found: " + To.Address;
 
                    Log.Warning(Message,
                        new KeyValuePair<string, object>("From", From?.Address),
                        new KeyValuePair<string, object>("To", To?.Address));
 
                    return !(await Sender.IqErrorItemNotFound(Id, From, To, Message, "en") is null);
                }
            }
            else if (Recipient is IClientConnection ToConnection &&
                await this.persistenceLayer.IsBlocked(From.BareJid, ToConnection.BareJid))
            {
                return !(await Sender.IqErrorServiceUnavailable(Id, From, To, string.Empty, string.Empty) is null);
            }
            else
                return await Recipient.IQ(Type, Id, To, From, Language, Stanza, Sender);
        }
 
        public async Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            Dictionary<string, EventHandlerAsync<IqEventArgs>> Handlers;
            EventHandlerAsync<IqEventArgs> h = null;
            IqResponse Response;
            string Counter;
            string Key;
            bool Blocked = await this.persistenceLayer.IsBlocked(From.BareJid, To.BareJid);
 
            switch (Type)
            {
                case "get":
                    if (this.responses.TryGet(From.Address, Id, true, out Response, out bool Created))
                    {
                        if (!Created)
                        {
                            KeyValuePair<string, bool> P = await Response.GetResponse();
 
                            if (P.Value)
                                return await Sender.IqResult(Id, From, To, P.Key);
                            else
                                return await Sender.IqError(Id, From, To, P.Key);
                        }
                    }
 
                    Handlers = this.iqGetHandlers;
                    Counter = "XMPP.Server.Get";
                    break;
 
                case "set":
                    if (this.responses.TryGet(From.Address, Id, true, out Response, out Created))
                    {
                        if (!Created)
                        {
                            KeyValuePair<string, bool> P = await Response.GetResponse();
 
                            if (P.Value)
                                return await Sender.IqResult(Id, From, To, P.Key);
                            else
                                return await Sender.IqError(Id, From, To, P.Key);
                        }
                    }
 
                    Handlers = this.iqSetHandlers;
                    Counter = "XMPP.Server.Set";
                    break;
 
                case "result":
                case "error":
                    if (Blocked)
                        return true;
 
                    return await this.ProcessResponse(Type, Id, To, From, Language, true, false, Stanza, Sender);
 
                default:
                    if (Sender is null)
                        return true;
                    else
                        return !(await Sender.IqErrorBadRequest(Id, From, To, "Invalid type.", "en") is null);
            }
 
            IqEventArgs e = new IqEventArgs(Sender, Stanza.StanzaElement, Id, Type, To, From, Language, Response);
 
            if (Blocked)
            {
                if (Sender is null)
                {
                    Response.SetResult(string.Empty, false);
                    return false;
                }
                else
                {
                    string ErrorXml = await Sender.IqErrorServiceUnavailable(Id, From, To, string.Empty, string.Empty);
                    Response.SetResult(ErrorXml, false);
                    return !(ErrorXml is null);
                }
            }
 
            lock (this.synchObject)
            {
                foreach (XmlNode N in Stanza.StanzaElement.ChildNodes)
                {
                    if (!(N is XmlElement E))
                        continue;
 
                    Key = E.LocalName + " " + E.NamespaceURI;
                    if (Handlers.TryGetValue(Key, out h))
                    {
                        Counter += "." + E.LocalName;
                        e.Query = E;
                        break;
                    }
                    else
                        h = null;
                }
            }
 
            if (h is null)
            {
                if (Sender is null)
                {
                    Response.SetResult(string.Empty, false);
                    return false;
                }
                else
                {
                    string ErrorXml = await Sender.IqError(Id, From, To, "cancel", "<feature-not-implemented xmlns='" + StanzaNamespace + "'/>", string.Empty, string.Empty);
                    Response.SetResult(ErrorXml, false);
                    return !(ErrorXml is null);
                }
            }
 
            try
            {
                await RuntimeCounters.IncrementCounter(Counter);
                await h(this, e);
                return true;
            }
            catch (Exception ex)
            {
                if (Sender is null)
                {
                    Response.SetResult(string.Empty, false);
                    return false;
                }
                else
                {
                    string ErrorXml = await Sender.IqError(Id, From, To, ex);
                    Response.SetResult(ErrorXml, false);
                    return !(ErrorXml is null);
                }
            }
        }
 
        internal async Task<bool> ProcessResponse(string Type, string Id, XmppAddress To, XmppAddress From, string Language,
            bool IqResponse, bool PresenceResponse, Stanza Stanza, ISender Sender)
        {
            if (!string.IsNullOrEmpty(Id))
            {
                PendingRequest Rec = null;
                bool Ok = Type == "result";
 
                lock (this.synchObject)
                {
                    if (this.pendingRequestsById.TryGetValue(Id, out Rec))
                    {
                        this.pendingRequestsById.Remove(Id);
                        this.pendingRequestsByTimeout.Remove(Rec.Timeout);
                    }
                    else
                        Rec = null;
                }
 
                if (!(Rec is null))
                {
                    if (IqResponse)
                    {
                        IqResultEventArgs e = new IqResultEventArgs(Stanza.StanzaElement, Id, To, From, Language, Ok, Rec.State);
                        if (!(Rec.ShortTermCacheKey is null))
                            this.shortTermCache[Rec.ShortTermCacheKey] = e;
 
                        await Rec.IqCallback.Raise(this, e);
                    }
 
                    if (PresenceResponse)
                    {
                        PresenceEventArgs e = new PresenceEventArgs(Sender, Type, Id, To, From, Language, Stanza, Rec.State);
                        await Rec.PresenceCallback.Raise(this, e);
                    }
                }
            }
 
            return true;
        }
 
        public Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.IQ(Type, Id, To, From, Language, ToStanza("iq", Type, Id, To, From, Language, ContentXml), Sender);
        }
 
        internal static Stanza ToStanza(string StanzaType, string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            StringBuilder Xml = new StringBuilder();
            StringBuilder Xml2 = new StringBuilder();
            int ContentStart, ContentLen;
 
            Xml.Append("<stream:stream to='");
            Xml.Append(XML.Encode(To.Domain));
            Xml.Append("' from='");
            Xml.Append(XML.Encode(From.Domain));
            Xml.Append("' version='1.0' xml:lang='");
            Xml.Append(XML.Encode(Language));
            Xml.Append("' xmlns='jabber:server' xmlns:stream='");
            Xml.Append(XmppClientConnection.StreamNamespace);
            Xml.Append("'>");
 
            Xml2.Append('<');
            Xml2.Append(StanzaType);
 
            if (!string.IsNullOrEmpty(Type))
            {
                Xml2.Append(" type='");
                Xml2.Append(Type);
                Xml2.Append('\'');
            }
 
            if (!string.IsNullOrEmpty(Id))
            {
                Xml2.Append(" id='");
                Xml2.Append(XML.Encode(Id));
                Xml2.Append('\'');
            }
 
            if (!From.IsEmpty)
            {
                Xml2.Append(" from='");
                Xml2.Append(XML.Encode(From.Address));
                Xml2.Append('\'');
            }
 
            if (!To.IsEmpty)
            {
                Xml2.Append(" to='");
                Xml2.Append(XML.Encode(To.Address));
                Xml2.Append('\'');
            }
 
            if (!string.IsNullOrEmpty(Language))
            {
                Xml2.Append(" xml:lang='");
                Xml2.Append(XML.Encode(Language));
                Xml2.Append('\'');
            }
 
            if (string.IsNullOrEmpty(ContentXml))
            {
                Xml2.Append("/>");
                ContentStart = ContentLen = 0;
            }
            else
            {
                Xml2.Append('>');
 
                ContentStart = Xml2.Length;
                ContentLen = ContentXml.Length;
 
                Xml2.Append(ContentXml);
                Xml2.Append("</");
                Xml2.Append(StanzaType);
                Xml2.Append('>');
            }
 
            string s = Xml2.ToString();
 
            Xml.Append(s);
            Xml.Append("</stream:stream>");
 
            try
            {
                XmlDocument Doc = XML.ParseXml(Xml.ToString(), true);
 
                return new Stanza(Doc.DocumentElement, s, ContentStart, ContentLen);
            }
            catch (Exception ex)
            {
                throw new Exception("Invalid XML:\r\n\r\n" + ex.Message + "\r\n\r\n" + Xml.ToString());
            }
        }
 
        public async Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            bool ToLocal = this.IsServerDomain(To.Domain, true);
 
            if (ToLocal)
            {
                if (await this.persistenceLayer.IsBlocked(From.BareJid, To.BareJid))
                    return await (Sender?.MessageErrorServiceUnavailable(From, To, string.Empty, string.Empty) ?? Task.FromResult(true));
                else if (await this.persistenceLayer.IsBlocked(To.BareJid, From.BareJid))
                {
                    return await Sender.Message("error", Id, From, To, string.Empty, "<error type='cancel'><not-acceptable xmlns='" + StanzaNamespace +
                        "'/><blocked xmlns='" + BlockingCommandErrorNamespace + "'/></error>");
                }
                else
                {
                    if (To.IsBareJID)
                    {
                        IClientConnection[] Connections = this.GetClientConnections(To.BareJid);
 
                        if (!(Connections is null) && Connections.Length > 0)
                        {
                            bool Forwarded = false;
 
                            foreach (IClientConnection Connection in Connections)
                            {
                                try
                                {
                                    if (await Connection.Message(Type, Id, To, From, Language, Stanza, Sender))
                                        Forwarded = true;
                                }
                                catch (Exception ex)
                                {
                                    try
                                    {
                                        Connection.Exception(ex);
                                        await Connection.DisposeAsync();
                                    }
                                    catch (Exception ex2)
                                    {
                                        Log.Exception(ex2);
                                    }
                                }
                            }
 
                            if (Forwarded)
                                return true;
                        }
 
                        if (string.IsNullOrEmpty(Type) || Type == "normal" || Type == "chat")
                        {
                            if (await this.persistenceLayer.StoreOfflineMessage(Type, Id, To, From, Language, Stanza))
                            {
                                if (Sender is ICommunicationLayer ComLayer)
                                    ComLayer.Information("Message stored for later delivery.");
                            }
                            else
                                return await (Sender?.MessageErrorServiceUnavailable(From, To, string.Empty, string.Empty) ?? Task.FromResult(true));
                        }
                    }
                    else if (To.IsDomain)
                    {
                        EventHandlerAsync<MessageEventArgs> h = null;
                        MessageEventArgs e = null;
                        string Counter = "XMPP.Server.Message";
                        
                        lock (this.synchObject)
                        {
                            foreach (XmlNode N in Stanza.StanzaElement.ChildNodes)
                            {
                                if (!(N is XmlElement E))
                                    continue;
 
                                string Key = E.LocalName + " " + E.NamespaceURI;
                                if (this.messageHandlers.TryGetValue(Key, out h))
                                {
                                    Counter += "." + E.LocalName;
 
                                    e = new MessageEventArgs(Sender, Stanza.StanzaElement, Id, Type,
                                        To, From, Language)
                                    {
                                        Content = E
                                    };
                                    break;
                                }
                                else
                                    h = null;
                            }
                        }
 
                        if (!(h is null))
                        {
                            try
                            {
                                await RuntimeCounters.IncrementCounter(Counter);
                                await h(this, e);
                                return true;
                            }
                            catch (Exception ex)
                            {
                                return await (Sender?.MessageError(Id, From, To, ex) ?? Task.FromResult(true));
                            }
                        }
                    }
                    else
                    {
                        if (this.TryGetConnection(To.Address, out IClientConnection Connection))
                        {
                            bool Forwarded = false;
 
                            try
                            {
                                Forwarded = await Connection.Message(Type, Id, To, From, Language, Stanza, Sender);
                            }
                            catch (Exception ex)
                            {
                                Connection.Exception(ex);
                                await Connection.DisposeAsync();
                            }
 
                            if (Forwarded)
                                return true;
                        }
 
                        return await (Sender?.MessageErrorServiceUnavailable(From, To, string.Empty, string.Empty) ?? Task.FromResult(true));
                    }
                }
 
                return true;
            }
            else
            {
                IComponent Component;
 
                lock (this.synchObject)
                {
                    if (!this.componentsByFulldomain.TryGetValue(To.Domain, out Component))
                        Component = null;
                }
 
                if (!(Component is null))
                {
                    if (!To.HasAccount || Component.SupportsAccounts)
                        return await Component.Message(Type, Id, To, From, Language, Stanza, Sender);
                }
 
                IS2SEndpoint Endpoint;
 
                try
                {
                    Endpoint = await this.GetS2sEndpoint(From.Domain, To.Domain, true, "Sending message from " + From.Address + " to " + To.Address);
                    if (Endpoint is null)
                        return true;
                }
                catch (Exception ex)
                {
                    if (!(Sender is null))
                        return await (Sender?.MessageErrorServiceUnavailable(From, To, ex.Message, string.Empty) ?? Task.FromResult(true));
 
                    return true;
                }
 
                return await Endpoint.Message(Type, Id, To, From, Language, Stanza, Sender);
            }
        }
 
        public static void RegisterRemoteDomain(CaseInsensitiveString RemoteDomain, string Host, int Port, bool TrustCertificate)
        {
            lock (remoteDomainLookup)
            {
                remoteDomainLookup[RemoteDomain] = new S2SRec()
                {
                    Domain = RemoteDomain,
                    Host = Host,
                    Port = Port,
                    TrustCertificate = TrustCertificate
                };
            }
        }
 
        public static void RegisterRemoteDomain(CaseInsensitiveString RemoteDomain, CaseInsensitiveString ServerDomain, string Host, int Port, bool TrustCertificate)
        {
            lock (remoteDomainLookup)
            {
                remoteDomainLookup[RemoteDomain] = new S2SRec()
                {
                    Domain = ServerDomain,
                    Host = Host,
                    Port = Port,
                    TrustCertificate = TrustCertificate
                };
            }
        }
 
        public static bool IsRemoteDomainRegistered(CaseInsensitiveString RemoteDomain)
        {
            lock (remoteDomainLookup)
            {
                return remoteDomainLookup.ContainsKey(RemoteDomain);
            }
        }
 
        internal async void RegisterS2SEndpoint(IS2SEndpoint Endpoint)
        {
            CaseInsensitiveString Domain = Endpoint.RemoteDomain;
            EndpointStatistics Stat = this.GetS2sStatistics(Domain, Endpoint.Type);
            EventHandlerAsync<ServerConnectionEventArgs> h;
 
            Stat.EndpointConnected(Endpoint);
 
            if (this.s2sEndpoints?.TryGetValue(Domain, out IS2SEndpoint Prev) ?? false)
            {
#if LogToWebHookTester
                // TODO: Remove
                _ = Task.Run(async () =>
                {
                    try
                    {
                        await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.domain.Value),
                            new Dictionary<string, object>()
                            {
                                { "id_prev", Prev.Id.ToString() },
                                { "id_updated", Endpoint.Id.ToString() },
                                { "event", "RegisterS2SEndpoint" },
                                { "remote", Domain.Value },
                                { "prev", JSON.Encode(Prev, true) },
                                { "updated", JSON.Encode(Endpoint, true) },
                                { "reason", "Updating" }
                            },
                            new KeyValuePair<string, string>("Accept", "application/json"));
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                });
#endif
                h = this.ServerConnectionUpdated;
 
                if (Prev != Endpoint)
                    this.s2sEndpoints[Domain] = Endpoint;
 
                await h.Raise(this, new ServerConnectionEventArgs(Domain, Endpoint));
 
                if (Prev == Endpoint)
                    return;
            }
            else
            {
                h = this.ServerConnectionAdded;
 
                this.s2sEndpoints?.Add(Domain, Endpoint);
 
#if LogToWebHookTester
                // TODO: Remove
                _ = Task.Run(async () =>
                {
                    try
                    {
                        await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.domain.Value),
                            new Dictionary<string, object>()
                            {
                                { "id", Endpoint.Id.ToString() },
                                { "event", "RegisterS2SEndpoint" },
                                { "remote", Domain?.Value },
                                { "value", JSON.Encode(Endpoint, true) },
                                { "reason", "Registering" }
                            },
                            new KeyValuePair<string, string>("Accept", "application/json"));
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                });
#endif
                await h.Raise(this, new ServerConnectionEventArgs(Domain, Endpoint));
            }
 
            if (Endpoint is XmppS2SEndpoint XmppS2SEndpoint)
                XmppS2SEndpoint.OnStateChanged += this.Endpoint_OnStateChanged;
        }
 
        private async Task Endpoint_OnStateChanged(object Sender, EventArgs e)
        {
            if (Sender is XmppS2SEndpoint Endpoint)
                await this.ServerConnectionUpdated.Raise(this, new ServerConnectionEventArgs(Endpoint.RemoteDomain, Endpoint));
        }
 
        public bool TryGetS2sEndpoint(string RemoteDomain, out IS2SEndpoint Endpoint)
        {
            return this.s2sEndpoints.TryGetValue(RemoteDomain, out Endpoint);
        }
 
        internal void RegisterAsTemporary(IS2SEndpoint Endpoint)
        {
            lock (this.synchObject)
            {
                this.temporaryConnections ??= new SortedDictionary<DateTime, IS2SEndpoint>();
 
                DateTime TP = DateTime.Now.AddMinutes(1);
 
                while (this.temporaryConnections.ContainsKey(TP))
                    TP = TP.AddTicks(this.gen.Next(10));
 
                this.temporaryConnections[TP] = Endpoint;
            }
        }
 
        internal static async Task<S2SRec> GetDomainFromDns(CaseInsensitiveString DomainName)
        {
            S2SRec Result;
            string SrvMsg;
 
            try
            {
                SRV SRV = await DnsResolver.TryLookupServiceEndpoint(DomainName, "xmpp-server", "tcp");
                if (SRV is null)
                    SrvMsg = "Unable to get SRV record for xmpp-server/tcp of " + DomainName;
                else
                {
                    Result = new S2SRec()
                    {
                        Domain = DomainName,
                        Host = SRV.TargetHost,
                        Port = SRV.Port,
                        TrustCertificate = false,
                        Type = S2sType.XMPP
                    };
 
                    return Result;
                }
            }
            catch (Exception ex)
            {
                SrvMsg = ex.Message;
            }
 
            try
            {
                string[] Hosts = await DnsResolver.TryLookupMailExchange(DomainName);
                if (!(Hosts is null) && Hosts.Length > 0 && !string.IsNullOrEmpty(Hosts[0]))
                {
                    try
                    {
                        using TcpClient TestClient = new TcpClient();
 
                        await TestClient.ConnectAsync(DomainName, DefaultS2sPort);
 
                        Log.Notice("Federated XMPP server connection. SRV DNS settings not found: " + SrvMsg, DomainName);
 
                        Result = new S2SRec()
                        {
                            Domain = DomainName,
                            Host = DomainName,
                            Port = DefaultS2sPort,
                            TrustCertificate = false,
                            Type = S2sType.XMPP
                        };
 
                        return Result;
                    }
                    catch (Exception)
                    {
                        // Ignore. Just a test to check for XMPP if DNS settings not available or incorrect.
                    }
 
                    Log.Notice("Federated mail server connection. XMPP server not found: " + SrvMsg, DomainName);
 
                    Result = new S2SRec()
                    {
                        Domain = DomainName,
                        Host = Hosts[0],
                        Port = SmtpServer.DefaultSmtpPort,
                        TrustCertificate = false,
                        Type = S2sType.SMTP
                    };
 
                    return Result;
                }
            }
            catch (Exception)
            {
                // Ignore
            }
 
            return null;
        }
 
        public static async Task<S2SRec> GetDomain(CaseInsensitiveString DomainOrSubdomain)
        {
            S2SRec Result;
 
            lock (remoteDomainLookup)
            {
                if (remoteDomainLookup.TryGetValue(DomainOrSubdomain, out Result))
                    return Result;
            }
 
            Result = await GetDomainFromDns(DomainOrSubdomain);
            if (!(Result is null))
            {
                if (Result.Type == S2sType.XMPP && Result.Domain.EndsWith("." + Result.Host))
                    Result.Domain = Result.Host;    // Component
 
                lock (remoteDomainLookup)
                {
                    remoteDomainLookup[DomainOrSubdomain] = Result;
                }
 
                return Result;
            }
 
            CaseInsensitiveString[] Parts = DomainOrSubdomain.Split('.');
            if (Parts.Length < 2)
                throw new Exception("Invalid domain or subdomain name: " + DomainOrSubdomain);
 
            int c = Parts.Length;
            int i = c - 2;
            CaseInsensitiveString Domain = Parts[i] + "." + Parts[i + 1];
            S2SRec Rec;
 
            while (i >= 0)
            {
                Rec = null;
 
                if (Domain != DomainOrSubdomain)
                {
                    Rec = await GetDomainFromDns(Domain);
                    if (!(Rec is null))
                        Result = Rec;
                }
 
                if (Rec is null)
                {
                    try
                    {
                        IPHostEntry Entry = await System.Net.Dns.GetHostEntryAsync(Domain);
                        if (Entry.AddressList.Length > 0)
                        {
                            using (TcpClient TestClient = new TcpClient())
                            {
                                await TestClient.ConnectAsync(Domain, DefaultS2sPort);
                                TestClient.Close();
                            }
 
                            Result = Rec = new S2SRec()
                            {
                                Domain = Domain,
                                Host = Domain,
                                Port = DefaultS2sPort,
                                Type = S2sType.XMPP,
                                TrustCertificate = false
                            };
                        }
                    }
                    catch (Exception)
                    {
                        // Subdomains might not be registered in DNS.
                    }
                }
 
                i--;
                if (i >= 0)
                    Domain = Parts[i] + "." + Domain;
 
                if (Rec is null && !(Result is null) && Result.Type == S2sType.XMPP)
                    break;
            }
 
            if (!(Result is null))
            {
                lock (remoteDomainLookup)
                {
                    remoteDomainLookup[DomainOrSubdomain] = Result;
                }
 
                return Result;
            }
 
            throw new Exception("Invalid S2S domain or subdomain name: " + DomainOrSubdomain);
        }
 
        public enum S2sType
        {
            XMPP,
 
            SMTP
        }
 
        public class S2SRec
        {
            public S2sType Type;
 
            public CaseInsensitiveString Domain;
 
            public CaseInsensitiveString Host;
 
            public int Port;
 
            public bool TrustCertificate;
        }
 
        internal async Task<IS2SEndpoint> GetS2sEndpoint(CaseInsensitiveString LocalDomain,
            CaseInsensitiveString RemoteDomain, bool ReuseExisting, string Reason)
        {
            XmppS2SEndpoint XmppS2SEndpoint;
            CaseInsensitiveString Host;
            S2SRec Rec;
            S2sType Type;
            int Port;
            bool RecFound;
            bool TrustCertificate;
 
            if (this.disposed)
                return null;
 
            lock (remoteDomainLookup)
            {
                RecFound = remoteDomainLookup.TryGetValue(RemoteDomain, out Rec);
            }
 
            if (!RecFound)
                Rec = await GetDomain(RemoteDomain);
 
            RemoteDomain = Rec.Domain;
            Host = Rec.Host;
            Port = Rec.Port;
            TrustCertificate = Rec.TrustCertificate;
            Type = Rec.Type;
 
            if (this.IsServerDomain(RemoteDomain, true))    // Non-existing sub-domain pointing to itself, creating loop.
                return null;
 
            using Runtime.Threading.Semaphore S2sSemaphore = await Semaphores.BeginWrite("s2s:" + RemoteDomain.LowerCase);
 
            QueuedStanza[] QueuedStanzas = null;
 
            if (ReuseExisting && this.s2sEndpoints.TryGetValue(RemoteDomain, out IS2SEndpoint Existing))
            {
                if (!((XmppS2SEndpoint = Existing as XmppS2SEndpoint) is null) &&
                    XmppS2SEndpoint.IsStale)
                {
                    Log.Informational("Removes stale S2S connection.", RemoteDomain, string.Empty, "XmppStaleS2s");
 
#if LogToWebHookTester
                    // TODO: Remove
                    _ = Task.Run(async () =>
                    {
                        try
                        {
                            await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.domain.Value),
                                new Dictionary<string, object>()
                                {
                                    { "id", Existing.Id.ToString() },
                                    { "event", "Removing stale S2S endpoint" },
                                    { "remote", RemoteDomain.Value },
                                    { "value", JSON.Encode(Existing, true) },
                                    { "reason", "Getting" },
                                    { "state", XmppS2SEndpoint.State },
                                    { "created", XmppS2SEndpoint.CreationTimeUtc.ToString() },
                                    { "connect", XmppS2SEndpoint.ConnectTimeUtc.ToString() },
                                    { "connected", XmppS2SEndpoint.ConnectedTimeUtc.ToString() },
                                },
                                new KeyValuePair<string, string>("Accept", "application/json"));
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    });
#endif
                    QueuedStanzas = XmppS2SEndpoint.GetAndClearQueuedStanzas();
                    await this.s2sEndpoints.RemoveAsync(RemoteDomain);  // Disposes the endpoint.
                }
                else
                    return Existing;
            }
 
            IS2SEndpoint Result;
 
            switch (Type)
            {
                case S2sType.XMPP:
                    if (this.HasDomain || RecFound)
                    {
                        Log.Informational("Opening S2S connection. " + Reason, RemoteDomain, string.Empty, "XmppOpenS2s");
 
                        if (!this.IsServerDomain(LocalDomain, true))
                        {
                            int i = LocalDomain.IndexOf('.');
                            if (i > 0)
                            {
                                CaseInsensitiveString s = LocalDomain.Substring(i + 1);
                                if (this.IsServerDomain(s, true))
                                    LocalDomain = s;
                            }
                        }
 
                        XmppS2SEndpoint = new XmppS2SEndpoint(LocalDomain, RemoteDomain,
                            Port, this.serverCertificate, this, TrustCertificate,
                            !ReuseExisting, QueuedStanzas);
 
                        await this.S2sEndpointCreated.Raise(this, new XmppS2SEndpointEventArgs(XmppS2SEndpoint));
 
                        Result = XmppS2SEndpoint;
 
                        this.AddS2SSniffers(Result, RemoteDomain);
 
                        XmppS2SEndpoint.Information("Opening S2S connection to " + Host + ". " + Reason);
 
#if LogToWebHookTester
                        // TODO: Remove
                        _ = Task.Run(async () =>
                        {
                            try
                            {
                                await InternetContent.PostAsync(new Uri("https://lab.tagroot.io/WebHookTester/Show.ws?ID=" + this.domain.Value),
                                    new Dictionary<string, object>()
                                    {
                                        { "id", XmppS2SEndpoint.Id.ToString() },
                                        { "event", "Creating S2S endpoint" },
                                        { "remote", RemoteDomain.Value },
                                        { "value", JSON.Encode(XmppS2SEndpoint, true) },
                                        { "reason", "Getting" }
                                    },
                                    new KeyValuePair<string, string>("Accept", "application/json"));
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                            }
                        });
#endif
                        _ = Task.Run(async () =>
                        {
                            try
                            {
                                await XmppS2SEndpoint.Connect(Host, false);
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                            }
                        });
                    }
                    else
                    {
                        ParentConnectionEventArgs e = new ParentConnectionEventArgs();
 
                        await this.GetParentConnection.Raise(this, e);
 
                        if (e.Client is null)
                            throw new NotSupportedException("S2S connections not supported. No domain or certificate defined, and no parent client connection available.");
 
                        Log.Informational("Tunneling S2S connection over client connection to parent. " + Reason, RemoteDomain, string.Empty, "XmppOpenS2sTunnel");
 
                        Result = new XmppS2SOverParentEndpoint(e.Client, LocalDomain, RemoteDomain);
                    }
                    break;
 
                case S2sType.SMTP:
                    if (this.smtpServer is null)
                        throw new NotSupportedException("Integration with SMTP not enabled.");
 
                    Result = new SmtpS2SEndpoint(LocalDomain, RemoteDomain, this.smtpServer, this);
 
                    if (ReuseExisting)
                        scheduler.Add(DateTime.Now.AddMinutes(10), this.RemoveSmtpConnection, Result);
                    break;
 
                default:
                    throw new NotSupportedException("S2S Connection type not supported: " + Type.ToString());
            }
 
            if (ReuseExisting)
                this.RegisterS2SEndpoint(Result);
            else
                this.RegisterAsTemporary(Result);
 
            return Result;
        }
 
        public event EventHandlerAsync<XmppS2SEndpointEventArgs> S2sEndpointCreated;
 
        public event EventHandlerAsync<XmppS2SEndpointEventArgs> S2sEndpointRemoved;
 
        private Task RemoveSmtpConnection(object State)
        {
            if (State is SmtpS2SEndpoint Endpoint)
            {
                lock (remoteDomainLookup)
                {
                    remoteDomainLookup.Remove(Endpoint.RemoteDomain);
                }
 
                this.s2sEndpoints.Remove(Endpoint.RemoteDomain);
            }
 
            return Task.CompletedTask;
        }
 
        public event EventHandlerAsync<ParentConnectionEventArgs> GetParentConnection;
 
        public bool HasDomain
        {
            get
            {
                if (CaseInsensitiveString.IsNullOrEmpty(this.domain) || this.serverCertificate is null)
                    return false;
 
                switch (this.domain.LowerCase)
                {
                    case "localhost":
                    case "example.com":
                    case "example2.com":
                    case "example3.com":
                    case "example.org":
                    case "example2.org":
                    case "example3.org":
                        return false;
 
                    default:
                        return true;
                }
            }
        }
 
        internal void AddS2SSniffers(ICommunicationLayer Endpoint, string RemoteDomain)
        {
            if (!string.IsNullOrEmpty(this.domainSnifferPath))
                Endpoint.Add(this.GetSniffer(RemoteDomain, true));
            else if (this.s2sSniffers.HasSniffers)
            {
                foreach (ISniffer Sniffer in this.s2sSniffers.Sniffers)
                    Endpoint.Add(Sniffer);
            }
        }
 
        internal static bool TrustCertificate(CaseInsensitiveString RemoteDomain)
        {
            lock (remoteDomainLookup)
            {
                if (remoteDomainLookup.TryGetValue(RemoteDomain, out S2SRec Rec))
                    return Rec.TrustCertificate;
                else
                    return false;
            }
        }
 
        public Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.Message(Type, Id, To, From, Language, ToStanza("message", Type, Id, To, From, Language, ContentXml), Sender);
        }
 
        public async Task<bool> Presence(string Type, string Id, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            if (Sender is IClientConnection FromConnection)
            {
                switch (Type)
                {
                    case "subscribe":
                    case "subscribed":
                    case "unsubscribe":
                    case "unsubscribed":
                        return await (Sender?.PresenceErrorNotAllowed(Id, From, this.domainAddress, string.Empty, string.Empty) ?? Task.FromResult(true));
                }
 
                CaseInsensitiveString FromUserName = FromConnection.UserName;
                IAccount FromAccount = await this.persistenceLayer.GetAccount(FromUserName);
 
                FromConnection.LastPresence = new PresenceEventArgs(Sender, Type, Id, XmppAddress.Empty, From, Language, Stanza, null);
                await this.PushPresence(FromConnection.BareAddress, Type, Id, From, Language, Stanza, false, Sender);
 
                foreach (IRosterItem Item in await this.persistenceLayer.GetRoster(FromUserName))
                {
                    if (Item.BareJid != FromConnection.BareJid &&
                        (Item.Subscription == SubscriptionStatus.both || Item.Subscription == SubscriptionStatus.from))
                    {
                        await this.PushPresence(new XmppAddress(Item.BareJid), Type, Id, From, Language, Stanza, false, Sender);
                    }
                }
 
                await this.ClientConnectionUpdated.Raise(this, new ClientConnectionEventArgs(From.Address, FromConnection));
            }
 
            return true;
        }
 
        public async Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            bool ToLocal = this.IsServerDomain(To.Domain, true);
            IAccount ToAccount = ToLocal ? await this.persistenceLayer.GetAccount(To.Account) : null;
            CaseInsensitiveString FromUserName = null;
            IClientConnection FromConnection = Sender as IClientConnection;
            bool FromLocal = !(FromConnection is null);
            IAccount FromAccount = null;
            PresenceEventArgs LastPresence = null;
            IRosterItem Item;
            bool UseBareJids = false;
 
            if (!string.IsNullOrEmpty(Id))
            {
                PendingRequest Rec = null;
                bool Ok = (Type != "error");
 
                lock (this.synchObject)
                {
                    if (this.pendingRequestsById.TryGetValue(Id, out Rec))
                    {
                        this.pendingRequestsById.Remove(Id);
                        this.pendingRequestsByTimeout.Remove(Rec.Timeout);
                    }
                    else
                        Rec = null;
                }
 
                if (!(Rec?.PresenceCallback is null))
                    await Rec.PresenceCallback.Raise(this, new PresenceEventArgs(Sender, Type, Id, To, From, Language, Stanza, Rec.State));
            }
 
            if (ToLocal && ToAccount is null)
                return await (Sender?.PresenceErrorItemNotFound(Id, From, To, string.Empty, string.Empty) ?? Task.FromResult(true));
 
            if (FromLocal)
            {
                FromUserName = FromConnection.UserName;
                FromAccount = await this.persistenceLayer.GetAccount(FromUserName);
 
                if (FromAccount is null)
                    return await (Sender?.PresenceErrorNotAllowed(Id, From, this.domainAddress, string.Empty, string.Empty) ?? Task.FromResult(true));
            }
 
            switch (Type)
            {
                case "subscribe":
                    if (FromLocal)
                    {
                        if (await this.persistenceLayer.IsBlocked(From.BareJid, To.BareJid))
                            return true;
 
                        Item = await this.persistenceLayer.GetRosterItem(FromUserName, To.BareJid);
 
                        if (!(Item is null))
                        {
                            if (!Item.PendingSubscription)
                                Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, Item.Name, Item.Subscription, true, Item.Groups);
                        }
                        else
                            Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, string.Empty, SubscriptionStatus.none, true, null);
 
                        if (!(Item is null))
                            await this.PushIq(From.BareJid, Item);
                    }
 
                    UseBareJids = true;
                    break;
 
                case "subscribed":
                    if (ToLocal)
                    {
                        Item = await this.persistenceLayer.GetRosterItem(To.Account, From.BareJid);
 
                        if (!(Item is null))
                        {
                            if (Item.Subscription == SubscriptionStatus.from)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(To.Account, From.BareJid, Item.Name, SubscriptionStatus.both,
                                    false, Item.Groups);
                            }
                            else if (Item.Subscription == SubscriptionStatus.none)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(To.Account, From.BareJid, Item.Name, SubscriptionStatus.to,
                                    false, Item.Groups);
                            }
                            else
                                Item = null;
 
                            if (!(Item is null))
                                await this.PushIq(To.BareJid, Item);
                        }
                        else
                            break;  // No subscription request to accept.
                    }
 
                    if (FromLocal)
                    {
                        Item = await this.persistenceLayer.GetRosterItem(FromUserName, To.BareJid);
                        if (!(Item is null))
                        {
                            if (Item.Subscription == SubscriptionStatus.to)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, Item.Name, SubscriptionStatus.both,
                                    Item.PendingSubscription, Item.Groups);
                            }
                            else if (Item.Subscription == SubscriptionStatus.none)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, Item.Name, SubscriptionStatus.from,
                                    Item.PendingSubscription, Item.Groups);
                            }
                            else
                                Item = null;
                        }
                        else
                            Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, string.Empty, SubscriptionStatus.from, false, null);
 
                        if (!(Item is null))
                            await this.PushIq(From.BareJid, Item);
 
                        LastPresence = FromConnection.LastPresence;
                    }
 
                    UseBareJids = true;
                    break;
 
                case "unsubscribed":
                    if (ToLocal)
                    {
                        Item = await this.persistenceLayer.GetRosterItem(To.Account, From.BareJid);
 
                        if (!(Item is null))
                        {
                            if (Item.Subscription == SubscriptionStatus.to)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(To.Account, From.BareJid, Item.Name, SubscriptionStatus.none,
                                    false, Item.Groups);
                            }
                            else if (Item.Subscription == SubscriptionStatus.both)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(To.Account, From.BareJid, Item.Name, SubscriptionStatus.from,
                                    false, Item.Groups);
                            }
                            else if (Item.PendingSubscription)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(To.Account, From.BareJid, Item.Name, Item.Subscription,
                                    false, Item.Groups);
                            }
                            else
                                Item = null;
 
                            if (!(Item is null))
                                await this.PushIq(To.BareJid, Item);
                        }
                    }
 
                    if (FromLocal)
                    {
                        Item = await this.persistenceLayer.GetRosterItem(FromUserName, To.BareJid);
                        if (!(Item is null))
                        {
                            if (Item.Subscription == SubscriptionStatus.from)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, Item.Name, SubscriptionStatus.none,
                                    Item.PendingSubscription, Item.Groups);
                            }
                            else if (Item.Subscription == SubscriptionStatus.both)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, Item.Name, SubscriptionStatus.to,
                                    Item.PendingSubscription, Item.Groups);
                            }
                            else
                                Item = null;
 
                            if (!(Item is null))
                                await this.PushIq(From.BareJid, Item);
                        }
                    }
 
                    UseBareJids = true;
                    break;
 
                case "unsubscribe":
                    if (ToLocal)
                    {
                        Item = await this.persistenceLayer.GetRosterItem(To.Account, From.BareJid);
 
                        if (!(Item is null))
                        {
                            if (Item.Subscription == SubscriptionStatus.from)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(To.Account, From.BareJid, Item.Name, SubscriptionStatus.none,
                                    false, Item.Groups);
                            }
                            else if (Item.Subscription == SubscriptionStatus.both)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(To.Account, From.BareJid, Item.Name, SubscriptionStatus.to,
                                    false, Item.Groups);
                            }
                            else
                                Item = null;
 
                            if (!(Item is null))
                                await this.PushIq(To.BareJid, Item);
                        }
                        else
                            break;  // No subscription request to unsubscribe from.
                    }
 
                    if (FromLocal)
                    {
                        Item = await this.persistenceLayer.GetRosterItem(FromUserName, To.BareJid);
                        if (!(Item is null))
                        {
                            if (Item.Subscription == SubscriptionStatus.to)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, Item.Name, SubscriptionStatus.none,
                                    false, Item.Groups);
                            }
                            else if (Item.Subscription == SubscriptionStatus.both)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, Item.Name, SubscriptionStatus.from,
                                    false, Item.Groups);
                            }
                            else if (Item.PendingSubscription)
                            {
                                Item = await this.persistenceLayer.SetRosterItem(FromUserName, To.BareJid, Item.Name, Item.Subscription,
                                    false, Item.Groups);
                            }
                            else
                                Item = null;
 
                            if (!(Item is null))
                                await this.PushIq(From.BareJid, Item);
                        }
                    }
 
                    await this.PushPresence(To, Type, Id, From.ToBareJID(), Language, Stanza, UseBareJids, Sender);
 
                    Type = "unavailable";
 
                    Stanza = null;
                    UseBareJids = true;
                    break;
 
                case "probe":
                    if (ToLocal)
                    {
                        if (ToAccount is null ||
                            await this.persistenceLayer.IsBlocked(From.BareJid, To.BareJid) ||
                            (From.HasAccount && (
                            (Item = await this.persistenceLayer.GetRosterItem(To.Account, From.BareJid)) is null ||
                            (Item.Subscription != SubscriptionStatus.both && Item.Subscription != SubscriptionStatus.from))))
                        {
                            if (!await (Sender?.Presence("unsubscribed", Id, From, To, string.Empty, string.Empty) ?? Task.FromResult(true)))
                                return false;
                        }
                        else
                        {
                            bool Sent = false;
 
                            if (To.IsBareJID)
                            {
                                IClientConnection[] Connections = this.GetClientConnections(To.BareJid);
                                if (!(Connections is null))
                                {
                                    foreach (IClientConnection Connection in Connections)
                                    {
                                        if (!((LastPresence = Connection.LastPresence) is null) && LastPresence.To.IsEmpty)
                                        {
                                            if (!await Sender.Presence(LastPresence.Type, Id, From, LastPresence.From, LastPresence.Language,
                                                LastPresence.Stanza?.Content))
                                            {
                                                return false;
                                            }
 
                                            Sent = true;
                                        }
                                    }
                                }
                            }
                            else if (this.TryGetConnection(To.Address, out IClientConnection Connection))
                            {
                                LastPresence = Connection.LastPresence;
                                if (!await (Sender?.Presence(LastPresence.Type, Id, From, LastPresence.From, LastPresence.Language, LastPresence.Stanza?.Content) ?? Task.FromResult(true)))
                                    return false;
                                Sent = true;
                            }
 
                            if (!Sent && !await (Sender?.Presence("unavailable", Id, From, To, string.Empty, string.Empty) ?? Task.FromResult(true)))
                                return false;
                        }
 
                        return true; // Don't propagate presence probes to clients.
                    }
                    break;
 
                case "":
                case "error":
                case "unavailable":
                    break;
 
                default:
                    if (!await (Sender?.PresenceErrorBadRequest(Id, From, this.domainAddress, "Invalid type.", "en") ?? Task.FromResult(true)))
                        return false;
                    break;
            }
 
            await this.PushPresence(To, Type, Id, UseBareJids ? From.ToBareJID() : From, Language, Stanza, UseBareJids, Sender);
 
            if (!(LastPresence is null))
            {
                await this.PushPresence(To, LastPresence.Type, LastPresence.Id, LastPresence.From, LastPresence.Language,
                    LastPresence.Stanza, false, Sender);
            }
 
            return true;
        }
 
        private async Task<bool> PushPresence(XmppAddress To, string Type, string Id, XmppAddress From, string Language, Stanza Stanza,
            bool UseBareJids, ISender Sender)
        {
            bool FromLocal = this.IsServerDomain(From.Domain, true);
            PresenceEventArgs e = null;
 
            if (FromLocal)
            {
                e = new PresenceEventArgs(Sender, Type, Id, To, From, Language, Stanza, null);
                await this.OnPresenceLocalSender.Raise(this, e);
 
                if (e.ResponseSent)
                    return true;
            }
 
            bool ToLocal = To.Domain == From.Domain ? FromLocal : this.IsServerDomain(To.Domain, true);
 
            if (ToLocal)
            {
                IClientConnection[] Connections = this.GetClientConnections(To.BareJid);
                await this.PushPresence(Type, Id, From, Language, Stanza is null ? string.Empty : Stanza.Content, Connections, UseBareJids);
 
                await this.OnPresenceLocalRecipient.Raise(this, e ?? new PresenceEventArgs(Sender, Type, Id, To, From, Language, Stanza, null));
            }
            else
            {
                IRecipient Recipient = await this.TryGetRecipient(To, From);
 
                if (!(Recipient is null))
                    await Recipient.Presence(Type, Id, To, From, Language, Stanza, Sender);
            }
 
            return true;
        }
 
        public event EventHandlerAsync<PresenceEventArgs> OnPresenceLocalRecipient = null;
 
        public event EventHandlerAsync<PresenceEventArgs> OnPresenceLocalSender = null;
 
        public Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.Presence(Type, Id, To, From, Language, ToStanza("presence", Type, Id, To, From, Language, ContentXml), Sender);
        }
 
        public static void GetErrorInformation(Exception ex, out string Type, out string Xml)
        {
            if (ex is StanzaExceptionException stEx)
            {
                Type = stEx.ErrorType;
                Xml = "<" + stEx.ErrorStanzaName + " xmlns='" + StanzaNamespace + "'/>";
                return;
            }
            else if (ex is HttpException)
            {
                Type = null;
                Xml = null;
 
                if (ex is HTTP.BadRequestException)
                {
                    Type = "modify";
                    Xml = "bad-request";
                }
                else if (ex is HTTP.ConflictException)
                {
                    Type = "cancel";
                    Xml = "conflict";
                }
                else if (ex is HTTP.ForbiddenException)
                {
                    Type = "auth";
                    Xml = "forbidden";
                }
                else if (ex is HTTP.NotImplementedException)
                {
                    Type = "cancel";
                    Xml = "feature-not-implemented";
                }
                else if (ex is HTTP.MovedPermanentlyException || ex is HTTP.GoneException)
                {
                    Type = "cancel";
                    Xml = "gone";
                }
                else if (ex is HTTP.InternalServerErrorException)
                {
                    Type = "cancel";
                    Xml = "internal-server-error";
                }
                else if (ex is HTTP.NotFoundException)
                {
                    Type = "cancel";
                    Xml = "item-not-found";
                }
                else if (ex is HTTP.NotAcceptableException || ex is HTTP.UnsupportedMediaTypeException)
                {
                    Type = "modify";
                    Xml = "not-acceptable";
                }
                else if (ex is HTTP.MethodNotAllowedException)
                {
                    Type = "cancel";
                    Xml = "not-allowed";
                }
                else if (ex is HTTP.TooManyRequestsException || ex is HTTP.InsufficientStorageException)
                {
                    Type = "wait";
                    Xml = "resource-constraint";
                }
                else if (ex is HTTP.ServiceUnavailableException)
                {
                    Type = "cancel";
                    Xml = "service-unavailable";
                }
                else if (ex is HTTP.NetworkAuthenticationRequiredException)
                {
                    Type = "auth";
                    Xml = "not-authorized";
                }
 
                if (!(Xml is null))
                {
                    Xml = "<" + Xml + " xmlns='" + StanzaNamespace + "'/>";
                    return;
                }
            }
 
            Type = "cancel";
            Xml = "<internal-server-error xmlns='" + StanzaNamespace + "'/>";
        }
 
        #endregion
 
        #region Request/Response
 
        public async Task<bool> GetLastPresence(CaseInsensitiveString BareJid, EventHandlerAsync<PresenceEventArgs> Callback, object State)
        {
            int i = BareJid.IndexOf('@');
            if (i >= 0)
            {
                CaseInsensitiveString UserName = BareJid.Substring(0, i);
                CaseInsensitiveString Domain = BareJid.Substring(i + 1);
 
                if (this.IsServerDomain(Domain, true))
                {
                    IClientConnection[] Connections = this.GetClientConnections(BareJid);
                    if (!(Connections is null))
                    {
                        PresenceEventArgs Last = null;
 
                        foreach (IClientConnection Connection in Connections)
                        {
                            if (!(Connection?.LastPresence is null))
                            {
                                PresenceEventArgs LastPresence = Connection.LastPresence;
                                if (Last is null || LastPresence.Timestamp > Last.Timestamp)
                                    Last = LastPresence;
                            }
                        }
 
                        if (Last is null)
                            return false;
 
                        await Callback.Raise(this, new PresenceEventArgs(null, Last.Type, Last.Id, Last.To, Last.From, Last.Language, Last.Stanza, State));
 
                        return true;
                    }
                    else
                        return false;
                }
                else
                {
                    IS2SEndpoint Endpoint;
 
                    try
                    {
                        Endpoint = await this.GetS2sEndpoint(this.domain, Domain, true, "Performing presence probe on " + BareJid);
                    }
                    catch (Exception)
                    {
                        return false;
                    }
 
                    if (Endpoint is XmppS2SEndpoint XmppS2SEndpoint)
                    {
                        PendingRequest Request = this.PrepareRequest(null, (Sender, e) =>
                        {
                            return Callback.Raise(this, new PresenceEventArgs(null, e.Type, e.Id, e.To, e.From, e.Language, e.Stanza, e.State));
                        }, null, State, 10000, 0, false, 10000, this.domainAddress, new XmppAddress(BareJid), string.Empty, string.Empty, null);
 
                        await XmppS2SEndpoint.SendStanza("presence", "probe", Request.Id, new XmppAddress(BareJid), this.domainAddress, string.Empty, string.Empty, this);
                        // TODO: Errors in SendStanza should be returned, which does not happen since last parameter is null.
 
                        return true;
                    }
                    else
                        return false;
                }
            }
            else
                return false;
        }
 
        private PendingRequest PrepareRequest(EventHandlerAsync<IqResultEventArgs> IqCallback, EventHandlerAsync<PresenceEventArgs> PresenceCallback,
            EventHandlerAsync<PendingRequestEventArgs> ResendCallback, object State, int RetryTimeout, int NrRetries, bool DropOff, int MaxRetryTimeout,
            XmppAddress From, XmppAddress To, string Language, string ContentXml, string ShortTermCacheKey)
        {
            lock (this.synchObject)
            {
                string Id;
 
                do
                {
                    Id = this.NewId(16);
                }
                while (this.pendingRequestsById.ContainsKey(Id));
 
                PendingRequest PendingRequest;
 
                if (!(IqCallback is null))
                {
                    PendingRequest = new PendingRequest(Id, RetryTimeout, NrRetries, DropOff, MaxRetryTimeout)
                    {
                        IqCallback = IqCallback,
                        ResendCallback = ResendCallback,
                        State = State,
                        From = From,
                        To = To,
                        Id = Id,
                        Language = Language,
                        ContentXml = ContentXml,
                        ShortTermCacheKey = ShortTermCacheKey
                    };
                }
                else
                {
                    PendingRequest = new PendingRequest(Id, RetryTimeout, NrRetries, DropOff, MaxRetryTimeout)
                    {
                        PresenceCallback = PresenceCallback,
                        ResendCallback = ResendCallback,
                        State = State,
                        From = From,
                        To = To,
                        Id = Id,
                        Language = Language,
                        ContentXml = ContentXml
                    };
                }
 
                DateTime TP = PendingRequest.Timeout;
 
                if (this.pendingRequestsByTimeout.ContainsKey(TP))
                {
                    Random Rnd = new Random();
 
                    while (this.pendingRequestsByTimeout.ContainsKey(TP))
                        TP = TP.AddTicks(Rnd.Next(100) + 1);
                }
 
                PendingRequest.Timeout = TP;
 
                this.pendingRequestsById[Id] = PendingRequest;
                this.pendingRequestsByTimeout[TP] = PendingRequest;
 
                return PendingRequest;
            }
        }
 
        public Task<bool> SendIqRequest(string Type, string From, string To, string Language,
            string ContentXml, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            return this.SendIqRequest(Type, new XmppAddress(From), new XmppAddress(To),
                Language, ContentXml, false, Callback, State);
        }
 
        public Task<bool> SendIqRequest(string Type, string From, string To, string Language,
            string ContentXml, bool CheckShortTermCache,
            EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            return this.SendIqRequest(Type, new XmppAddress(From), new XmppAddress(To),
                Language, ContentXml, CheckShortTermCache, Callback, State);
        }
 
        public Task<bool> SendIqRequest(string Type, XmppAddress From, XmppAddress To,
            string Language, string ContentXml, EventHandlerAsync<IqResultEventArgs> Callback,
            object State)
        {
            return this.SendIqRequest(Type, From, To, Language, ContentXml, false, Callback, State);
        }
 
        public async Task<bool> SendIqRequest(string Type, XmppAddress From, XmppAddress To,
            string Language, string ContentXml, bool CheckShortTermCache,
            EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            IRecipient Recipient = await this.TryGetRecipient(To, From);
 
            if (Recipient is null)
            {
                IqResultEventArgs e = new IqResultEventArgs(null, string.Empty, From, To, Language, false, State);
                await Callback.Raise(this, e);
 
                return false;
            }
 
            string Key = null;
 
            if (CheckShortTermCache)
            {
                StringBuilder sb = new StringBuilder();
 
                sb.AppendLine(Type);
                sb.AppendLine(From.Address.Value);
                sb.AppendLine(To.Address.Value);
                sb.AppendLine(Language);
                sb.AppendLine(ContentXml);
 
                Key = sb.ToString();
 
                if (this.shortTermCache.TryGetValue(Key, out IqResultEventArgs Result))
                {
                    await Callback.Raise(this, Result);
                    return true;
                }
            }
 
            PendingRequest Request = this.PrepareRequest(Callback, null, async (Sender, e) =>
            {
                await Recipient.IQ(Type, e.Request.Id, e.Request.To, e.Request.From,
                    e.Request.Language, e.Request.ContentXml, this);
 
            }, State, this.defaultRetryTimeout, this.defaultNrRetries, this.defaultDropOff,
                this.defaultMaxRetryTimeout, From, To, Language, ContentXml, Key);
 
            await Recipient.IQ(Type, Request.Id, To, From, Language, ContentXml, this);
 
            return true;
        }
 
        public Task<IqResultEventArgs> IqRequest(string Type, string From, string To,
            string Language, string ContentXml)
        {
            return this.IqRequest(Type, new XmppAddress(From), new XmppAddress(To), Language, ContentXml, false);
        }
 
        public Task<IqResultEventArgs> IqRequest(string Type, string From, string To,
            string Language, string ContentXml, bool CheckShortTermCache)
        {
            return this.IqRequest(Type, new XmppAddress(From), new XmppAddress(To), Language,
                ContentXml, CheckShortTermCache);
        }
 
        public Task<IqResultEventArgs> IqRequest(string Type, XmppAddress From, XmppAddress To, string Language, string ContentXml)
        {
            return this.IqRequest(Type, From, To, Language, ContentXml, false);
        }
 
        public async Task<IqResultEventArgs> IqRequest(string Type, XmppAddress From, XmppAddress To,
            string Language, string ContentXml, bool CheckShortTermCache)
        {
            TaskCompletionSource<IqResultEventArgs> Result = new TaskCompletionSource<IqResultEventArgs>();
 
            if (await this.SendIqRequest(Type, From, To, Language, ContentXml, CheckShortTermCache,
                (Sender, e) =>
                {
                    Result.TrySetResult(e);
                    return Task.CompletedTask;
 
                }, null))
            {
                return await Result.Task;
            }
            else
                throw new InvalidOperationException("Unable to send request.");
        }
 
        public Task<bool> SendMessage(string Type, string Id, string From, string To, string Language, string ContentXml)
        {
            return this.SendMessage(Type, Id, new XmppAddress(From), new XmppAddress(To), Language, ContentXml);
        }
 
        public async Task<bool> SendMessage(string Type, string Id, XmppAddress From, XmppAddress To, string Language, string ContentXml)
        {
            IRecipient Recipient = await this.TryGetRecipient(To, From);
 
            if (Recipient is null)
                return false;
            else
            {
                await Recipient.Message(Type, Id, To, From, Language, ContentXml, this);
                return true;
            }
        }
 
        private async void SecondTimerCallback(object State)
        {
            try
            {
                LinkedList<KeyValuePair<DateTime, IS2SEndpoint>> ToRemove = null;
                List<PendingRequest> Retries = null;
                DateTime Now = DateTime.Now;
                DateTime TP;
                bool Retry;
 
                lock (this.synchObject)
                {
                    foreach (KeyValuePair<DateTime, PendingRequest> P in this.pendingRequestsByTimeout)
                    {
                        if (P.Key <= Now)
                        {
                            Retries ??= new List<PendingRequest>();
                            Retries.Add(P.Value);
                        }
                        else
                            break;
                    }
 
                    if (!(this.temporaryConnections is null))
                    {
                        foreach (KeyValuePair<DateTime, IS2SEndpoint> P in this.temporaryConnections)
                        {
                            if (P.Key < Now)
                            {
                                ToRemove ??= new LinkedList<KeyValuePair<DateTime, IS2SEndpoint>>();
                                ToRemove.AddLast(P);
                            }
                            else
                                break;
                        }
 
                        if (!(ToRemove is null))
                        {
                            foreach (KeyValuePair<DateTime, IS2SEndpoint> P in ToRemove)
                                this.temporaryConnections.Remove(P.Key);
 
                            if (this.temporaryConnections.Count == 0)
                                this.temporaryConnections = null;
                        }
                    }
                }
 
                if (!(Retries is null))
                {
                    foreach (PendingRequest Request in Retries)
                    {
                        lock (this.synchObject)
                        {
                            this.pendingRequestsByTimeout.Remove(Request.Timeout);
 
                            if (Retry = Request.CanRetry())
                            {
                                TP = Request.Timeout;
 
                                if (this.pendingRequestsByTimeout.ContainsKey(TP))
                                {
                                    Random Rnd = new Random();
 
                                    while (this.pendingRequestsByTimeout.ContainsKey(TP))
                                        TP = TP.AddTicks(Rnd.Next(100) + 1);
                                }
 
                                Request.Timeout = TP;
 
                                this.pendingRequestsByTimeout[Request.Timeout] = Request;
                            }
                            else
                                this.pendingRequestsById.Remove(Request.Id);
                        }
 
                        try
                        {
                            if (Retry)
                                await Request.ResendCallback.Raise(this, new PendingRequestEventArgs(Request));
                            else
                            {
                                if (!(Request.IqCallback is null))
                                {
                                    StringBuilder Xml = new StringBuilder();
 
                                    Xml.Append("<iq xmlns='jabber:server' type='error' from='");
                                    Xml.Append(Request.To);
                                    Xml.Append("' id='");
                                    Xml.Append(Request.Id);
                                    Xml.Append("'><error type='wait'><recipient-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>");
                                    Xml.Append("<text xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'>Timeout.</text></error></iq>");
 
                                    XmlDocument Doc = XML.ParseXml(Xml.ToString(), true);
 
                                    IqResultEventArgs e = new IqResultEventArgs(Doc.DocumentElement, Request.Id, XmppAddress.Empty, Request.To, string.Empty, false,
                                        Request.State);
 
                                    await Request.IqCallback.Raise(this, e);
                                }
                                else if (!(Request.PresenceCallback is null))
                                {
                                    Stanza Stanza = ToStanza("presence", "error", Request.Id, XmppAddress.Empty, Request.To, string.Empty,
                                        "<error type='wait'><recipient-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                        "<text xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'>Timeout.</text></error>");
 
                                    PresenceEventArgs e = new PresenceEventArgs(null, "error", Request.Id, XmppAddress.Empty, Request.To, string.Empty,
                                        Stanza, Request.State);
 
                                    await Request.PresenceCallback.Raise(this, e);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    }
                }
 
                if (!(ToRemove is null))
                {
                    foreach (KeyValuePair<DateTime, IS2SEndpoint> P in ToRemove)
                        await P.Value.DisposeAsync("Removing temporary connection.");
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        #region ISender
 
        public virtual async Task<string> IqError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            GetErrorInformation(ex, out _, out string Xml);
            Stanza Stanza = ToStanza("iq", "error", Id, To, From, string.Empty, Xml);
 
            await this.ProcessResponse("error", Id, To, From, string.Empty, true, false, Stanza, this);
 
            return Xml;
        }
 
        public virtual async Task<bool> IqError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            Stanza Stanza = ToStanza("iq", "error", Id, To, From, string.Empty, ErrorXml);
 
            await this.ProcessResponse("error", Id, To, From, string.Empty, true, false, Stanza, this);
 
            return true;
        }
 
        public virtual async Task<bool> IqResult(string Id, XmppAddress To, XmppAddress From, string ResultXml)
        {
            Stanza Stanza = ToStanza("iq", "result", Id, To, From, string.Empty, ResultXml);
 
            await this.ProcessResponse("result", Id, To, From, string.Empty, true, false, Stanza, this);
 
            return true;
        }
 
        public virtual async Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            GetErrorInformation(ex, out _, out string Xml);
            Stanza Stanza = ToStanza("presence", "error", Id, To, From, string.Empty, Xml);
 
            await this.ProcessResponse("error", Id, To, From, string.Empty, false, true, Stanza, this);
 
            return true;
        }
 
        public virtual async Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            Stanza Stanza = ToStanza("presence", "error", Id, To, From, string.Empty, ErrorXml);
 
            await this.ProcessResponse("error", Id, To, From, string.Empty, false, true, Stanza, this);
 
            return true;
        }
 
        public virtual async Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            Stanza Stanza = ToStanza("presence", Type, Id, To, From, string.Empty, ContentXml);
 
            await this.ProcessResponse(Type, Id, To, From, string.Empty, true, false, Stanza, this);
 
            return true;
        }
 
        public virtual Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        public virtual Task<bool> MessageError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        #endregion
 
        #endregion
 
        #region Roster
 
        private async Task RosterQuery(object Sender, IqEventArgs e)
        {
            if (!(e.Sender is IClientConnection ClientConnection) || (!e.To.IsEmpty && e.To.Address != ClientConnection.BareJid))
            {
                await e.IqErrorForbidden(e.To, "You can only access your own roster.", "en");
                return;
            }
 
            CaseInsensitiveString UserName = ClientConnection.UserName;
            IEnumerable<IRosterItem> Roster = await this.persistenceLayer.GetRoster(UserName);
            if (Roster is null)
            {
                await e.IqErrorItemNotFound(e.To, "Roster not found.", "en");
                return;
            }
 
            string Ver = XML.Attribute(e.Query, "ver");
 
            List<IRosterItem> A = new List<IRosterItem>();
            A.AddRange(Roster);
            A.Sort((i1, i2) => i1.BareJid.CompareTo(i2.BareJid));
 
            StringBuilder Xml = new StringBuilder();
 
            foreach (IRosterItem Item in A)
                this.Serialize(Xml, Item);
 
            string s = Xml.ToString();
            string Hash = Hashes.ComputeSHA1HashString(Encoding.UTF8.GetBytes(s));
 
            if (Ver == Hash)
                await e.IqResult(string.Empty, e.From.ToBareJID());
            else
            {
                Xml.Clear();
                Xml.Append("<query xmlns='");
                Xml.Append(RosterNamespace);
                Xml.Append("' ver='");
                Xml.Append(Hash);
                Xml.Append("'>");
                Xml.Append(s);
                Xml.Append("</query>");
 
                await e.IqResult(Xml.ToString(), e.From.ToBareJID());
            }
        }
 
        private void Serialize(StringBuilder Xml, IRosterItem Item)
        {
            Xml.Append("<item jid='");
            Xml.Append(XML.Encode(Item.BareJid));
 
            if (Item.PendingSubscription && (Item.Subscription != SubscriptionStatus.both && Item.Subscription != SubscriptionStatus.to))
                Xml.Append("' ask='subscribe");
 
            if (!string.IsNullOrEmpty(Item.Name))
            {
                Xml.Append("' name='");
                Xml.Append(XML.Encode(Item.Name));
            }
 
            if (Item.Subscription != SubscriptionStatus.none)
            {
                Xml.Append("' subscription='");
                Xml.Append(Item.Subscription.ToString());
            }
 
            string[] Groups = Item.Groups;
            if (Groups is null || Groups.Length == 0)
                Xml.Append("'/>");
            else
            {
                Xml.Append("'>");
 
                foreach (string Group in Groups)
                {
                    Xml.Append("<group>");
                    Xml.Append(XML.Encode(Group));
                    Xml.Append("</group>");
                }
 
                Xml.Append("</item>");
            }
        }
 
        private async Task RosterSet(object Sender, IqEventArgs e)
        {
            if (!(e.Sender is IClientConnection ClientConnection) || (!e.To.IsEmpty && e.To.Address != ClientConnection.BareJid))
            {
                await e.IqErrorForbidden(e.To, "You can only access your own roster.", "en");
                return;
            }
 
            XmlElement E;
            List<string> Groups = null;
            CaseInsensitiveString UserName = ClientConnection.UserName;
            CaseInsensitiveString Jid = null;
            string Name = null;
            string s;
            SubscriptionStatus Subscription = SubscriptionStatus.none;
            bool PendingSubscription;
            bool First = true;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                E = N as XmlElement;
                if (E is null)
                    continue;
 
                if (E.LocalName != "item")
                    continue;
 
                if (First)
                    First = false;
                else
                {
                    await e.IqErrorBadRequest(e.To, "Multiple items not allowed.", "en");
                    return;
                }
 
                Jid = XML.Attribute(E, "jid");
                Name = XML.Attribute(E, "name");
                PendingSubscription = XML.Attribute(E, "ask") == "subscribe";
                Subscription = XML.Attribute(E, "subscription", SubscriptionStatus.none);
 
                if (Name.Length > MaxNameLength)
                {
                    await e.IqErrorNotAcceptable(e.To, "Name too long.", "en");
                    return;
                }
 
                foreach (XmlNode N2 in N.ChildNodes)
                {
                    E = N2 as XmlElement;
                    if (E is null)
                        continue;
 
                    if (E.LocalName != "group")
                        continue;
 
                    Groups ??= new List<string>();
 
                    s = E.InnerText;
                    if (string.IsNullOrEmpty(s) || s.Length > MaxGroupLength)
                    {
                        await e.IqErrorNotAcceptable(e.To, "Group name too long.", "en");
                        return;
                    }
                    else if (Groups.Contains(s))
                    {
                        await e.IqErrorBadRequest(e.To, "Group name occurred twice: " + s, "en");
                        return;
                    }
 
                    Groups.Add(s);
                }
            }
 
            if (CaseInsensitiveString.IsNullOrEmpty(Jid))
            {
                await e.IqErrorBadRequest(e.To, "JID not specificed.", "en");
                return;
            }
 
            IRosterItem Item = await this.persistenceLayer.SetRosterItem(UserName, Jid, Name, null, null, Groups?.ToArray());
            if (!(Item is null))
            {
                if (Subscription == SubscriptionStatus.remove)
                {
                    if (await this.persistenceLayer.RemoveRosterItem(UserName, Jid))
                    {
                        if (Item.Subscription == SubscriptionStatus.both || Item.Subscription == SubscriptionStatus.from)
                            await this.PushPresence(new XmppAddress(Item.BareJid), "unavailable", string.Empty, e.From, string.Empty, (Stanza)null, true, this);
 
                        if (Item.Subscription == SubscriptionStatus.both || Item.Subscription == SubscriptionStatus.to)
                        {
                            await this.PushPresence(new XmppAddress(Item.BareJid), "unsubscribe", string.Empty, e.From.ToBareJID(), string.Empty, (Stanza)null, true, this);
                            await this.PushPresence(e.From.ToBareJID(), "unsubscribed", string.Empty, new XmppAddress(Item.BareJid), string.Empty, (Stanza)null, true, this);
                        }
 
                        if (Item.Subscription == SubscriptionStatus.both || Item.Subscription == SubscriptionStatus.from)
                        {
                            await this.PushPresence(e.From.ToBareJID(), "unsubscribe", string.Empty, new XmppAddress(Item.BareJid), string.Empty, (Stanza)null, true, this);
                            await this.PushPresence(new XmppAddress(Item.BareJid), "unsubscribed", string.Empty, e.From.ToBareJID(), string.Empty, (Stanza)null, true, this);
                        }
 
                        await e.IqResult(string.Empty, e.To);
 
                        StringBuilder Xml = new StringBuilder();
 
                        Xml.Append("<query xmlns='");
                        Xml.Append(RosterNamespace);
                        Xml.Append("'><item jid='");
                        Xml.Append(Jid);
                        Xml.Append("' subscription='remove'></item></query>");
 
                        await this.PushIq("set", false, XmppAddress.Empty, string.Empty, Xml.ToString(), this.GetClientConnections(e.From.BareJid));
                    }
                    else
                        await e.IqErrorItemNotFound(e.To, string.Empty, string.Empty);
                }
                else
                {
                    await e.IqResult(string.Empty, e.To);
                    await this.PushIq(ClientConnection.BareJid, Item);
                }
            }
            else
                await e.IqErrorItemNotFound(e.To, string.Empty, string.Empty);
        }
 
        private Task PushIq(CaseInsensitiveString BareJid, IRosterItem Item)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(RosterNamespace);
            Xml.Append("'>");
 
            this.Serialize(Xml, Item);
 
            Xml.Append("</query>");
 
            return this.PushIq("set", false, XmppAddress.Empty, string.Empty, Xml.ToString(), this.GetClientConnections(BareJid));
        }
 
        private async Task PushIq(string Type, bool IncludeTo, XmppAddress From, string Language, string Xml, IClientConnection[] Connections)
        {
            if (!(Connections is null))
            {
                foreach (IClientConnection Connection in Connections)
                {
                    if (Connection.State == XmppConnectionState.Active)
                    {
                        try
                        {
                            await Connection.IQ(Type, this.NewId(16), IncludeTo ? Connection.Address : XmppAddress.Empty, From, Language, Xml, this);
                        }
                        catch (Exception ex)
                        {
                            try
                            {
                                Connection.Exception(ex);
                                await Connection.DisposeAsync();
                            }
                            catch (Exception ex2)
                            {
                                Log.Exception(ex2);
                            }
                        }
                    }
                }
            }
        }
 
        private async Task PushPresence(string Type, string Id, XmppAddress From, string Language, string Xml, IClientConnection[] Connections,
            bool UseBareJids)
        {
            if (!(Connections is null))
            {
                foreach (IClientConnection Connection in Connections)
                {
                    if (Connection.State == XmppConnectionState.Active)
                    {
                        try
                        {
                            await Connection.Presence(Type, string.IsNullOrEmpty(Id) ? this.NewId(16) : Id,
                                UseBareJids ? Connection.BareAddress : Connection.Address, From, Language, Xml, this);
                        }
                        catch (Exception ex)
                        {
                            try
                            {
                                Connection.Exception(ex);
                                await Connection.DisposeAsync();
                            }
                            catch (Exception ex2)
                            {
                                Log.Exception(ex2);
                            }
                        }
                    }
                }
            }
        }
 
        #endregion
 
        #region Ping XEP-0199
 
        private Task PingGet(object Sender, IqEventArgs e)
        {
            e.IqResult(string.Empty, e.To);
 
            return Task.CompletedTask;
        }
 
        #endregion
 
        #region Discovery XEP-0030
 
        private Task DiscoveryQueryGet(object Sender, IqEventArgs e)
        {
            XmlElement E = e.Query;
            string Node = XML.Attribute(E, "node");
            if (!string.IsNullOrEmpty(Node))
            {
                e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                return Task.CompletedTask;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(DiscoveryNamespace);
            Xml.Append("'><identity category='server' type='im'/>");  // https://xmpp.org/registrar/disco-categories.html
 
            lock (this.synchObject)
            {
                foreach (string Feature in this.features.Keys)
                {
                    Xml.Append("<feature var='");
                    Xml.Append(XML.Encode(Feature));
                    Xml.Append("'/>");
                }
            }
 
            Xml.Append("</query>");
 
            e.IqResult(Xml.ToString(), e.To);
 
            return Task.CompletedTask;
        }
 
        private Task DiscoveryQueryItemsGet(object Sender, IqEventArgs e)
        {
            XmlElement E = e.Query;
            string Node = XML.Attribute(E, "node");
            if (!string.IsNullOrEmpty(Node))
            {
                e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                return Task.CompletedTask;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(DiscoveryItemsNamespace);
            Xml.Append("'>");
 
            foreach (IComponent Component in this.componentsStatic)
            {
                Xml.Append("<item jid='");
                Xml.Append(XML.Encode(Component.Subdomain));
                Xml.Append('.');
                Xml.Append(XML.Encode(e.To.IsEmpty ? e.From.Domain : e.To.Domain));
                Xml.Append("' name='");
                Xml.Append(XML.Encode(Component.Name));
                Xml.Append("'/>");
            }
 
            Xml.Append("</query>");
 
            e.IqResult(Xml.ToString(), e.To);
 
            return Task.CompletedTask;
        }
 
        #endregion
 
        #region Software Version (XEP-0092)
 
        private Task SoftwareVersionGet(object Sender, IqEventArgs e)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(SoftwareVersionNamespace);
            Xml.Append("'><name>");
            Xml.Append(XML.Encode(this.serverName));
            Xml.Append("</name><version>");
            Xml.Append(XML.Encode(this.serverVersion));
            Xml.Append("</version><os>");
            Xml.Append(XML.Encode(this.serverOS));
            Xml.Append("</os></query>");
 
            e.IqResult(Xml.ToString(), e.To);
 
            return Task.CompletedTask;
        }
 
        #endregion
 
        #region Entity Time (XEP-0202)
 
        private Task TimeGet(object Sender, IqEventArgs e)
        {
            StringBuilder Xml = new StringBuilder();
            DateTimeOffset Time = DateTimeOffset.Now;
            TimeSpan TimeZone = Time.Offset;
            DateTime Utc = Time.UtcDateTime;
 
            Xml.Append("<time xmlns='");
            Xml.Append(TimeNamespace);
            Xml.Append("'><tzo>");
 
            if (TimeZone == TimeSpan.Zero)
                Xml.Append("Z");
            else
            {
                if (TimeZone < TimeSpan.Zero)
                {
                    Xml.Append('-');
                    TimeZone = -TimeZone;
                }
                else
                    Xml.Append('+');
 
                Xml.Append(TimeZone.Hours.ToString("D2"));
                Xml.Append(':');
                Xml.Append(TimeZone.Minutes.ToString("D2"));
            }
 
            Xml.Append("</tzo><utc>");
            Xml.Append(XML.Encode(Utc));
            Xml.Append("</utc></time>");
 
            e.IqResult(Xml.ToString(), e.To);
 
            return Task.CompletedTask;
        }
 
        #endregion
 
        #region vCard (XEP-0054)
 
        private async Task VCardGet(object Sender, IqEventArgs e)
        {
            if (!e.From.HasAccount || !this.IsServerDomain(e.From.Domain, true))
                await e.IqErrorItemNotFound(e.To, "Account not found.", "en");
            else
            {
                string s = await this.persistenceLayer.GetVCard(e.From.Account);
 
                if (string.IsNullOrEmpty(s))
                    await e.IqErrorItemNotFound(e.To, "vCard not found.", "en");
                else
                    await e.IqResult("<vCard xmlns='" + VCardNamespace + "'>" + s + "</vCard>", e.To);
            }
        }
 
        private async Task VCardSet(object Sender, IqEventArgs e)
        {
            if (!e.From.HasAccount || !this.IsServerDomain(e.From.Domain, true))
                await e.IqErrorItemNotFound(e.To, "Account not found.", "en");
            else
            {
                CaseInsensitiveString UserName = e.From.Account;
                string VCard = e.Query.InnerXml;
 
                if (!await this.persistenceLayer.SetVCard(UserName, VCard))
                    await e.IqErrorItemNotFound(e.To, "Unable to set vCard.", "en");
                else
                    await e.IqResult(string.Empty, e.To);
            }
        }
 
        #endregion
 
        #region Register (XEP-0077) & Form signatures (XEP-0348)
 
        private const string RegistrationInstructions = "Register your new account, by filling in the details below.";
 
        internal async Task<bool> CanRegister(IClientConnection Connection)
        {
            DateTime? Next = await this.GetEarliestLoginOpportunity(Connection);
            return !Next.HasValue;
        }
 
        internal async Task<bool> CanRegister(IClientConnection Connection, IqEventArgs e)
        {
            DateTime? Next = await this.GetEarliestLoginOpportunity(Connection);
 
            if (Next.HasValue)
            {
                StringBuilder sb = new StringBuilder();
                DateTime TP = Next.Value;
                DateTime Today = DateTime.Today;
 
                if (Next.Value == DateTime.MaxValue)
                {
                    sb.Append("This endpoint (");
                    sb.Append(Connection.RemoteEndPoint);
                    sb.Append(") has been blocked from the system.");
 
                    await e.IqErrorForbidden(e.To, sb.ToString(), "en");
                    return false;
                }
                else
                {
                    sb.Append("Too many failed login attempts in a row registered. Try again after ");
                    sb.Append(TP.ToLongTimeString());
 
                    if (TP.Date != Today)
                    {
                        if (TP.Date == Today.AddDays(1))
                            sb.Append(" tomorrow");
                        else
                        {
                            sb.Append(", ");
                            sb.Append(TP.ToShortDateString());
                        }
                    }
 
                    sb.Append(". Remote Endpoint: ");
                    sb.Append(Connection.RemoteEndPoint);
 
                    await e.IqErrorNotAllowed(e.To, sb.ToString(), "en");
                    return false;
                }
            }
 
            return true;
        }
 
        private async Task RegisterGet(object Sender, IqEventArgs e)
        {
            if (!(e.Sender is IClientConnection Connection))
            {
                await e.IqErrorForbidden(e.To, "Only clients can register.", "en");
                return;
            }
 
            if (!await this.CanRegister(Connection, e))
                return;
 
            StringBuilder Xml = new StringBuilder();
            byte[] Token = GetRandomNumbers(32);
            byte[] Secret = GetRandomNumbers(32);
 
            Xml.Append("<query xmlns='");
            Xml.Append(RegisterNamespace);
            Xml.Append("'><instructions>");
            Xml.Append(RegistrationInstructions);
            Xml.Append("</instructions>");
            Xml.Append("<x xmlns='jabber:x:data' type='form'>");
            Xml.Append("<title>Contest Registration</title>");
            Xml.Append("<instructions>");
            Xml.Append(RegistrationInstructions);
            Xml.Append("</instructions>");
            Xml.Append("<field type='hidden' var='FORM_TYPE'>");
            Xml.Append("<value>urn:xmpp:xdata:signature:oauth1</value>");
            Xml.Append("</field>");
            Xml.Append("<field type='text-single' label='User Name:' var='username'>");
            Xml.Append("<required/>");
            Xml.Append("</field>");
            Xml.Append("<field type='text-private' label='Password:' var='password'>");
            Xml.Append("<required/>");
            Xml.Append("</field>");
            Xml.Append("<field type='text-single' label='Email Address' var='email'/>");
            Xml.Append("<field type='text-single' label='Phone Number' var='phone'/>");
            Xml.Append("<field type='hidden' var='oauth_version'>");
            Xml.Append("<value>1.0</value>");
            Xml.Append("</field>");
            Xml.Append("<field type='hidden' var='oauth_signature_method'>");
            Xml.Append("<value>HMAC-SHA1</value>");
            Xml.Append("</field>");
            Xml.Append("<field type='hidden' var='oauth_token'>");
            Xml.Append("<value>");
            Xml.Append(Hashes.BinaryToString(Token));
            Xml.Append("</value>");
            Xml.Append("</field>");
            Xml.Append("<field type='hidden' var='oauth_token_secret'>");
            Xml.Append("<value>");
            Xml.Append(Hashes.BinaryToString(Secret));
            Xml.Append("</value>");
            Xml.Append("</field>");
            Xml.Append("<field type='hidden' var='oauth_nonce'>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
            Xml.Append("<field type='hidden' var='oauth_timestamp'>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
            Xml.Append("<field type='hidden' var='oauth_consumer_key'>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
            Xml.Append("<field type='hidden' var='oauth_signature'>");
            Xml.Append("<value/>");
            Xml.Append("</field>");
            Xml.Append("</x>");
            Xml.Append("</query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task RegisterSet(object Sender, IqEventArgs e)
        {
            if (!(e.Sender is IClientConnection Connection))
            {
                await e.IqErrorForbidden(e.To, "Only clients can register.", "en");
                return;
            }
 
            if (!await this.CanRegister(Connection, e))
                return;
 
            CaseInsensitiveString UserName = null;
            string Password = null;
            bool Remove = false;
            int Count = 0;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (!(N is XmlElement E))
                    continue;
 
                Count++;
                if (E.NamespaceURI == RegisterNamespace)
                {
                    switch (E.LocalName)
                    {
                        case "username":
                            UserName = E.InnerText;
                            break;
 
                        case "password":
                            Password = E.InnerText;
                            break;
 
                        case "remove":
                            Remove = true;
                            break;
                    }
                }
                else if (E.LocalName == "x" && E.NamespaceURI == DataFormsNamespace && XML.Attribute((XmlElement)N, "type") == "submit")
                {
                    if (Connection.State != XmppConnectionState.Authenticating)
                    {
                        await e.IqErrorNotAllowed(e.To, "Step only allowed during authentication phase.", "en");
                        return;
                    }
 
                    string FormType = null;
                    CaseInsensitiveString EMail = null;
                    CaseInsensitiveString PhoneNr = null;
                    string OAuthVersion = null;
                    string OAuthSignatureMethod = null;
                    string OAuthToken = null;
                    string OAuthTokenSecret = null;
                    string OAuthNonce = null;
                    string OAuthTimestamp = null;
                    string OAuthConsumerKey = null;
                    string OAuthSignature = null;
 
                    foreach (XmlNode N2 in E.ChildNodes)
                    {
                        if (N2.LocalName == "field")
                        {
                            string Var = XML.Attribute((XmlElement)N2, "var");
                            string Value = null;
 
                            foreach (XmlNode N3 in N2.ChildNodes)
                            {
                                if (N3.LocalName == "value")
                                {
                                    Value = N3.InnerText;
                                    break;
                                }
                            }
 
                            if (Value is null)
                                continue;
 
                            switch (Var)
                            {
                                case "FORM_TYPE":
                                    FormType = Value;
                                    break;
 
                                case "username":
                                    UserName = Value;
                                    break;
 
                                case "password":
                                    Password = Value;
                                    break;
 
                                case "email":
                                    EMail = Value;
                                    break;
 
                                case "phone":
                                    PhoneNr = Value;
                                    break;
 
                                case "oauth_version":
                                    OAuthVersion = Value;
                                    break;
 
                                case "oauth_signature_method":
                                    OAuthSignatureMethod = Value;
                                    break;
 
                                case "oauth_token":
                                    OAuthToken = Value;
                                    break;
 
                                case "oauth_token_secret":
                                    OAuthTokenSecret = Value;
                                    break;
 
                                case "oauth_nonce":
                                    OAuthNonce = Value;
                                    break;
 
                                case "oauth_timestamp":
                                    OAuthTimestamp = Value;
                                    break;
 
                                case "oauth_consumer_key":
                                    OAuthConsumerKey = Value;
                                    break;
 
                                case "oauth_signature":
                                    OAuthSignature = Value;
                                    break;
 
                                default:
                                    break;
                            }
                        }
                    }
 
                    bool Signed = false;
                    bool Logged = false;
 
                    if (FormType == "urn:xmpp:xdata:signature:oauth1" && OAuthVersion == "1.0" && !string.IsNullOrEmpty(UserName) &&
                        !string.IsNullOrEmpty(Password) && !(EMail is null) && !(PhoneNr is null) && !string.IsNullOrEmpty(OAuthSignatureMethod) &&
                        !string.IsNullOrEmpty(OAuthToken) && !string.IsNullOrEmpty(OAuthTokenSecret) && !string.IsNullOrEmpty(OAuthNonce) &&
                        !string.IsNullOrEmpty(OAuthTimestamp) && !string.IsNullOrEmpty(OAuthConsumerKey) && !string.IsNullOrEmpty(OAuthSignature))
                    {
                        string KeySecret = await this.persistenceLayer.GetApiKeySecret(OAuthConsumerKey);
                        if (!string.IsNullOrEmpty(KeySecret))
                        {
                            StringBuilder PStr = new StringBuilder();
 
                            PStr.Append("email=");
                            PStr.Append(OAuthEncode(EMail));
                            PStr.Append("&FORM_TYPE=");
                            PStr.Append(OAuthEncode(FormType));
                            PStr.Append("&oauth_consumer_key=");
                            PStr.Append(OAuthEncode(OAuthConsumerKey));
                            PStr.Append("&oauth_nonce=");
                            PStr.Append(OAuthEncode(OAuthNonce));
                            PStr.Append("&oauth_signature_method=");
                            PStr.Append(OAuthEncode(OAuthSignatureMethod));
                            PStr.Append("&oauth_timestamp=");
                            PStr.Append(OAuthEncode(OAuthTimestamp));
                            PStr.Append("&oauth_token=");
                            PStr.Append(OAuthEncode(OAuthToken));
                            PStr.Append("&oauth_version=");
                            PStr.Append(OAuthEncode(OAuthVersion));
                            PStr.Append("&password=");
                            PStr.Append(OAuthEncode(Password));
                            PStr.Append("&phone=");
                            PStr.Append(OAuthEncode(PhoneNr));
                            PStr.Append("&username=");
                            PStr.Append(OAuthEncode(UserName));
 
                            StringBuilder BStr = new StringBuilder();
 
                            BStr.Append("submit&&");    // No to-field.
                            BStr.Append(OAuthEncode(PStr.ToString()));
 
                            byte[] Key = Encoding.ASCII.GetBytes(OAuthEncode(KeySecret) + "&" + OAuthEncode(OAuthTokenSecret));
                            byte[] Hash = null;
 
                            switch (OAuthSignatureMethod)
                            {
                                case "HMAC-SHA1":
                                    Hash = Hashes.ComputeHMACSHA1Hash(Key, Encoding.ASCII.GetBytes(BStr.ToString()));
                                    break;
 
                                default:
                                    Logged = true;
                                    LoginAuditor.Fail("Registration form signature failed. Unhandled signature method requested.", UserName, Connection.RemoteEndPoint, Connection.Protocol,
                                        new KeyValuePair<string, object>("ApiKey", OAuthConsumerKey),
                                        new KeyValuePair<string, object>("Method", OAuthSignatureMethod),
                                        new KeyValuePair<string, object>("EMail", EMail?.Value),
                                        new KeyValuePair<string, object>("PhoneNr", PhoneNr?.Value));
                                    break;
                            }
 
                            if (!(Hash is null))
                            {
                                string Signature = OAuthEncode(Convert.ToBase64String(Hash));
                                Signed = Signature == OAuthSignature;
 
                                if (!Signed)
                                {
                                    Logged = true;
                                    LoginAuditor.Fail("Registration form signature failed.", UserName, Connection.RemoteEndPoint, Connection.Protocol,
                                        new KeyValuePair<string, object>("ApiKey", OAuthConsumerKey),
                                        new KeyValuePair<string, object>("Method", OAuthSignatureMethod),
                                        new KeyValuePair<string, object>("EMail", EMail?.Value),
                                        new KeyValuePair<string, object>("PhoneNr", PhoneNr?.Value));
                                }
                            }
                        }
                        else
                        {
                            Logged = true;
                            LoginAuditor.Fail("Registration form signature failed. Invalid API key used.", UserName, Connection.RemoteEndPoint, Connection.Protocol,
                                new KeyValuePair<string, object>("ApiKey", OAuthConsumerKey),
                                new KeyValuePair<string, object>("EMail", EMail?.Value),
                                new KeyValuePair<string, object>("PhoneNr", PhoneNr?.Value));
                        }
                    }
                    else
                    {
                        Logged = true;
                        LoginAuditor.Fail("Registration form signature failed. Signature parameters not provided.", UserName, Connection.RemoteEndPoint, Connection.Protocol);
                    }
 
                    if (Signed)
                    {
                        if (string.IsNullOrEmpty(UserName))
                            await e.IqErrorBadRequest(e.To, "User name cannot be empty.", "en");
 
                        if (UserName.Length > 1023)
                            await e.IqErrorBadRequest(e.To, "User name too long.", "en");
 
                        foreach (char ch in UserName.ToCharArray())
                        {
                            if (char.IsWhiteSpace(ch))
                            {
                                await e.IqErrorNotAllowed(e.To, "White-space characters not allowed in user names.", "en");
                                return;
                            }
                            else if (ch == '@')
                            {
                                await e.IqErrorNotAllowed(e.To, "@ characters not allowed in user names.", "en");
                                return;
                            }
                        }
 
                        if (!IsValidUserName(UserName))
                        {
                            await e.IqErrorBadRequest(e.To, "User Name contains prohibited characters.", "en");
                            return;
                        }
 
                        KeyValuePair<IAccount, string[]> P = await this.persistenceLayer.CreateAccount(OAuthConsumerKey, UserName, Password, EMail, PhoneNr, Connection.RemoteEndPoint);
                        IAccount Account = P.Key;
                        if (Account is null)
                        {
                            string[] Alternatives = P.Value;
                            StringBuilder Xml = new StringBuilder();
 
                            Xml.Append("<conflict xmlns='");
                            Xml.Append(StanzaNamespace);
                            Xml.Append("'/>");
 
                            if (!(Alternatives is null) && Alternatives.Length > 0)
                            {
                                Xml.Append("<alternatives xmlns='");
                                Xml.Append(AlternativesNamespace);
                                Xml.Append("'>");
 
                                foreach (string Alternative in Alternatives)
                                {
                                    Xml.Append("<alternative>");
                                    Xml.Append(XML.Encode(Alternative));
                                    Xml.Append("</alternative>");
                                }
 
                                Xml.Append("</alternatives>");
                            }
 
                            await e.IqError("cancel", Xml.ToString(), e.To,
                                "Account name already exists, or API key limit reached.", "en");
 
                            Logged = true;
                            LoginAuditor.Fail("Registration failed. Signature OK, but account already exists, or API key limit reached.", UserName, Connection.RemoteEndPoint, Connection.Protocol,
                                new KeyValuePair<string, object>("ApiKey", OAuthConsumerKey),
                                new KeyValuePair<string, object>("Method", OAuthSignatureMethod),
                                new KeyValuePair<string, object>("EMail", EMail?.Value),
                                new KeyValuePair<string, object>("PhoneNr", PhoneNr?.Value));
                        }
                        else
                        {
                            await e.IqResult(string.Empty, e.To);
 
                            Logged = true;
                            LoginAuditor.Success("Registration successful and account created.", UserName, Connection.RemoteEndPoint, Connection.Protocol,
                                new KeyValuePair<string, object>("ApiKey", OAuthConsumerKey),
                                new KeyValuePair<string, object>("Method", OAuthSignatureMethod),
                                new KeyValuePair<string, object>("EMail", EMail?.Value),
                                new KeyValuePair<string, object>("PhoneNr", PhoneNr?.Value));
                        }
                    }
                    else
                    {
                        if (!Logged)
                        {
                            LoginAuditor.Fail("Registration form signature failed.", UserName, Connection.RemoteEndPoint, Connection.Protocol,
                                new KeyValuePair<string, object>("ApiKey", OAuthConsumerKey),
                                new KeyValuePair<string, object>("Method", OAuthSignatureMethod),
                                new KeyValuePair<string, object>("EMail", EMail?.Value),
                                new KeyValuePair<string, object>("PhoneNr", PhoneNr?.Value));
                        }
 
                        await e.IqErrorBadRequest(e.To, "Form signature incorrect.", "en");
                    }
 
                    return;
                }
            }
 
            if (Remove)
            {
                if (Count > 1)
                    await e.IqErrorBadRequest(e.To, "Remove element must be only child element.", "en");
                else if (Connection.State != XmppConnectionState.Active)
                    await e.IqErrorForbidden(e.To, "Only allowed to remove your own account, while account is active.", "en");
                else if (!this.IsServerDomain(e.From.Domain, true))
                {
                    await e.IqError("auth", "<registration-required xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>", e.To,
                        "Only accounts registered on the broker can remove their accounts.", "en");
                }
                else if (await this.persistenceLayer.DeleteAccount(e.From.Account, Connection.RemoteEndPoint))
                {
                    await e.IqResult(string.Empty, e.To);
                    Connection.AccountDeleted();
                }
                else
                {
                    await e.IqError("auth", "<registration-required xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>", e.To,
                        "Only accounts registered on the broker can remove their accounts.", "en");
                }
 
                return;
            }
 
            if (!string.IsNullOrEmpty(UserName) && !string.IsNullOrEmpty(Password))
            {
                if (Connection.State != XmppConnectionState.Active || Connection.UserName != UserName ||
                    !await this.persistenceLayer.ChangePassword(UserName, Password))
                {
                    await e.IqErrorNotAllowed(e.To, "Password change not allowed.", "en");
                }
                else
                    await e.IqResult(string.Empty, e.To);
 
                IClientConnection[] CurrentConnections = this.GetClientConnections(e.From.BareJid);
 
                if (!(CurrentConnections is null))
                {
                    foreach (IClientConnection ClientConnection in CurrentConnections)
                    {
                        if (ClientConnection.FullJid != e.From.Address)
                            await ClientConnection.StreamErrorUnauthorized();
                    }
                }
            }
            else
                await e.IqErrorBadRequest(e.To, "Empty user names or passwords not allowed.", "en");
        }
 
        public static bool IsValidUserName(string UserName)
        {
            foreach (char ch in UserName)
            {
                switch (ch)
                {
                    // From XMPP spec (RFC 6122):
                    case '"':
                    case '&':
                    case '\'':
                    case '/':
                    case ':':
                    case '<':
                    case '>':
                    case '@':
 
                    // Disallow space
                    case ' ':
 
                    // Invalid as file name characters (for file sniffers, etc.)
                    //case '"':
                    //case '<':
                    //case '>':
                    case '|':
                    case '\0':
                    case '\u0001':
                    case '\u0002':
                    case '\u0003':
                    case '\u0004':
                    case '\u0005':
                    case '\u0006':
                    case '\a':
                    case '\b':
                    case '\t':
                    case '\n':
                    case '\v':
                    case '\f':
                    case '\r':
                    case '\u000e':
                    case '\u000f':
                    case '\u0010':
                    case '\u0011':
                    case '\u0012':
                    case '\u0013':
                    case '\u0014':
                    case '\u0015':
                    case '\u0016':
                    case '\u0017':
                    case '\u0018':
                    case '\u0019':
                    case '\u001a':
                    case '\u001b':
                    case '\u001c':
                    case '\u001d':
                    case '\u001e':
                    case '\u001f':
                    //case ':':
                    case '*':
                    case '?':
                    case '\\':
                        //case '/':
                        return false;
                }
            }
 
            return true;
        }
 
        private static string OAuthEncode(string s)
        {
            StringBuilder Result = new StringBuilder();
 
            foreach (char ch in s)
            {
                if (OAuthReserved.IndexOf(ch) < 0)
                {
                    Result.Append("%");
                    Result.Append(((int)ch).ToString("X2"));
                }
                else
                    Result.Append(ch);
            }
 
            return Result.ToString();
        }
 
        private const string OAuthReserved = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
 
        #endregion
 
        #region Blocking Command (XEP-0191) and Spam Reporting (XEP-0377).
 
        private async Task BlockListGet(object Sender, IqEventArgs e)
        {
            if (!(e.Sender is IClientConnection Connection) || e.From.BareJid != Connection.BareJid)
            {
                await e.IqErrorForbidden(e.To, "Access to block list can only be granted from the corresponding client.", "en");
                return;
            }
 
            IEnumerable<CaseInsensitiveString> BlockList = await this.persistenceLayer.GetBlockList(Connection.UserName);
            if (BlockList is null)
            {
                await e.IqErrorItemNotFound(e.To, "List not found.", "en");
                return;
            }
 
            Connection.WantsBlockList = true;
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<blocklist xmlns='");
            Xml.Append(BlockingCommandNamespace);
            Xml.Append("'>");
 
            foreach (CaseInsensitiveString Jid in BlockList)
            {
                Xml.Append("<item jid='");
                Xml.Append(Jid);
                Xml.Append("'/>");
            }
 
            Xml.Append("</blocklist>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task BlockSet(object Sender, IqEventArgs e)
        {
            if (!(e.Sender is IClientConnection Connection) || e.From.BareJid != Connection.BareJid)
            {
                await e.IqErrorForbidden(e.To, "Access to block list can only be granted from the corresponding client.", "en");
                return;
            }
 
            BlockingReason Reason = BlockingReason.Other;
            List<CaseInsensitiveString> BareJids = null;
            string Text = string.Empty;
            string TextLanguage = string.Empty;
            CaseInsensitiveString BareJid;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                switch (N.LocalName)
                {
                    case "item":
                        BareJid = XML.Attribute((XmlElement)N, "jid");
                        if (CaseInsensitiveString.IsNullOrEmpty(BareJid))
                        {
                            await e.IqErrorBadRequest(e.To, "Empty JID.", "en");
                            return;
                        }
 
                        BareJids ??= new List<CaseInsensitiveString>();
                        BareJids.Add(BareJid);
                        break;
 
                    case "report":
                        foreach (XmlNode N2 in N.ChildNodes)
                        {
                            switch (N2.LocalName)
                            {
                                case "text":
                                    XmlElement E = (XmlElement)N2;
                                    Text = E.InnerText;
                                    TextLanguage = XML.Attribute(E, "xml:lang");
                                    break;
 
                                case "spam":
                                    Reason = BlockingReason.Spam;
                                    break;
 
                                case "abuse":
                                    Reason = BlockingReason.Abuse;
                                    break;
                            }
                        }
                        break;
                }
            }
 
            if (BareJids is null)
            {
                await e.IqErrorBadRequest(e.To, "Empty list.", "en");
                return;
            }
 
            StringBuilder Xml = null;
 
            foreach (CaseInsensitiveString BareJid2 in BareJids)
            {
                if (await this.persistenceLayer.AddBlock(Connection.UserName, BareJid2, Reason, Text, TextLanguage))
                {
                    IClientConnection[] Connections = this.GetClientConnections(Connection.BareJid);
 
                    if (!(Connections is null))
                    {
                        foreach (IClientConnection Connection2 in Connections)
                        {
                            if (Connection2 != Connection && Connection2.WantsBlockList)
                            {
                                if (Xml is null)
                                    Xml = new StringBuilder();
                                else
                                    Xml.Clear();
 
                                Xml.Append("<block xmlns='");
                                Xml.Append(BlockingCommandNamespace);
                                Xml.Append("'><item jid='");
                                Xml.Append(BareJid2);
                                Xml.Append("'/></block>");
 
                                try
                                {
                                    await Connection2.IQ("set", string.Empty, Connection2.Address, e.To, string.Empty, Xml.ToString(), this);
                                }
                                catch (Exception ex)
                                {
                                    Connection.Exception(ex);
                                    await Connection.DisposeAsync();
                                }
                            }
                        }
                    }
                }
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        private async Task UnblockSet(object Sender, IqEventArgs e)
        {
            if (!(e.Sender is IClientConnection Connection) || e.From.BareJid != Connection.BareJid)
            {
                await e.IqErrorForbidden(e.To, "Access to block list can only be granted from the corresponding client.", "en");
                return;
            }
 
            List<CaseInsensitiveString> BareJids = null;
            CaseInsensitiveString BareJid;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N.LocalName == "item")
                {
                    BareJid = XML.Attribute((XmlElement)N, "jid");
                    if (CaseInsensitiveString.IsNullOrEmpty(BareJid))
                    {
                        await e.IqErrorBadRequest(e.To, "Empty JID.", "en");
                        return;
                    }
 
                    BareJids ??= new List<CaseInsensitiveString>();
                    BareJids.Add(BareJid);
                }
            }
 
            if (BareJids is null)
            {
                if (await this.persistenceLayer.ClearBlocks(Connection.UserName))
                {
                    IClientConnection[] Connections = this.GetClientConnections(Connection.BareJid);
 
                    if (!(Connections is null))
                    {
                        foreach (IClientConnection Connection2 in Connections)
                        {
                            if (Connection2 != Connection && Connection2.WantsBlockList)
                            {
                                try
                                {
                                    await Connection2.IQ("set", string.Empty, Connection2.Address, e.To, string.Empty,
                                        "<unblock xmlns='" + BlockingCommandNamespace + "'/>", this);
                                }
                                catch (Exception ex)
                                {
                                    try
                                    {
                                        Connection.Exception(ex);
                                        await Connection.DisposeAsync();
                                    }
                                    catch (Exception ex2)
                                    {
                                        Log.Exception(ex2);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                StringBuilder Xml = null;
 
                foreach (CaseInsensitiveString BareJid2 in BareJids)
                {
                    if (await this.persistenceLayer.Unblock(Connection.UserName, BareJid2))
                    {
                        IClientConnection[] Connections = this.GetClientConnections(Connection.BareJid);
 
                        if (!(Connections is null))
                        {
                            foreach (IClientConnection Connection2 in Connections)
                            {
                                if (Connection2 != Connection && Connection2.WantsBlockList)
                                {
                                    if (Xml is null)
                                        Xml = new StringBuilder();
                                    else
                                        Xml.Clear();
 
                                    Xml.Append("<unblock xmlns='");
                                    Xml.Append(BlockingCommandNamespace);
                                    Xml.Append("'><item jid='");
                                    Xml.Append(BareJid2);
                                    Xml.Append("'/></unblock>");
 
                                    try
                                    {
                                        await Connection2.IQ("set", string.Empty, Connection2.Address, e.To, string.Empty, Xml.ToString(), this);
                                    }
                                    catch (Exception ex)
                                    {
                                        Connection.Exception(ex);
                                        await Connection.DisposeAsync();
                                    }
                                }
                            }
                        }
                    }
                }
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        #endregion
 
        #region Sniffers
 
        internal XmlFileSniffer GetSniffer(string Key, bool S2S)
        {
            string FileName;
 
            if (S2S)
                FileName = this.domainSnifferPath.Replace("%DOMAIN%", Key);
            else
                FileName = this.clientSnifferPath.Replace("%ENDPOINT%", Key);
 
            if (!(this.sniffers is null) && this.sniffers.TryGetValue(FileName, out XmlFileSniffer XmlFileSniffer))
                return XmlFileSniffer;
 
            if (S2S)
            {
                if (this.s2sEndpoints.TryGetValue(Key, out IS2SEndpoint Endpoint) &&
                    Endpoint.HasSniffers)
                {
                    foreach (ISniffer Sniffer in Endpoint.Sniffers)
                    {
                        if (Sniffer is XmlFileSniffer XmlFileSniffer2)
                            return XmlFileSniffer2;
                    }
                }
            }
            else
            {
                IClientConnection[] Connections = this.GetClientConnections(Key + "@" + this.domain);
                if (!(Connections is null))
                {
                    foreach (IClientConnection Connection in Connections)
                    {
                        if (Connection is ICommunicationLayer ComLayer && ComLayer.HasSniffers)
                        {
                            foreach (ISniffer Sniffer in ComLayer.Sniffers)
                            {
                                if (Sniffer is XmlFileSniffer XmlFileSniffer2)
                                    return XmlFileSniffer2;
                            }
                        }
                    }
                }
            }
 
            return new XmlFileSniffer(FileName, this.GetTransformPath(S2S), 7, BinaryPresentationMethod.ByteCount);
        }
 
        internal async Task CacheSniffers(IEnumerable<ISniffer> Sniffers)
        {
            foreach (ISniffer Sniffer in Sniffers)
            {
                if (Sniffer is XmlFileSniffer XmlFileSniffer)
                    this.CacheSniffer(XmlFileSniffer);
                else if (Sniffer is IDisposableAsync DisposableAsync)
                    await DisposableAsync.DisposeAsync();
                else if (Sniffer is IDisposable Disposable)
                    Disposable.Dispose();
            }
        }
 
        internal void CacheSniffer(XmlFileSniffer Sniffer)
        {
            if (this.sniffers is null)
            {
                this.sniffers = new Cache<CaseInsensitiveString, XmlFileSniffer>(int.MaxValue, TimeSpan.MaxValue, new TimeSpan(1, 1, 0), true);
                this.sniffers.Removed += this.Sniffers_Removed;
            }
 
            this.sniffers.Add(Sniffer.FileName, Sniffer);
        }
 
        private Task Sniffers_Removed(object Sender, CacheItemEventArgs<CaseInsensitiveString, XmlFileSniffer> e)
        {
            if (this.disposed || (DateTime.Now - e.Value.LastEvent).TotalMinutes > 30)
                return e.Value.DisposeAsync();
            else
                return Task.CompletedTask;
        }
 
        #endregion
 
        #region Statistics
 
        internal void DataReceived(int NrRead)
        {
            lock (this.statSync)
            {
                this.nrBytesRx += NrRead;
            }
        }
 
        internal void DataTransmitted(int NrWritten)
        {
            lock (this.statSync)
            {
                this.nrBytesTx += NrWritten;
            }
        }
 
        internal void IncCounters(string Stanza, string Type, XmppAddress From, XmppAddress To, XmlElement StanzaElement)
        {
            string Namespace = null;
            string LocalName = null;
            string LocalNameBak = null;
            string ns = StanzaElement.NamespaceURI;
 
            foreach (XmlNode N in StanzaElement.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    if (E.NamespaceURI != ns)
                    {
                        Namespace = E.NamespaceURI;
                        LocalName = E.LocalName;
                        break;
                    }
                    else
                        LocalNameBak ??= E.LocalName;
                }
            }
 
            if (Namespace is null)
            {
                Namespace = StanzaElement.NamespaceURI;
                LocalName = LocalNameBak ?? string.Empty;
            }
 
            lock (this.statSync)
            {
                this.nrStanzas++;
 
                this.IncLocked(Stanza + "#" + Type, this.stanzasPerStanzaType);
                this.IncLocked(From.Domain, this.stanzasPerFromDomain);
                this.IncLocked(From.BareJid, this.stanzasPerFromBareJid);
                this.IncLocked(To.Domain, this.stanzasPerToDomain);
                this.IncLocked(To.BareJid, this.stanzasPerToBareJid);
                this.IncLocked(Namespace, this.stanzasPerNamespace);
                this.IncLocked(Namespace + "#" + LocalName, this.stanzasPerFqn);
            }
        }
 
        private void IncLocked(string Key, Dictionary<string, Statistic> Stat)
        {
            if (!Stat.TryGetValue(Key, out Statistic Rec))
            {
                Rec = new Statistic(1);
                Stat[Key] = Rec;
            }
            else
                Rec.Inc();
        }
 
        public Statistics.CommunicationStatistics GetCommunicationStatisticsSinceLast()
        {
            Statistics.CommunicationStatistics Result;
            DateTime TP = DateTime.Now;
 
            lock (this.statSync)
            {
                Result = new Statistics.CommunicationStatistics()
                {
                    StanzasPerStanzaType = this.stanzasPerStanzaType,
                    StanzasPerFromDomain = this.stanzasPerFromDomain,
                    StanzasPerToDomain = this.stanzasPerToDomain,
                    StanzasPerFromBareJid = this.stanzasPerFromBareJid,
                    StanzasPerToBareJid = this.stanzasPerToBareJid,
                    StanzasPerNamespace = this.stanzasPerNamespace,
                    StanzasPerFqn = this.stanzasPerFqn,
                    LastStat = this.lastStat,
                    CurrentStat = TP,
                    NrBytesRx = this.nrBytesRx,
                    NrBytesTx = this.nrBytesTx,
                    NrStanzas = this.nrStanzas
                };
 
                this.stanzasPerStanzaType = new Dictionary<string, Statistic>();
                this.stanzasPerFromDomain = new Dictionary<string, Statistic>();
                this.stanzasPerToDomain = new Dictionary<string, Statistic>();
                this.stanzasPerFromBareJid = new Dictionary<string, Statistic>();
                this.stanzasPerToBareJid = new Dictionary<string, Statistic>();
                this.stanzasPerNamespace = new Dictionary<string, Statistic>();
                this.stanzasPerFqn = new Dictionary<string, Statistic>();
                this.lastStat = TP;
                this.nrBytesRx = 0;
                this.nrBytesTx = 0;
                this.nrStanzas = 0;
            }
 
            return Result;
        }
 
        #endregion
 
        #region XEP-0049: Private XML Storage
 
        internal async Task PrivateXmlStorageGet(object Sender, IqEventArgs e)
        {
            if (!this.clientConnections.TryGetValue(e.From.Address, out IClientConnection Connection))
            {
                await e.IqErrorForbidden(e.To, "Private storage only accessible from clients directly connected to the server.", "en");
                return;
            }
 
            IAccount FromAccount = await this.persistenceLayer.GetAccount(Connection.UserName);
            if (FromAccount is null)
            {
                await e.IqErrorItemNotFound(e.To, "Account no longer found.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
            bool Empty = true;
            bool Found;
 
            Xml.Append("<query xmlns='");
            Xml.Append(PrivateXmlStorageNamespace);
            Xml.Append("'>");
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    Empty = false;
                    Found = false;
 
                    foreach (PersistedElement Element in await Database.Find<PersistedElement>(new FilterAnd(
                        new FilterFieldEqualTo("Account", FromAccount.UserName),
                        new FilterFieldEqualTo("Namespace", E.NamespaceURI),
                        new FilterFieldEqualTo("LocalName", E.LocalName))))
                    {
                        if (Found)
                            await Database.Delete(Element);
                        else
                        {
                            Xml.Append(Element.Xml);
                            Found = true;
                        }
                    }
 
                    if (!Found)
                    {
                        await e.IqErrorItemNotFound(e.To, "Element not found.", "en");
                        return;
                    }
                }
            }
 
            if (Empty)
            {
                await e.IqErrorBadRequest(e.To, "Query is empty.", "en");
                return;
            }
 
            Xml.Append("</query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        internal async Task PrivateXmlStorageSet(object Sender, IqEventArgs e)
        {
            if (!this.clientConnections.TryGetValue(e.From.Address, out IClientConnection Connection))
            {
                await e.IqErrorForbidden(e.To, "Private storage only accessible from clients directly connected to the server.", "en");
                return;
            }
 
            IAccount FromAccount = await this.persistenceLayer.GetAccount(Connection.UserName);
            if (FromAccount is null)
            {
                await e.IqErrorItemNotFound(e.To, "Account no longer found.", "en");
                return;
            }
 
            bool Empty = true;
            bool Found;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    bool DeleteElement = IsEmptyPrivateXml(E);
 
                    Found = false;
                    Empty = false;
 
                    foreach (PersistedElement Element in await Database.Find<PersistedElement>(new FilterAnd(
                        new FilterFieldEqualTo("Account", FromAccount.UserName),
                        new FilterFieldEqualTo("Namespace", E.NamespaceURI),
                        new FilterFieldEqualTo("LocalName", E.LocalName))))
                    {
                        if (Found)
                            await Database.Delete(Element);
                        else
                        {
                            if (DeleteElement)
                                await Database.Delete(Element);
                            else
                            {
                                Element.Xml = E.OuterXml;
                                Element.Updated = DateTime.UtcNow;
 
                                await Database.Update(Element);
                            }
 
                            Found = true;
                        }
                    }
 
                    if (Found || DeleteElement)
                        continue;
 
                    DateTime TP = DateTime.UtcNow;
 
                    await Database.Insert(new PersistedElement()
                    {
                        Account = FromAccount.UserName,
                        Namespace = E.NamespaceURI,
                        LocalName = E.LocalName,
                        Created = TP,
                        Updated = TP,
                        Xml = E.OuterXml
                    });
                }
            }
 
            if (Empty)
                await e.IqErrorNotAcceptable(e.To, "Empty query element.", "en");
            else
                await e.IqResult(string.Empty, e.To);
        }
 
        private static bool IsEmptyPrivateXml(XmlElement E)
        {
            if (E.HasChildNodes)
                return false;
 
            foreach (XmlAttribute Attr in E.Attributes)
            {
                if (Attr.Name != "xmlns")
                    return false;
            }
 
            return true;
        }
 
        #endregion
 
        #region SMTP integration
 
        private Task SmtpServer_MessageReceived(object Sender, SmtpMessageEventArgs e)
        {
            return this.ProcessMessage(e.Message);
        }
 
        public async Task ProcessMessage(SmtpMessage Message)
        {
            try
            {
                List<KeyValuePair<string, object>> Tags = new List<KeyValuePair<string, object>>();
 
                foreach (KeyValuePair<string, string> P in Message.AllHeaders)
                    Tags.Add(new KeyValuePair<string, object>(P.Key, P.Value));
 
                Log.Informational("Mail received.", Tags.ToArray());
 
                /*try
                {
                    string FileName = @"C:\ProgramData\IoT Gateway\SMTP\" + Guid.NewGuid().ToString();
                    await Resources.WriteAllBytesAsync(FileName + ".bin", Message.TransformedBody ?? Message.UntransformedBody);
                    await Files.WriteAllTextAsync(FileName + ".txt", Message.ContentType);
                    Log.Informational("Incoming mail saved to disk: " + FileName);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }*/
 
                Dictionary<CaseInsensitiveString, bool> Processed = new Dictionary<CaseInsensitiveString, bool>();
 
                await this.ProcessMessage(Message, Message.To, Processed);
                await this.ProcessMessage(Message, Message.Cc, Processed);
                await this.ProcessMessage(Message, Message.Bcc, Processed);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async Task ProcessMessage(SmtpMessage Message, IEnumerable<MailAddress> Recipients, Dictionary<CaseInsensitiveString, bool> Processed)
        {
            if (!(Recipients is null))
            {
                foreach (MailAddress Recipient in Recipients)
                {
                    if (!Processed.ContainsKey(Recipient.Address))
                    {
                        Processed[Recipient.Address] = true;
                        await this.ProcessMessage(Message, Recipient);
                    }
                }
            }
        }
 
        private readonly Dictionary<string, DateTime> lastBounce = new Dictionary<string, DateTime>();
 
        private bool CanReturnBounceMessage(MailAddress Recipient, MailAddress Sender)
        {
            string Key = Recipient.Address + " | " + Sender.Address;
            DateTime TP;
 
            lock (this.lastBounce)
            {
                if (this.lastBounce.ContainsKey(Key))
                    return false;
            }
 
            TP = scheduler.Add(DateTime.Now.AddHours(4), (P) =>
            {
                lock (this.lastBounce)
                {
                    this.lastBounce.Remove((string)P);
                }
            }, Key);
 
            lock (this.lastBounce)
            {
                this.lastBounce[Key] = TP;
            }
 
            return true;
        }
 
        private async Task ProcessMessage(SmtpMessage Message, MailAddress Recipient)
        {
            try
            {
                XmppAddress Addr = new XmppAddress(Recipient.Address);
                if (this.IsServerDomain(Addr.Domain, true))
                {
                    IRosterItem Item = await this.persistenceLayer.GetRosterItem(Addr.Account, Message.FromMail.Address);
                    StringBuilder Markdown;
 
                    if (Item is null ||
                        (Item.Subscription != SubscriptionStatus.both &&
                        Item.Subscription != SubscriptionStatus.from &&
                        Item.Subscription != SubscriptionStatus.to))        // If not white-listed
                    {
                        if (!this.CanReturnBounceMessage(Recipient, Message.FromMail))
                        {
                            Log.Notice("Mail discarded.", Recipient.Address, Message.FromMail.Address);
                            return;
                        }
 
                        Markdown = new StringBuilder();
 
                        Markdown.AppendLine("Welcome");
                        Markdown.AppendLine("===========");
                        Markdown.AppendLine();
 
                        Markdown.Append("The mail server at **");
                        Markdown.Append(MarkdownDocument.Encode(this.domain));
                        Markdown.AppendLine("** only forwards mail messages from approved senders.");
                        Markdown.Append("Since **");
                        Markdown.Append(MarkdownDocument.Encode(Message.FromMail.Address));
                        Markdown.Append("** has not been approved by **");
                        Markdown.Append(MarkdownDocument.Encode(Recipient.Address));
                        Markdown.AppendLine("**, your mail has not been forwarded.");
                        Markdown.AppendLine();
 
                        if (this.httpServer.OpenHttpsPorts.Length > 0 || this.httpServer.OpenHttpPorts.Length > 0)
                        {
                            Markdown.Append("If you want, you can send a request to **");
                            Markdown.Append(MarkdownDocument.Encode(Recipient.Address));
                            Markdown.Append("** to become approved, by following this link: [Request approval](");
                            Markdown.Append("http");
 
                            if (this.httpServer.OpenHttpsPorts.Length > 0)
                            {
                                Markdown.Append("s://");
                                Markdown.Append(this.domain);
 
                                if (Array.IndexOf(this.httpServer.OpenHttpsPorts, HttpServer.DefaultHttpsPort) < 0)
                                {
                                    Markdown.Append(':');
                                    Markdown.Append(this.httpServer.OpenHttpsPorts[0]);
                                }
                            }
                            else
                            {
                                Markdown.Append("://");
                                Markdown.Append(this.domain);
 
                                if (Array.IndexOf(this.httpServer.OpenHttpPorts, HttpServer.DefaultHttpPort) < 0)
                                {
                                    Markdown.Append(':');
                                    Markdown.Append(this.httpServer.OpenHttpPorts[0]);
                                }
                            }
 
                            string Expires = DateTime.Now.AddDays(1).Ticks.ToString();
 
                            Markdown.Append("/RequestWhiteList?Sender=");
                            Markdown.Append(XML.HtmlValueEncode(Message.FromMail.Address));
                            Markdown.Append("&Receiver=");
                            Markdown.Append(XML.HtmlValueEncode(Recipient.Address));
                            Markdown.Append("&Expires=P");
                            Markdown.Append(Expires);
                            Markdown.Append("&MAC=");
 
                            StringBuilder sb = new StringBuilder();
                            sb.Append(Message.FromMail.Address);
                            sb.Append(" | ");
                            sb.Append(Recipient.Address);
                            sb.Append(" | ");
                            sb.Append(Expires);
 
                            if (RequestWhiteList.whiteListKey is null)
                            {
                                string Key = await RuntimeSettings.GetAsync("WhiteList.Key", string.Empty);
                                if (string.IsNullOrEmpty(Key))
                                {
                                    Key = Convert.ToBase64String(GetRandomNumbers(32));
                                    await RuntimeSettings.SetAsync("WhiteList.Key", Key);
                                }
 
                                RequestWhiteList.whiteListKey = Key;
                            }
 
                            string MAC = Hashes.ComputeHMACSHA256HashString(System.Convert.FromBase64String(RequestWhiteList.whiteListKey),
                                Encoding.UTF8.GetBytes(sb.ToString()));
 
                            Markdown.Append(MAC);
                            Markdown.AppendLine(")");
                            Markdown.AppendLine();
 
                            Log.Notice("Mail discarded. Bounce message returned.", Recipient.Address, Message.FromMail.Address,
                                new KeyValuePair<string, object>("Sender", Message.FromMail.Address),
                                new KeyValuePair<string, object>("Receiver", Recipient.Address),
                                new KeyValuePair<string, object>("Expires", Expires),
                                new KeyValuePair<string, object>("MAC", MAC));
                        }
 
                        await this.SendMailMessage(Recipient.Address, Message.FromMail.Address, "Approval required", Markdown.ToString());
                    }
                    else
                    {
                        XmppAddress From = new XmppAddress(Message.FromMail.Address);
                        XmppAddress To = new XmppAddress(Recipient.Address);
                        ISender Sender = await this.GetS2sEndpoint(To.Domain, From.Domain, true, "Forwarding e-mail.");
                        List<EmbeddedContent> Attachments = null;
                        List<EmbeddedContent> Inline = null;
                        object Decoded = Message.DecodedBody;
                        string PlainText = null;
                        HtmlDocument Html = null;
                        MarkdownDocument MarkdownDocument = null;
 
                        if (!(Sender is null))
                        {
                            if (!(Message.Attachments is null) && Message.Attachments.Length > 0)
                            {
                                Attachments = new List<EmbeddedContent>();
                                Attachments.AddRange(Message.Attachments);
                            }
 
                            if (!(Message.InlineObjects is null) && Message.InlineObjects.Length > 0)
                            {
                                Inline = new List<EmbeddedContent>();
                                Inline.AddRange(Message.InlineObjects);
                            }
 
                            if (!(Decoded is null) && Decoded is MultipartContent MultipartContent)
                            {
                                LinkedList<MultipartContent> ToProcess = new LinkedList<MultipartContent>();
 
                                ToProcess.AddLast(MultipartContent);
                                Decoded = null;
 
                                while (!(ToProcess.First is null))
                                {
                                    MultipartContent = ToProcess.First.Value;
                                    ToProcess.RemoveFirst();
 
                                    if (MultipartContent is ContentAlternatives ContentAlternatives)
                                    {
                                        foreach (EmbeddedContent EmbeddedContent in ContentAlternatives.Content)
                                        {
                                            if (PlainText is null && EmbeddedContent.Decoded is string s2)
                                                PlainText = s2;
                                            else if (Html is null && EmbeddedContent.Decoded is HtmlDocument Html2)
                                                Html = Html2;
                                            else if (MarkdownDocument is null && EmbeddedContent.Decoded is MarkdownDocument MarkdownDocument2)
                                                MarkdownDocument = MarkdownDocument2;
                                            else if (EmbeddedContent.Decoded is MultipartContent MultipartContent2)
                                                ToProcess.AddLast(MultipartContent2);
                                            else if (Decoded is null)
                                                Decoded = EmbeddedContent.Decoded;
                                            else
                                            {
                                                Attachments ??= new List<EmbeddedContent>();
                                                Attachments.Add(EmbeddedContent);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        foreach (EmbeddedContent EmbeddedContent in MultipartContent.Content)
                                        {
                                            switch (EmbeddedContent.Disposition)
                                            {
                                                case ContentDisposition.Attachment:
                                                    Attachments ??= new List<EmbeddedContent>();
                                                    Attachments.Add(EmbeddedContent);
                                                    break;
 
                                                case ContentDisposition.Inline:
                                                    Inline ??= new List<EmbeddedContent>();
                                                    Inline.Add(EmbeddedContent);
                                                    break;
 
                                                default:
                                                    if (EmbeddedContent.Decoded is MultipartContent MultipartContent2)
                                                        ToProcess.AddLast(MultipartContent2);
                                                    else if (Decoded is null)
                                                        Decoded = EmbeddedContent.Decoded;
                                                    else
                                                    {
                                                        Attachments ??= new List<EmbeddedContent>();
                                                        Attachments.Add(EmbeddedContent);
                                                    }
                                                    break;
                                            }
                                        }
                                    }
                                }
                            }
 
                            if (!(Decoded is null))
                            {
                                if (PlainText is null && Decoded is string s)
                                    PlainText = s;
                                else if (Html is null && Decoded is HtmlDocument Html2)
                                    Html = Html2;
                                else if (MarkdownDocument is null && Decoded is MarkdownDocument MarkdownDocument2)
                                    MarkdownDocument = MarkdownDocument2;
                            }
 
                            if (!(MarkdownDocument is null))
                            {
                                // TODO: Check message, and block items that can pose a security issue (for instance, inclusion script, javascript, etc.).
 
                                if (string.IsNullOrEmpty(PlainText))
                                    PlainText = await MarkdownDocument.GeneratePlainText();
 
                                Html ??= new HtmlDocument(await MarkdownDocument.GenerateHTML());
                            }
 
                            StringBuilder Content = new StringBuilder();
                            bool HasBody = false;
 
                            if (!string.IsNullOrEmpty(Message.Subject))
                            {
                                Content.Append("<subject>");
                                Content.Append(XML.Encode(Message.Subject));
                                Content.Append("</subject>");
                            }
 
                            if (!string.IsNullOrEmpty(Message.MessageID))
                            {
                                Content.Append("<thread>");
                                Content.Append(XML.Encode(Message.MessageID));
                                Content.Append("</thread>");
                            }
 
                            if (!string.IsNullOrEmpty(PlainText))
                            {
                                Content.Append("<body>");
                                Content.Append(XML.Encode(PlainText));
                                Content.Append("</body>");
 
                                HasBody = true;
                            }
 
                            if (!(Html?.Body is null))
                            {
                                Content.Append("<html xmlns='http://jabber.org/protocol/xhtml-im'>");
                                Content.Append("<body xmlns='http://www.w3.org/1999/xhtml'>");
 
                                if (Html.Body.HasChildren)
                                {
                                    foreach (HtmlNode N2 in Html.Body.Children)
                                        this.XmlEncode(N2, Content);
                                }
 
                                Content.Append("</body></html>");
 
                                HasBody = true;
                            }
 
                            if (!(MarkdownDocument is null))
                            {
                                Content.Append("<content xmlns='");
                                Content.Append(ContentNamespace);
                                Content.Append("' type='text/markdown'>");
                                Content.Append(XML.HtmlValueEncode(await MarkdownDocument.GenerateMarkdown(true)));
                                Content.Append("</content>");
 
                                HasBody = true;
                            }
 
                            if (!HasBody)
                            {
                                Markdown = new StringBuilder();
 
                                Markdown.AppendLine("Unable to process incoming message");
                                Markdown.AppendLine("=======================================");
                                Markdown.AppendLine();
 
                                Markdown.Append("The mail server at **");
                                Markdown.Append(MarkdownDocument.Encode(this.domain));
                                Markdown.AppendLine("** was unable to forward the mail message to **");
                                Markdown.Append(MarkdownDocument.Encode(Recipient.Address));
                                Markdown.Append("**), since the content type `");
                                Markdown.Append(Message.ContentType);
                                Markdown.AppendLine("` is not handled.");
 
                                await this.SendMailMessage(Recipient.Address, Message.FromMail.Address, "Unable to process incoming message", Markdown.ToString());
 
                                Log.Notice("Mail discarded due to unhandled Content-Type.", Recipient.Address, Message.FromMail.Address,
                                    new KeyValuePair<string, object>("Content-Type", Message.ContentType));
 
                                return;
                            }
 
                            Content.Append("<mailInfo xmlns='urn:xmpp:smtp' contentType='");
                            Content.Append(XML.Encode(Message.ContentType));
 
                            if (!string.IsNullOrEmpty(Message.MessageID))
                            {
                                Content.Append("' id='");
                                Content.Append(XML.Encode(Message.MessageID));
                            }
 
                            Content.Append("' priority='");
                            Content.Append(((int)Message.Priority).ToString());
 
                            if (Message.Date.HasValue)
                            {
                                Content.Append("' date='");
                                Content.Append(XML.Encode(Message.Date.Value));
                            }
 
                            Content.Append("' fromMail='");
                            Content.Append(XML.Encode(Message.FromMail.Address));
 
                            Content.Append("' fromHeader='");
                            Content.Append(XML.Encode(Message.FromHeader.ToString()));
 
                            Content.Append("' sender='");
                            Content.Append(XML.Encode(Message.Sender.ToString()));
 
                            DateTime TP = DateTime.Now;
                            MailContent MailContent = new MailContent()
                            {
                                BareJid = Addr.BareJid,
                                ContentType = Message.ContentType,
                                Content = Message.TransformedBody ?? Message.UntransformedBody,
                                Created = TP,
                                ContentId = Guid.NewGuid().ToString()
                            };
 
                            await Database.Insert(MailContent);
 
                            Content.Append("' size='");
                            Content.Append((MailContent.Content?.Length ?? 0).ToString());
 
                            Content.Append("' cid='");
                            Content.Append(MailContent.ContentId);
 
                            Content.Append("'><headers xmlns='http://jabber.org/protocol/shim'>");
 
                            foreach (KeyValuePair<string, string> P in Message.AllHeaders)
                            {
                                Content.Append("<header name='");
                                Content.Append(XML.Encode(P.Key));
                                Content.Append("'>");
                                Content.Append(XML.Encode(P.Value));
                                Content.Append("</header>");
                            }
 
                            Content.Append("</headers>");
 
                            await this.Serialize(Content, Attachments?.ToArray(), "attachment", Addr);
                            await this.Serialize(Content, Inline?.ToArray(), "inline", Addr);
 
                            Content.Append("</mailInfo>");
 
                            await this.Message("chat", string.Empty, To, From, string.Empty, Content.ToString(), Sender);
                        }
                    }
                }
                else    // Relay to other domain
                {
                    IS2SEndpoint S2sEndpoint = await this.GetS2sEndpoint(this.domain, Addr.Domain, true, "Relaying incoming mail message.");
                    if (S2sEndpoint is SmtpS2SEndpoint SmtpS2SEndpoint)
                        await SmtpS2SEndpoint.RelayMessage(Message, Recipient);     // Only relay to other SMTP servers
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private void XmlEncode(HtmlNode N, StringBuilder Output)
        {
            if (N is HtmlElement E)
            {
                if (E.HasPrefix)
                    return;
 
                switch (E.LocalName.ToUpper())
                {
                    case "SCRIPT":
                    case "META":
                    case "STYLE":
                    case "APPLET":
                    case "EMBED":
                    case "IFRAME":
                    case "NOEMBED":
                    case "OBJECT":
                    case "PARAM":
                    case "CANVAS":
                    case "NOSCRIPT":
                    case "BUTTON":
                    case "FORM":
                    case "INPUT":
                    case "OUTPUT":
                    case "SELECT":
                    case "TEXTAREA":
                    case "DETAILS":
                    case "DIALOG":
                    case "MENU":
                    case "MENUITEM":
                    case "SUMMARY":
                    case "CONTENT":
                    case "ELEMENT":
                    case "SHADOW":
                    case "SLOT":
                    case "TEMPLATE":
                    case "COMMAND":
                    case "DIR":
                    case "FRAME":
                    case "FRAMESET":
                        return;
                }
 
                Output.Append('<');
                Output.Append(E.LocalName);
 
                if (E.HasAttributes)
                {
                    foreach (HtmlAttribute Attr in E.Attributes)
                    {
                        if (Attr.HasPrefix)
                            continue;
 
                        Output.Append(' ');
                        Output.Append(Attr.LocalName);
                        Output.Append("=\"");
                        Output.Append(XML.HtmlAttributeEncode(Attr.Value));
                        Output.Append('"');
                    }
                }
 
                if (E.HasChildren)
                {
                    Output.Append('>');
 
                    foreach (HtmlNode N2 in E.Children)
                        this.XmlEncode(N2, Output);
 
                    Output.Append("</");
                    Output.Append(E.LocalName);
                    Output.Append('>');
                }
                else if (E.IsEmptyElement)
                    Output.Append("/>");
                else
                {
                    Output.Append("></");
                    Output.Append(E.LocalName);
                    Output.Append('>');
                }
            }
            else if (N is HtmlText Text)
                Output.Append(XML.Encode(Text.InlineText));
            else if (N is HtmlEntity Entity)
            {
                if (N is HtmlEntityUnicode EntityUnicode)
                {
                    char ch = (char)EntityUnicode.Code;
 
                    switch (ch)
                    {
                        case '<':
                            Output.Append("&lt;");
                            break;
 
                        case '>':
                            Output.Append("&gt;");
                            break;
 
                        case '"':
                            Output.Append("&quot;");
                            break;
 
                        case '\'':
                            Output.Append("&apos;");
                            break;
 
                        case '&':
                            Output.Append("&amp;");
                            break;
 
                        default:
                            Output.Append(ch);
                            break;
                    }
                }
                else
                {
                    switch (Entity.EntityName.ToLower())
                    {
                        case "lt":
                        case "gt":
                        case "quot":
                        case "apos":
                        case "amp":
                            Output.Append('&');
                            Output.Append(Entity.EntityName);
                            Output.Append(';');
                            break;
 
                        default:
                            Output.Append(HtmlEntity.EntityToCharacter(Entity.EntityName));
                            break;
                    }
                }
            }
            else if (N is CDATA CDATA)
                Output.Append(XML.Encode(CDATA.Content));
        }
 
        private async Task Serialize(StringBuilder Content, IEnumerable<EmbeddedContent> Objects, string ElementName, XmppAddress Recipient)
        {
            if (!(Objects is null))
            {
                foreach (EmbeddedContent EmbeddedContent in Objects)
                {
                    MailContent MailContent = new MailContent()
                    {
                        BareJid = Recipient.BareJid,
                        ContentType = EmbeddedContent.ContentType,
                        Content = EmbeddedContent.TransferDecoded ?? EmbeddedContent.Raw,
                        Created = DateTime.Now,
                        ContentId = Guid.NewGuid().ToString()
                    };
 
                    await Database.Insert(MailContent);
 
                    Content.Append('<');
                    Content.Append(ElementName);
                    Content.Append(" contentType='");
                    Content.Append(XML.Encode(EmbeddedContent.ContentType));
 
                    if (!string.IsNullOrEmpty(EmbeddedContent.Description))
                    {
                        Content.Append("' description='");
                        Content.Append(XML.Encode(EmbeddedContent.Description));
                    }
 
                    if (!string.IsNullOrEmpty(EmbeddedContent.FileName))
                    {
                        Content.Append("' fileName='");
                        Content.Append(XML.Encode(EmbeddedContent.FileName));
                    }
 
                    if (!string.IsNullOrEmpty(EmbeddedContent.Name))
                    {
                        Content.Append("' name='");
                        Content.Append(XML.Encode(EmbeddedContent.Name));
                    }
 
                    if (!string.IsNullOrEmpty(EmbeddedContent.ID))
                    {
                        Content.Append("' id='");
                        Content.Append(XML.Encode(EmbeddedContent.ID));
                    }
 
                    Content.Append("' cid='");
                    Content.Append(XML.Encode(MailContent.ContentId));
 
                    Content.Append("' size='");
                    Content.Append((MailContent.Content?.Length ?? 0).ToString());
 
                    Content.Append("'/>");
                }
            }
        }
 
        private async Task GetMailContent(object Sender, IqEventArgs e)
        {
            string ContentId = XML.Attribute(e.Query, "cid");
            string ContentType = XML.Attribute(e.Query, "type");
 
            MailContent Content = await Database.FindFirstDeleteRest<MailContent>(new FilterFieldEqualTo("ContentId", ContentId));
            if (Content is null)
            {
                await e.IqErrorItemNotFound(e.To, "Mail content item not found.", "en");
                return;
            }
 
            if (Content.BareJid != e.From.BareJid)
            {
                await e.IqErrorForbidden(e.To, "Not authorized access.", "en");
                return;
            }
 
            byte[] Data = null;
 
            if (!string.IsNullOrEmpty(ContentType) && string.Compare(Content.ContentType, ContentType, true) != 0)
            {
                try
                {
                    ContentResponse Decoded = await InternetContent.DecodeAsync(Content.ContentType, Content.Content, null);
                    if (Decoded.HasError)
                    {
                        await e.IqErrorNotAcceptable(e.To, "Unable to decode mail object.", "en");
                        return;
                    }
 
                    if (Decoded.Decoded is MultipartContent MultipartContent)
                    {
                        LinkedList<MultipartContent> ToProcess = new LinkedList<MultipartContent>();
                        ToProcess.AddLast(MultipartContent);
 
                        while (Data is null && !(ToProcess.First is null))
                        {
                            MultipartContent = ToProcess.First.Value;
                            ToProcess.RemoveFirst();
 
                            foreach (EmbeddedContent Obj in MultipartContent.Content)
                            {
                                if (string.Compare(Obj.ContentType, ContentType, true) == 0)
                                {
                                    Data = Obj.TransferDecoded ?? Obj.Raw;
                                    break;
                                }
 
                                if (!Obj.ContentType.StartsWith("multipart/"))
                                    continue;
 
                                ContentResponse Item = await InternetContent.DecodeAsync(Obj.ContentType, Obj.TransferDecoded ?? Obj.Raw, null);
                                if (Item.HasError)
                                {
                                    await e.IqErrorNotAcceptable(e.To, "Unable to decode mail object.", "en");
                                    return;
                                }
 
                                MultipartContent = Item.Decoded as MultipartContent;
                                if (!(MultipartContent is null))
                                    ToProcess.AddLast(MultipartContent);
                            }
                        }
                    }
 
                    if (Data is null)
                    {
                        await e.IqErrorItemNotFound(e.To, "Content-Type not found in mail object.", "en");
                        return;
                    }
                }
                catch (Exception)
                {
                    await e.IqErrorNotAcceptable(e.To, "Unable to decode mail object.", "en");
                    return;
                }
            }
            else
            {
                ContentType = Content.ContentType;
                Data = Content.Content;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<content type='");
            Xml.Append(XML.Encode(ContentType));
            Xml.Append("' xmlns='");
            Xml.Append(MailNamespace);
 
            if (Content.Content is null)
                Xml.Append("'/>");
            else
            {
                Xml.Append("'>");
                Xml.Append(Convert.ToBase64String(Data));
                Xml.Append("</content>");
            }
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task DeleteMailContent(object Sender, IqEventArgs e)
        {
            string ContentId = XML.Attribute(e.Query, "cid");
 
            MailContent Content = await Database.FindFirstDeleteRest<MailContent>(new FilterFieldEqualTo("ContentId", ContentId));
            if (Content is null)
            {
                await e.IqErrorItemNotFound(e.To, "Mail content item not found.", "en");
                return;
            }
 
            if (Content.BareJid != e.From.BareJid)
            {
                await e.IqErrorForbidden(e.To, "Not authorized access.", "en");
                return;
            }
 
            await Database.Delete(Content);
 
            await e.IqResult(string.Empty, e.To);
        }
 
        public async Task<int> DeleteOldMailContent(DateTime OlderThan)
        {
            return await Database.Delete<MailContent>(new FilterFieldLesserOrEqualTo("Created", OlderThan));
        }
 
        public async Task<bool> SendMailMessage(CaseInsensitiveString From, CaseInsensitiveString To, string Subject, string Markdown)
        {
            MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Markdown);
            string HTML = "<html><body>" + HtmlDocument.GetBody(await Doc.GenerateHTML()) + "</body></html>";
            string PlainText = await Doc.GeneratePlainText();
 
            return await this.smtpServer.SendMessage(From, To, Subject, new EmbeddedContent[]
                {
                    new EmbeddedContent()
                    {
                        ContentType = "text/html; charset=utf-8",
                        Raw = Encoding.UTF8.GetBytes(HTML)
                    },
                    new EmbeddedContent()
                    {
                        ContentType = "text/plain; charset=utf-8",
                        Raw = Encoding.UTF8.GetBytes(PlainText)
                    },
                    new EmbeddedContent()
                    {
                        ContentType = "text/markdown; charset=utf-8",
                        Raw = Encoding.UTF8.GetBytes(Markdown)
                    }
                }, Array.Empty<EmbeddedContent>());
        }
 
        #endregion
 
        #region Service Discovery
 
        public Task<ServiceDiscoveryResult> ServiceDiscoveryAsync(string To)
        {
            return this.ServiceDiscoveryAsync(To, string.Empty);
        }
 
        public async Task<ServiceDiscoveryResult> ServiceDiscoveryAsync(string To, string Node)
        {
            StringBuilder Xml = new StringBuilder();
            bool CacheResponse = string.IsNullOrEmpty(Node) && (string.IsNullOrEmpty(To) || this.IsServerDomain(To, true));
            TaskCompletionSource<ServiceDiscoveryResult> Result = new TaskCompletionSource<ServiceDiscoveryResult>();
 
            Xml.Append("<query xmlns='");
            Xml.Append(DiscoveryNamespace);
 
            if (!string.IsNullOrEmpty(Node))
            {
                Xml.Append("' node='");
                Xml.Append(XML.Encode(Node));
            }
 
            Xml.Append("'/>");
 
            await this.SendIqRequest("get", this.domainAddress, new XmppAddress(To), string.Empty,
                Xml.ToString(), true, (Sender, e) =>
                {
                    if (e.Ok)
                    {
                        Dictionary<string, bool> Features = new Dictionary<string, bool>();
                        List<Identity> Identities = new List<Identity>();
 
                        foreach (XmlNode N in e.Response.ChildNodes)
                        {
                            if (N.LocalName == "query")
                            {
                                foreach (XmlNode N2 in N.ChildNodes)
                                {
                                    switch (N2.LocalName)
                                    {
                                        case "identity":
                                            Identities.Add(new Identity((XmlElement)N2));
                                            break;
 
                                        case "feature":
                                            Features[XML.Attribute((XmlElement)N2, "var")] = true;
                                            break;
                                    }
                                }
                            }
                        }
 
                        Result.TrySetResult(new ServiceDiscoveryResult(Identities.ToArray(), Features));
                    }
                    else if (string.IsNullOrEmpty(e.ErrorText))
                        Result.TrySetException(new Exception("Unable to perform service discovery."));
                    else
                        Result.TrySetException(new Exception(e.ErrorText));
 
                    return Task.CompletedTask;
 
                }, null);
 
            return await Result.Task;
        }
 
        public Task<Item[]> ServiceItemsDiscoveryAsync(string To)
        {
            return this.ServiceItemsDiscoveryAsync(To, string.Empty);
        }
 
        public async Task<Item[]> ServiceItemsDiscoveryAsync(string To, string Node)
        {
            StringBuilder Xml = new StringBuilder();
            TaskCompletionSource<Item[]> Result = new TaskCompletionSource<Item[]>();
 
            Xml.Append("<query xmlns='");
            Xml.Append(DiscoveryItemsNamespace);
 
            if (!string.IsNullOrEmpty(Node))
            {
                Xml.Append("' node='");
                Xml.Append(XML.Encode(Node));
            }
 
            Xml.Append("'/>");
 
            await this.SendIqRequest("get", this.domainAddress, new XmppAddress(To),
                string.Empty, Xml.ToString(), true, (Sender, e) =>
                {
                    if (e.Ok)
                    {
                        List<Item> Items = new List<Item>();
 
                        foreach (XmlNode N in e.Response.ChildNodes)
                        {
                            if (N.LocalName == "query")
                            {
                                foreach (XmlNode N2 in N.ChildNodes)
                                {
                                    if (N2.LocalName == "item")
                                        Items.Add(new Item((XmlElement)N2));
                                }
                            }
                        }
 
                        Result.TrySetResult(Items.ToArray());
                    }
                    else if (string.IsNullOrEmpty(e.ErrorText))
                        Result.TrySetException(new Exception("Unable to perform service items discovery."));
                    else
                        Result.TrySetException(new Exception(e.ErrorText));
 
                    return Task.CompletedTask;
 
                }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region Finding components
 
        public async Task<CaseInsensitiveString> FindComponentAsync(CaseInsensitiveString Jid, CaseInsensitiveString Feature)
        {
            CaseInsensitiveString Key = Jid + " " + Feature;
 
            lock (this.services)
            {
                if (this.services.TryGetValue(Key, out CaseInsensitiveString Service))
                    return Service;
            }
 
            string BareJid = GetBareJID(Jid);
            int i = BareJid.IndexOf('@');
            string Domain = BareJid[(i + 1)..];
 
            ServiceDiscoveryResult e = await this.ServiceDiscoveryAsync(Domain);
            string Result = null;
 
            if (e.HasFeature(Feature))
                Result = Domain;
            else
            {
                Item[] Items = await this.ServiceItemsDiscoveryAsync(Domain);
 
                foreach (Item Component in Items)
                {
                    e = await this.ServiceDiscoveryAsync(Component.JID);
                    if (e.HasFeature(Feature))
                    {
                        Result = Component.JID;
                        break;
                    }
                }
            }
 
            if (!string.IsNullOrEmpty(Result))
            {
                lock (this.services)
                {
                    this.services[Key] = Result;
                }
            }
 
            return Result;
        }
 
        #endregion
 
        #region Push Notification
 
        #region New Token
 
        private async Task NewTokenHandler(object Sender, IqEventArgs e)
        {
            CaseInsensitiveString BareJid = e.From.BareJid;
 
            if (!e.From.HasAccount)
            {
                await e.IqErrorItemNotFound(e.To, "Account not found.", "en");
                return;
            }
 
            if (!this.IsServerDomain(e.From.Domain, true))
            {
                await e.IqErrorForbidden(e.To, "Push Forwarding service only available for clients on broker.", "en");
                return;
            }
 
            if (!Enum.TryParse<PushMessagingService>(XML.Attribute(e.Query, "service"), out PushMessagingService Service))
            {
                await e.IqErrorBadRequest(e.To, "Unrecognized service.", "en");
                return;
            }
 
            if (!Enum.TryParse<ClientType>(XML.Attribute(e.Query, "clientType"), out ClientType ClientType))
            {
                await e.IqErrorBadRequest(e.To, "Unrecognized client type.", "en");
                return;
            }
 
            string Token = XML.Attribute(e.Query, "token");
            if (string.IsNullOrEmpty(Token))
            {
                await e.IqErrorBadRequest(e.To, "No token provided.", "en");
                return;
            }
 
            PushNotificationToken TokenObj = await TryGetPushNotificationToken(BareJid);
            DateTime TP = DateTime.UtcNow;
 
            if (TokenObj is null)
            {
                TokenObj = new PushNotificationToken()
                {
                    BareJid = BareJid,
                    Created = TP,
                    NrUpdates = 1,
                    Token = Token,
                    Service = Service,
                    ClientType = ClientType,
                    Updated = TP
                };
 
                tokens[BareJid] = TokenObj;
 
                await Database.Insert(TokenObj);
            }
            else
            {
                TokenObj.Token = Token;
                TokenObj.Service = Service;
                TokenObj.ClientType = ClientType;
                TokenObj.Updated = TP;
                TokenObj.NrUpdates++;
 
                await Database.Update(TokenObj);
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        public static async Task<PushNotificationToken> TryGetPushNotificationToken(CaseInsensitiveString BareJid)
        {
            if (tokens.TryGetValue(BareJid, out PushNotificationToken Token))
                return Token;
 
            Token = await Database.FindFirstDeleteRest<PushNotificationToken>(new FilterFieldEqualTo("BareJid", BareJid));
            tokens[BareJid] = Token;    // Store null, if none is found, to avoid repetitive searches.
 
            return Token;
        }
 
        #endregion
 
        #region Remove Token
 
        private async Task RemoveTokenHandler(object Sender, IqEventArgs e)
        {
            CaseInsensitiveString BareJid = e.From.BareJid;
 
            if (!e.From.HasAccount)
            {
                await e.IqErrorItemNotFound(e.To, "Account not found.", "en");
                return;
            }
 
            if (!this.IsServerDomain(e.From.Domain, true))
            {
                await e.IqErrorForbidden(e.To, "Push Forwarding service only available for clients on broker.", "en");
                return;
            }
 
            PushNotificationToken TokenObj = await TryGetPushNotificationToken(BareJid);
            if (TokenObj is null)
            {
                await e.IqErrorItemNotFound(e.To, "Token not found.", "en");
                return;
            }
 
            tokens.Remove(BareJid);
            await Database.Delete(TokenObj);
 
            await e.IqResult(string.Empty, e.To);
        }
 
        #endregion
 
        #region Clear Rules
 
        private async Task ClearRulesHandler(object Sender, IqEventArgs e)
        {
            CaseInsensitiveString BareJid = e.From.BareJid;
 
            if (!e.From.HasAccount)
            {
                await e.IqErrorItemNotFound(e.To, "Account not found.", "en");
                return;
            }
 
            if (!this.IsServerDomain(e.From.Domain, true))
            {
                await e.IqErrorForbidden(e.To, "Push Forwarding service only available for clients on broker.", "en");
                return;
            }
 
            foreach (PushNotificationRule Rule in await Database.FindDelete<PushNotificationRule>(new FilterFieldEqualTo("BareJid", BareJid)))
                rules.Remove(RuleKey(Rule));
 
            await e.IqResult(string.Empty, e.To);
        }
 
        private static string RuleKey(PushNotificationRule Rule)
        {
            return RuleKey(Rule.BareJid, Rule.MessageType, Rule.LocalName, Rule.Namespace);
        }
 
        private static string RuleKey(CaseInsensitiveString BareJid, string MessageType, string LocalName, string Namespace)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(BareJid.LowerCase);
            sb.Append(' ');
            sb.Append(MessageType);
            sb.Append(' ');
            sb.Append(LocalName);
            sb.Append(' ');
            sb.Append(Namespace);
 
            return sb.ToString();
        }
 
        #endregion
 
        #region Add Rule
 
        private async Task AddRuleHandler(object Sender, IqEventArgs e)
        {
            CaseInsensitiveString BareJid = e.From.BareJid;
 
            if (!e.From.HasAccount)
            {
                await e.IqErrorItemNotFound(e.To, "Account not found.", "en");
                return;
            }
 
            if (!this.IsServerDomain(e.From.Domain, true))
            {
                await e.IqErrorForbidden(e.To, "Push Forwarding service only available for clients on broker.", "en");
                return;
            }
 
            string MessageType = XML.Attribute(e.Query, "type");
            string LocalName = XML.Attribute(e.Query, "localName");
            string Namespace = XML.Attribute(e.Query, "namespace");
            string Channel = XML.Attribute(e.Query, "channel");
            string MessageVariable = XML.Attribute(e.Query, "variable");
            string PatternMatchingScript = null;
            string ContentScript = null;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E && E.NamespaceURI == MessagePushNamespace)
                {
                    switch (E.LocalName)
                    {
                        case "PatternMatching":
                            PatternMatchingScript = E.InnerText.Trim();
 
                            try
                            {
                                Expression Exp = new Expression(PatternMatchingScript);
 
                                if (!CheckExpressionSafe(Exp, out ScriptNode Prohibited))
                                {
                                    await e.IqErrorForbidden(e.To, "Pattern Matching Script contains prohibited elements: " +
                                        Prohibited?.SubExpression, "en");
 
                                    return;
                                }
                            }
                            catch (Exception)
                            {
                                await e.IqErrorBadRequest(e.To, "Invalid pattern-matching script.", "en");
                                return;
                            }
                            break;
 
                        case "Content":
                            ContentScript = E.InnerText.Trim();
 
                            try
                            {
                                Expression Exp = new Expression(ContentScript);
 
                                if (!CheckExpressionSafe(Exp, out ScriptNode Prohibited))
                                {
                                    await e.IqErrorForbidden(e.To, "Content Script contains prohibited elements: " +
                                        Prohibited?.SubExpression, "en");
 
                                    return;
                                }
                            }
                            catch (Exception)
                            {
                                await e.IqErrorBadRequest(e.To, "Invalid content script.", "en");
                                return;
                            }
                            break;
 
                        default:
                            await e.IqErrorBadRequest(e.To, "Unrecognized child element: " + e.Language, "en");
                            return;
                    }
                }
            }
 
            PushNotificationRule Rule = await TryGetPushNotificationRule(BareJid, MessageType, LocalName, Namespace);
 
            if (Rule is null)
            {
                Rule = new PushNotificationRule()
                {
                    BareJid = BareJid,
                    LocalName = LocalName,
                    Namespace = Namespace,
                    MessageType = MessageType,
                    Channel = Channel,
                    MessageVariable = MessageVariable,
                    PatternMatchingScript = PatternMatchingScript,
                    ContentScript = ContentScript
                };
 
                await Database.Insert(Rule);
 
                rules[RuleKey(Rule)] = Rule;
            }
            else
            {
                Rule.Channel = Channel;
                Rule.MessageVariable = MessageVariable;
                Rule.PatternMatchingScript = PatternMatchingScript;
                Rule.ContentScript = ContentScript;
 
                await Database.Update(Rule);
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        private readonly static Assembly scriptContent = typeof(GraphEncoder).Assembly;
        private readonly static Assembly scriptPersistence = typeof(IncCounter).Assembly;
        private readonly static Assembly[] prohibitedAssemblies = new Assembly[]
        {
            scriptContent,                      // Waher.Script.Content
            scriptPersistence,                  // Waher.Script.Persistence
            typeof(FractalGraph).Assembly,      // Waher.Script.Fractals
            typeof(WhoIs).Assembly,             // Waher.Script.Networking
            typeof(FtsCollection).Assembly,     // Waher.Script FullTextSearch
            typeof(ConnectMsSql).Assembly,      // Waher.Script.Data
            typeof(ShellExecute).Assembly       // Waher.Script.System
        };
 
        public static bool CheckExpressionSafe(Expression Expression, out ScriptNode Prohibited)
        {
            return CheckExpressionSafe(Expression, false, false, false, out Prohibited);
        }
 
        public static bool CheckExpressionSafe(Expression Expression, bool AllowNamedMembers, bool AllowError,
            bool AllowCustomFunctions, out ScriptNode Prohibited)
        {
            ScriptNode Prohibited2 = null;
            bool Safe = Expression.ForAll((ScriptNode Node, out ScriptNode NewNode, object State) =>
            {
                NewNode = null;
 
                Assembly Assembly = Node.GetType().Assembly;
 
                foreach (Assembly A in prohibitedAssemblies)
                {
                    if (A.FullName == Assembly.FullName)
                    {
                        if (A == scriptContent)
                        {
                            if (Node is Script.Content.Functions.Duration ||
                                Node.GetType().Namespace == typeof(Utf8Encode).Namespace)
                            {
                                return true;
                            }
                        }
                        else if (A == scriptPersistence)
                        {
                            if (Node is IncCounter ||
                                Node is DecCounter ||
                                Node is GetCounter ||
                                Node is GetHashObject ||
                                Node is PersistHash ||
                                Node is VerifyHash)
                            {
                                return true;
                            }
                        }
 
                        Prohibited2 = Node;
                        return false;
                    }
                }
 
                if ((Node is NamedMember && !AllowNamedMembers) ||
                    (Node is NamedMemberAssignment && !AllowNamedMembers) ||
                    (Node is LambdaDefinition && !AllowCustomFunctions) ||
                    Node is NamedMethodCall ||
                    Node is DynamicFunctionCall ||
                    Node is DynamicMember ||
                    Node is Create ||
                    Node is Destroy ||
                    (Node is Error && !AllowError))
                {
                    Prohibited2 = Node;
                    return false;
                }
 
                return true;
 
            }, null, SearchMethod.TreeOrder);
 
            Prohibited = Prohibited2;
            return Safe;
        }
 
        public static async Task<PushNotificationRule> TryGetPushNotificationRule(CaseInsensitiveString BareJid, string MessageType,
            string LocalName, string Namespace)
        {
            string Key = RuleKey(BareJid, MessageType, LocalName, Namespace);
 
            if (rules.TryGetValue(Key, out PushNotificationRule Rule))
                return Rule;
 
            Rule = await Database.FindFirstDeleteRest<PushNotificationRule>(new FilterAnd(
                new FilterFieldEqualTo("BareJid", BareJid),
                new FilterFieldEqualTo("MessageType", MessageType),
                new FilterFieldEqualTo("LocalName", LocalName),
                new FilterFieldEqualTo("Namespace", Namespace)));
            rules[Key] = Rule;    // Store null, if none is found, to avoid repetitive searches.
 
            return Rule;
        }
 
        #endregion
 
        #region Remove Rule
 
        private async Task RemoveRuleHandler(object Sender, IqEventArgs e)
        {
            CaseInsensitiveString BareJid = e.From.BareJid;
 
            if (!e.From.HasAccount)
            {
                await e.IqErrorItemNotFound(e.To, "Account not found.", "en");
                return;
            }
 
            if (!this.IsServerDomain(e.From.Domain, true))
            {
                await e.IqErrorForbidden(e.To, "Push Forwarding service only available for clients on broker.", "en");
                return;
            }
 
            string MessageType = XML.Attribute(e.Query, "type");
            string LocalName = XML.Attribute(e.Query, "localName");
            string Namespace = XML.Attribute(e.Query, "namespace");
 
            PushNotificationRule Rule = await TryGetPushNotificationRule(BareJid, MessageType, LocalName, Namespace);
 
            if (Rule is null)
            {
                await e.IqErrorItemNotFound(e.To, "Rule not found.", "en");
                return;
            }
 
            rules.Remove(RuleKey(Rule));
            await Database.Delete(Rule);
 
            await e.IqResult(string.Empty, e.To);
        }
 
        #endregion
 
        #endregion
 
        // TODO: Retries
    }
}