db/d47/_xmpp_server_module_8cs_source.html

using SkiaSharp;

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.IO.Compression;

using System.Net;

using System.Net.Sockets;

using System.Reflection;

using System.Runtime.ExceptionServices;

using System.Security.Cryptography;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using System.Web;

using System.Xml;

using Waher.Content;

using Waher.Content.Emoji;

using Waher.Content.Html;

using Waher.Content.Html.Css;

using Waher.Content.Html.JavaScript;

using Waher.Content.Markdown;

using Waher.Content.Markdown.Consolidation;

using Waher.Content.Markdown.Model;

using Waher.Content.Multipart;

using Waher.Content.SystemFiles;

using Waher.Content.Text;

using Waher.Content.Xml;

using Waher.Content.Xsl;

using Waher.Events;

using Waher.Events.Statistics;

using Waher.IoTGateway;

using Waher.IoTGateway.ScriptExtensions.Constants;

using Waher.IoTGateway.Setup;

using Waher.IoTGateway.WebResources;

using Waher.Networking;

using Waher.Networking.DNS;

using Waher.Networking.DNS.Communication;

using Waher.Networking.DNS.HTTPS;

using Waher.Networking.HTTP;

using Waher.Networking.SMTP.Server;

using Waher.Networking.Sniffers;

using Waher.Networking.XMPP.Concentrator;

using Waher.Networking.XMPP.Server;

using Waher.Networking.XMPP.Server.BOSH;

using Waher.Networking.XMPP.Server.HttpFileUpload;

using Waher.Networking.XMPP.Server.SOCKS5;

using Waher.Networking.XMPP.Server.Statistics;

using Waher.Networking.XMPP.Server.WS;

using Waher.Persistence;

using Waher.Persistence.Filters;

using Waher.Persistence.FullTextSearch;

using Waher.Persistence.FullTextSearch.Tokenizers;

using Waher.Runtime.Cache;

using Waher.Runtime.Inventory;

using Waher.Runtime.ServiceRegistration;

using Waher.Runtime.Settings;

using Waher.Runtime.Temporary;

using Waher.Script;

using Waher.Script.Abstraction.Elements;

using Waher.Script.Exceptions;

using Waher.Script.Graphs;

using Waher.Script.Objects;

using Waher.Script.Objects.Matrices;

using Waher.Script.Operators.Matrices;

using Waher.Security;

using Waher.Security.EllipticCurves;

using Waher.Security.JWT;

using Waher.Security.LoginMonitor;

using Waher.Security.SHA3;

using Waher.Security.SPF;

using Waher.Security.Users;

using Waher.Service.IoTBroker.Admin;

using Waher.Service.IoTBroker.Admin.Muc;

using Waher.Service.IoTBroker.DataStorage;

using Waher.Service.IoTBroker.EDaler;

using Waher.Service.IoTBroker.Encodings;

using Waher.Service.IoTBroker.Events;

using Waher.Service.IoTBroker.HttpX;

using Waher.Service.IoTBroker.Legal;

using Waher.Service.IoTBroker.Legal.MFA;

using Waher.Service.IoTBroker.Marketplace;

using Waher.Service.IoTBroker.MultiUserChat;

using Waher.Service.IoTBroker.NeuroFeatures.WebServices;

using Waher.Service.IoTBroker.Paiwise;

using Waher.Service.IoTBroker.Provisioning;

using Waher.Service.IoTBroker.Provisioning.SoftwareUpdates;

using Waher.Service.IoTBroker.PubSub;

using Waher.Service.IoTBroker.Sampling;

using Waher.Service.IoTBroker.ServiceRegistrations;

using Waher.Service.IoTBroker.Setup;

using Waher.Service.IoTBroker.Sources.Connections;

using Waher.Service.IoTBroker.Sources.GatewayConfig;

using Waher.Service.IoTBroker.Sources.PersistedData;

using Waher.Service.IoTBroker.Sources.ProgramData;

using Waher.Service.IoTBroker.Sources.Protocols;

using Waher.Service.IoTBroker.StateMachines;

using Waher.Service.IoTBroker.Synchronization;

using Waher.Service.IoTBroker.WebServices;

using Waher.Things;


namespace Waher.Service.IoTBroker

{

    [Singleton]

    public class XmppServerModule : IModule

    {

        public const string NamespaceSynchronizationIeeeV1 = "urn:ieee:iot:synchronization:1.0";


        public const string NamespaceSynchronizationNeuroFoundationV1 = "urn:nf:iot:synchronization:1.0";


        public const string NamespaceDnsOverXmpp = "urn:xmpp:dox:0";


        public const string NamespaceJwt = "urn:xmpp:jwt:0";


        public static string NamespaceSynchronization(NamespaceSet Version)

        {

            switch (Version)

            {

                case NamespaceSet.XsfV0:

                case NamespaceSet.IeeeV1: return NamespaceSynchronizationIeeeV1;

                default:

                case NamespaceSet.NeuroFoundationV1: return NamespaceSynchronizationNeuroFoundationV1;

            }

        }


        public static NamespaceSet GetVersion(string Namespace)

        {

            switch (Namespace)

            {

                case NamespaceSynchronizationNeuroFoundationV1:

                default:

                case ProvisioningComponent.NamespaceProvisioningTokenNeuroFoundationV1:

                case ProvisioningComponent.NamespaceProvisioningDeviceNeuroFoundationV1:

                case ProvisioningComponent.NamespaceProvisioningOwnerNeuroFoundationV1:

                case ProvisioningComponent.NamespaceIoTDiscoveryNeuroFoundationV1:

                case ProvisioningComponent.NamespaceSoftwareUpdatesNeuroFoundationV1:

                case LegalComponent.NamespaceLegalIdentityNeuroFoundationV1:

                case LegalComponent.NamespaceSmartContractsNeuroFoundationV1:

                case LegalComponent.NamespaceE2ENeuroFoundationV1:

                    return NamespaceSet.NeuroFoundationV1;


                case NamespaceSynchronizationIeeeV1:

                case ProvisioningComponent.NamespaceProvisioningTokenIeeeV1:

                case ProvisioningComponent.NamespaceProvisioningDeviceIeeeV1:

                case ProvisioningComponent.NamespaceProvisioningOwnerIeeeV1:

                case ProvisioningComponent.NamespaceIoTDiscoveryIeeeV1:

                case ProvisioningComponent.NamespaceSoftwareUpdatesIeeeV1:

                case LegalComponent.NamespaceLegalIdentityIeeeV1:

                case LegalComponent.NamespaceSmartContractsIeeeV1:

                case LegalComponent.NamespaceE2EIeeeV1:

                    return NamespaceSet.IeeeV1;


                case ProvisioningComponent.NamespaceIoTDiscoveryXsfV0:

                    return NamespaceSet.XsfV0;

            }

        }


        private const string Ip2LocalizationPackageName = "IP2LOCATION-LITE-DB3.CSV";


        private static XmppServerModule instance = null;

        private static Calibration calibration;

        private readonly static Stopwatch clock = CreateWatch();

        private static readonly byte[] iotBrokerPackagePublicKey = System.Convert.FromBase64String("BRb026TgJ5L1t6T5jWL23m0BQHg1kUNY308V8ixlqmNN8nrPDzB3tTygDylyzjmDCFgWSf7OyUWA");

        private static readonly Edwards448 ed448 = new Edwards448();

        internal const string AutoInstallDelayParameterName = "Autoinstall.DelayMin";

        internal const string AutoInstallContentOnlyParameterName = "Autoinstall.ContentOnly";

        internal const string AutoInstallTimeParameterName = "Autoinstall.Time";


        private readonly Dictionary<CaseInsensitiveString, WebNode> webNodes = new Dictionary<CaseInsensitiveString, WebNode>();

        private readonly SortedDictionary<string, LinkedList<IAdminCommand>> adminCommands = new SortedDictionary<string, LinkedList<IAdminCommand>>();

        private readonly Dictionary<CaseInsensitiveString, RoomInfo> mucRooms = new Dictionary<CaseInsensitiveString, RoomInfo>();

        private readonly Dictionary<CaseInsensitiveString, SortedDictionary<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs>> presenceByNickAndRoom = new Dictionary<CaseInsensitiveString, SortedDictionary<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs>>();

        private Dictionary<string, bool> vulnerableResources = null;

        private Cache<string, IP4Localization> ip4LocalizationCache;

        private Cache<string, Variables> chatSessions = null;

        private Cache<string, IConsolidator> consolidators;

        private Cache<string, string> ssoTokens;

        private EventStatisticsSink eventStatistics = null;

        private PersistenceLayer persistenceLayer = null;

        private XmppServer xmppServer = null;

        private SmtpServer smtpServer = null;

        private Socks5Component socks5Component = null;

        private EventLogComponent eventLogComponent = null;

        private ProvisioningComponent provisioningComponent = null;

        private PubSubComponent pubSubComponent = null;

        private MultiUserChatComponent mucComponent = null;

        private ServiceRegistrationComponent serviceRegistrationComponent = null;

        private LegalComponent legalComponent = null;

        private EDalerComponent eDalerComponent = null;

        private ConcentratorServer concentratorServer = null;

        private ServiceRegistrationClient serviceRegistrationClient;

        private HttpServer httpServer = null;

        private HttpxServer httpxServer = null;

        private HttpFileUploadSettings httpFileUploadSettings = null;

        private HttpFileUploadComponent httpFileUploadComponent;

        private XmppFileUploadResource httpFileUploadResource;

        private HttpFolderResource httpEncryptedFileUploadResource;

        private HttpFolderResource httpPubSubFileUploadResource;

        private CreateApiKey createApiKey = null;

        private UpdateApiKey updateApiKey = null;

        private CreateAccount createAccount = null;

        private UpdateAccount updateAccount = null;

        private DeleteAccount deleteAccount = null;

        private UpdatePubSubNode updatePubSubNode = null;

        private DeletePubSubNode deletePubSubNode = null;

        private LoadMoreItems loadMoreItems = null;

        private Feedback feedback = null;

        private RequestAccount requestAccount = null;

        private RequestApiKey requestApiKey = null;

        private SearchEvents searchEvents = null;

        private SendOperatorMessage sendMessage = null;

        private SetContractState setContractState = null;

        private PublisherAvatar publisherAvatar = null;

        private BoshWebClientResource webClient1 = null;

        private BoshWebClientResource webClient2 = null;

        private WebSocketClientResource webSocketClient = null;

        private WebHostMetaDataXml webHostMetaDataXml = null;

        private WebHostMetaDataJson webHostMetaDataJson = null;

        private ConnectionsSource connectionsSource = null;

        private LegalIdentityStateChanged legalIdentityStateChanged = null;

        private QR qr = null;

        private UploadPackage uploadPackage = null;

        private UploadSignature uploadSignature = null;

        private DeletePackage deletePackage = null;

        private InstallPackage installPackage = null;

        private UninstallPackage uninstallPackage = null;

        private HttpFolderResource packages = null;

        private DnsOverHttpsResource dnsOverHttps = null;

        private ValidateLegalId validateLegalId = null;

        private ValidateContract validateContract = null;

        private MultiFactorAuthentication mfa = null;

        private QuickLogin quickLogin = null;

        private WhatsMyEndpointResource whatsMyEndpointResource = null;

        private AddNote addNote = null;

        private HttpResource chatFile = null;

        private XmppOverHttp xmppOverHttp = null;

        private Buckets statistics = null;

        private Timer sampleTimer = null;

        private JwtFactory jwtFactory = null;


        private static string appData = string.Empty;

        internal static DateTime autoUpdateTP = DateTime.MinValue;


        public XmppServerModule()

        {

        }


        public async Task Start()

        {

            try

            {

                Log.Informational("XMPP Server starting.");

                instance = this;


                if (Types.TryGetModuleParameter("AppData", out object Obj) && (Obj is string s))

                    appData = s;


                this.eventStatistics = new EventStatisticsSink("Event Statistics");

                Log.Register(this.eventStatistics);


                DateTime Now = DateTime.Now;

                DateTime TP = new DateTime(Now.Year, Now.Month, Now.Day, Now.Hour, Now.Minute, 0);

                this.statistics = new Buckets(TP, new Duration(false, 0, 0, 0, 0, 1, 0));


                TP = new DateTime(Now.Year, Now.Month, Now.Day, Now.Hour, Now.Minute, Now.Second);

                int UntilNext = (int)((TP.AddSeconds(1) - Now).TotalMilliseconds + 0.5);


                if (UntilNext < 0)

                    UntilNext += 1000;


                this.sampleTimer = new Timer(this.SampleTimerEventHandler, null, UntilNext, 1000);


                this.persistenceLayer = new PersistenceLayer();


                this.ip4LocalizationCache = new Cache<string, IP4Localization>(int.MaxValue, TimeSpan.FromDays(30), TimeSpan.FromDays(1));

                LoginAuditor.AnnotateEndpoint += this.LoginAuditor_AnnotateEndpoint;


                List<string> Ip4DnsBlackLists = new List<string>();

                List<string> Ip6DnsBlackLists = new List<string>();


                try

                {

                    XmlDocument Doc = new XmlDocument();

                    Doc.Load(Path.Combine(appData, "DNSBL.xml"));


                    XSL.Validate("DNSBL", Doc, "BlackLists", "http://waher.se/Schema/DNSBL.xsd",

                        XSL.LoadSchema(typeof(XmppServerModule).Namespace + ".Schema.DNSBL.xsd"));


                    foreach (XmlNode N in Doc.DocumentElement.ChildNodes)

                    {

                        if (N is XmlElement E && E.LocalName == "BlackList")

                        {

                            s = XML.Attribute(E, "ip4DomainName");

                            if (!string.IsNullOrEmpty(s))

                                Ip4DnsBlackLists.Add(s);


                            s = XML.Attribute(E, "ip6DomainName");

                            if (!string.IsNullOrEmpty(s))

                                Ip6DnsBlackLists.Add(s);

                        }

                    }

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                List<SpfExpression> SpfExpressions = new List<SpfExpression>();


                try

                {

                    XmlDocument Doc = new XmlDocument();

                    Doc.Load(Path.Combine(appData, "SPF.xml"));


                    XSL.Validate("SPF", Doc, "SpfRecords", "http://waher.se/Schema/SPF.xsd",

                        XSL.LoadSchema(typeof(XmppServerModule).Namespace + ".Schema.SPF.xsd"));


                    foreach (XmlNode N in Doc.DocumentElement.ChildNodes)

                    {

                        if (N is XmlElement E && E.LocalName == "SpfRecord")

                        {

                            string Domain = XML.Attribute(E, "domain");

                            string Spf = XML.Attribute(E, "spf");

                            bool IncludeSubdomains = XML.Attribute(E, "includeSubdomains", false);


                            SpfExpressions.Add(new SpfExpression(Domain, IncludeSubdomains, Spf));

                        }

                    }

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                try

                {

                    TokenizationProcess StopWords = new TokenizationProcess();

                    XmlDocument Doc = new XmlDocument();

                    Doc.Load(Path.Combine(appData, "StopWords.xml"));


                    foreach (XmlNode N in Doc.DocumentElement.ChildNodes)

                    {

                        if (N is XmlElement E && E.LocalName == "Language")

                        {

                            foreach (XmlNode N2 in E.ChildNodes)

                            {

                                if (N2 is XmlElement E2 && E2.LocalName == "Stopword")

                                    await FullTextSearchModule.Tokenize(new object[] { E2.InnerText }, StopWords);

                            }

                        }

                    }


                    string[] StopWords2 = new string[StopWords.TokenCounts.Count];

                    StopWords.TokenCounts.Keys.CopyTo(StopWords2, 0);


                    Search.RegisterStopWords(StopWords2);

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                IoTBroker.Legal.Identity.Iso3166.Load();

                IoTBroker.Legal.Identity.PersonalNumberSchemes.Load();

                IoTBroker.Legal.Identity.PhoneCountryCodes.Load();


                Encoding.RegisterProvider(new CodePages());


                this.smtpServer = new SmtpServer(Gateway.Domain, Gateway.GetConfigPorts("SMTP"), 10 * 1024 * 1024,

                    Gateway.Certificate, !(Gateway.Certificate is null), this.persistenceLayer, Ip4DnsBlackLists.ToArray(),

                    Ip6DnsBlackLists.ToArray(), SpfExpressions.ToArray());


                Types.SetModuleParameter("SMTP_SERVER", this.smtpServer);


                this.smtpServer.ExternalSniffers.Add(new XmlFileSniffer(appData + "SMTP" + Path.DirectorySeparatorChar +

                    "SMTP Server Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml", appData + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",

                    7, BinaryPresentationMethod.ByteCount));


                this.smtpServer.SmtpSnifferPath = appData + "SMTP" + Path.DirectorySeparatorChar +

                    "%ENDPOINT%" + Path.DirectorySeparatorChar + "SMTP Server Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml";


                await RelayConfiguration.Instance.ConfigureSystem();


                if (Types.TryGetModuleParameter("HTTP", out Obj))

                    this.httpServer = Obj as HttpServer;

                else

                    this.httpServer = null;


                this.xmppServer = await XmppServer.Create(Gateway.Domain, Gateway.AlternativeDomains,

                    Gateway.GetConfigPorts("XMPP.C2S"),

                    Gateway.GetConfigPorts("XMPP.S2S"),

                    Gateway.Certificate, !(Gateway.Certificate is null), this.persistenceLayer, this.smtpServer, this.httpServer);


                Types.SetModuleParameter("XMPP_SERVER", this.xmppServer);


                this.xmppServer.ClientConnectionAdded += this.XmppServer_ClientConnectionAdded;

                this.xmppServer.ClientConnectionRemoved += this.XmppServer_ClientConnectionRemoved;

                this.xmppServer.ClientConnectionUpdated += this.XmppServer_ClientConnectionUpdated;

                this.xmppServer.ServerConnectionAdded += this.XmppServer_ServerConnectionAdded;

                this.xmppServer.ServerConnectionRemoved += this.XmppServer_ServerConnectionRemoved;

                this.xmppServer.ServerConnectionUpdated += this.XmppServer_ServerConnectionUpdated;


                #region Neuro-Foundation V1 handlers


                this.xmppServer.RegisterIqGetHandler("req", NamespaceSynchronizationNeuroFoundationV1, ClockSynchronization.RequestHandler, true);

                this.xmppServer.RegisterIqGetHandler("sourceReq", NamespaceSynchronizationNeuroFoundationV1, ClockSynchronization.ClockSourceReq, false);


                #endregion


                #region IEEE V1 handlers


                this.xmppServer.RegisterIqGetHandler("req", NamespaceSynchronizationIeeeV1, ClockSynchronization.RequestHandler, true);

                this.xmppServer.RegisterIqGetHandler("sourceReq", NamespaceSynchronizationIeeeV1, ClockSynchronization.ClockSourceReq, false);


                #endregion


                #region XSF handlers


                #endregion


                this.xmppServer.RegisterIqGetHandler("dns", NamespaceDnsOverXmpp, this.DnsRequest, true);


                this.xmppServer.RegisterIqGetHandler("jwt", NamespaceJwt, this.JwtRequest, true);

                this.jwtFactory = JwtFactory.CreateHmacSha256();

                Types.SetModuleParameter("JWT", this.jwtFactory);


                this.persistenceLayer.Server = this.xmppServer;


                this.provisioningComponent = new ProvisioningComponent(this.xmppServer, "provisioning", "Thing Registry and Provisioning Server");

                this.pubSubComponent = await PubSubComponent.Create(this.xmppServer, "pubsub", "Publish/Subscribe service");

                this.mucComponent = new MultiUserChatComponent(this.xmppServer, "muc", "Multi-User Chat service");

                this.eventLogComponent = new EventLogComponent(this.xmppServer, "log", "Event Log");

                this.serviceRegistrationComponent = new ServiceRegistrationComponent(this.xmppServer, "services", "Service Registry");

                this.legalComponent = new LegalComponent(this.xmppServer, "legal", "Smart Contracts", this.httpServer, Path.Combine(Gateway.AppDataFolder, "Attachments"), null, this.pubSubComponent);

                this.eDalerComponent = new EDalerComponent(this.xmppServer, "edaler", "eDaler", this.legalComponent);

                this.legalComponent.EDaler = this.eDalerComponent;


                int[] Socks5Ports = Gateway.GetConfigPorts("SOCKS5");


                if (Socks5Ports.Length > 0)

                    this.socks5Component = new Socks5Component(this.xmppServer, "socks5", Socks5Ports[0]);


                string FileName = Path.Combine(Gateway.AppDataFolder, "HoneyPotResources.txt");

                if (File.Exists(FileName))

                {

                    try

                    {

                        s = File.ReadAllText(FileName);

                        string[] Resources = s.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);

                        Dictionary<string, bool> VulnerableResources = new Dictionary<string, bool>(StringComparer.InvariantCultureIgnoreCase);


                        foreach (string Resource in Resources)

                        {

                            if (Resource.StartsWith("/"))

                                VulnerableResources[Resource.Substring(1)] = true;

                        }


                        this.vulnerableResources = VulnerableResources;


                        Gateway.Root.FileNotFound += this.Root_FileNotFound;

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                    }

                }


                if (!(this.httpServer is null))

                {

                    this.httpServer.Register(new HttpConfigurableFileResource("/.well-known/security.txt",

                        Path.Combine(Gateway.RootFolder, ".well-known", "security.txt"), PlainTextCodec.DefaultContentType));

                    this.httpServer.Register(new HttpConfigurableFileResource("/firebase-messaging-sw.js",

                        Path.Combine(Gateway.RootFolder, "firebase-messaging-sw.js"), JavaScriptCodec.DefaultContentType));


                    this.httpServer.Register(this.webClient1 = new BoshWebClientResource(this.xmppServer, this.httpServer, "/webclient"));

                    this.httpServer.Register(this.webClient2 = new BoshWebClientResource(this.xmppServer, this.httpServer, "/http-bind"));

                    this.httpServer.Register(this.webSocketClient = new WebSocketClientResource(this.xmppServer, "/xmpp-websocket"));

                    this.httpServer.Register(this.webHostMetaDataXml = new WebHostMetaDataXml());

                    this.httpServer.Register(this.webHostMetaDataJson = new WebHostMetaDataJson());

                    this.httpServer.Register(this.packages = new HttpFolderResource("/Packages", PackagesFolder, false, false, true, false, HostDomainOptions.SameForAllDomains, new PackageUrlValidator()));

                    this.httpServer.Register(this.createApiKey = new CreateApiKey());

                    this.httpServer.Register(this.updateApiKey = new UpdateApiKey());

                    this.httpServer.Register(this.createAccount = new CreateAccount());

                    this.httpServer.Register(this.updateAccount = new UpdateAccount());

                    this.httpServer.Register(this.deleteAccount = new DeleteAccount());

                    this.httpServer.Register(this.updatePubSubNode = new UpdatePubSubNode());

                    this.httpServer.Register(this.deletePubSubNode = new DeletePubSubNode());

                    this.httpServer.Register(this.loadMoreItems = new LoadMoreItems());

                    this.httpServer.Register(this.feedback = new Feedback());

                    this.httpServer.Register(this.requestAccount = new RequestAccount());

                    this.httpServer.Register(this.requestApiKey = new RequestApiKey());

                    this.httpServer.Register(this.searchEvents = new SearchEvents());

                    this.httpServer.Register(this.sendMessage = new SendOperatorMessage());

                    this.httpServer.Register(this.setContractState = new SetContractState());

                    this.httpServer.Register(this.publisherAvatar = new PublisherAvatar());

                    this.httpServer.Register(this.legalIdentityStateChanged = new LegalIdentityStateChanged());

                    this.httpServer.Register(this.qr = new QR());

                    this.httpServer.Register(this.uploadPackage = new UploadPackage());

                    this.httpServer.Register(this.uploadSignature = new UploadSignature());

                    this.httpServer.Register(this.deletePackage = new DeletePackage());

                    this.httpServer.Register(this.installPackage = new InstallPackage());

                    this.httpServer.Register(this.uninstallPackage = new UninstallPackage());

                    this.httpServer.Register(this.dnsOverHttps = new DnsOverHttpsResource());

                    this.httpServer.Register(this.validateLegalId = new ValidateLegalId());

                    this.httpServer.Register(this.validateContract = new ValidateContract());

                    this.httpServer.Register(this.mfa = new MultiFactorAuthentication());

                    this.httpServer.Register(this.quickLogin = new QuickLogin());

                    this.httpServer.Register(this.whatsMyEndpointResource = new WhatsMyEndpointResource("/WMEP"));

                    this.httpServer.Register(this.addNote = new AddNote());

                    this.chatFile = this.httpServer.Register("/ChatFile", this.ChatFileDownload, false, true);

                    this.httpxServer = new HttpxServer(this.xmppServer, this.httpServer, 8192);


                    if (!CaseInsensitiveString.IsNullOrEmpty(Gateway.Domain) && DomainConfiguration.Instance.UseEncryption)

                        this.httpServer.Register(this.xmppOverHttp = new XmppOverHttp("/HTTPX"));


                    if (!(this.httpServer.Sniffers is null))

                    {

                        this.xmppServer.C2sSniffers.Add(new XmlFileSniffer(appData + "XMPP_C2S" + Path.DirectorySeparatorChar +

                            "XMPP Server Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml", appData + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",

                            7, BinaryPresentationMethod.ByteCount));


                        this.xmppServer.ClientSnifferPath = appData + "XMPP_C2S" + Path.DirectorySeparatorChar +

                            "%ENDPOINT%" + Path.DirectorySeparatorChar + "XMPP Server Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml";


                        this.xmppServer.S2sSniffers.Add(new XmlFileSniffer(appData + "XMPP_S2S" + Path.DirectorySeparatorChar +

                            "XMPP Server Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml", appData + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",

                            7, BinaryPresentationMethod.ByteCount));


                        this.xmppServer.DomainSnifferPath = appData + "XMPP_S2S" + Path.DirectorySeparatorChar +

                            "%DOMAIN%" + Path.DirectorySeparatorChar + "XMPP Server Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml";

                    }


                    bool Encrypted = true;

                    int[] Ports = this.httpServer.OpenHttpsPorts;

                    if (Ports.Length == 0)

                    {

                        Encrypted = false;

                        Ports = this.httpServer.OpenHttpPorts;

                    }


                    if (Ports.Length > 0)

                    {

                        StringBuilder Url = new StringBuilder();

                        int Port = Ports[0];


                        Url.Append("http");

                        if (Encrypted)

                            Url.Append('s');

                        Url.Append("://");

                        Url.Append(Gateway.Domain);


                        if (Encrypted)

                        {

                            if (Port != HttpServer.DefaultHttpsPort)

                            {

                                Url.Append(':');

                                Url.Append(Port.ToString());

                            }

                        }

                        else

                        {

                            if (Port != HttpServer.DefaultHttpPort)

                            {

                                Url.Append(':');

                                Url.Append(Port.ToString());

                            }

                        }


                        string Root = Url.ToString();


                        Url.Append("/HttpUpload");


                        this.httpFileUploadSettings = new HttpFileUploadSettings()

                        {

                            MaxFileSize = 1024 * 1024 * 20,

                            MaxFilesPerMinute = 10,

                            MaxBytesPerMinute = 1024 * 1024 * 50,

                            FileLifetime = TimeSpan.FromMinutes(10),

                            FileFolder = Path.Combine(appData, "HttpUpload"),

                            HttpFolder = Url.ToString(),

                            BackupFolder = await Export.GetFullExportFolderAsync(),

                            KeyFolder = await Export.GetFullKeyExportFolderAsync(),

                            EncryptedStorageFolder = Path.Combine(appData, "EncryptedStorage"),

                            EncryptedStorageRoot = Root + "/EncryptedStorage",

                            PubSubStorageFolder = Path.Combine(appData, "PubSubStorage"),

                            PubSubStorageRoot = Root + "/PubSubStorage"

                        };


                        this.httpFileUploadComponent = new HttpFileUploadComponent(this.xmppServer, "upload", this.httpFileUploadSettings);

                        this.httpFileUploadResource = new XmppFileUploadResource("/HttpUpload", this.httpFileUploadComponent, Encrypted);

                        this.httpEncryptedFileUploadResource = new HttpFolderResource("/EncryptedStorage", this.httpFileUploadSettings.EncryptedStorageFolder, false, false, true, false);

                        this.httpPubSubFileUploadResource = new HttpFolderResource("/PubSubStorage", this.httpFileUploadSettings.PubSubStorageFolder, false, false, true, false);

                        this.httpServer.Register(this.httpFileUploadResource);

                        this.httpServer.Register(this.httpEncryptedFileUploadResource);

                        this.httpServer.Register(this.httpPubSubFileUploadResource);


                        Export.OnExportFolderUpdated += this.Export_OnExportFolderUpdated;

                        Export.OnExportKeyFolderUpdated += this.Export_OnExportKeyFolderUpdated;

                    }


                    HttpReverseProxyResource[] ReverseProxies = this.httpServer.GetRegisteredResources<HttpReverseProxyResource>();


                    foreach (HttpReverseProxyResource ProxyResource in ReverseProxies)

                    {

                        if (ProxyResource.UserSessions)

                        {

                            if (this.ssoTokens is null)

                                this.ssoTokens = new Cache<string, string>(int.MaxValue, TimeSpan.FromMinutes(30), TimeSpan.FromMinutes(5));


                            if (ProxyResource.Encrypted)

                                ProxyResource.BeforeForwardRequest += this.ProxyResource_AddSsoInformationEncrypted;

                            else

                                ProxyResource.BeforeForwardRequest += this.ProxyResource_AddSsoInformationUnencrypted;

                        }

                    }

                }


                Gateway.OnNewCertificate += this.Gateway_OnNewCertificate;

                Gateway.ScheduleEvent(this.Service_OnAfterBackup, DateTime.Today.AddDays(1), null);


                if (Types.TryGetModuleParameter("Concentrator", out Obj) && !((this.concentratorServer = Obj as ConcentratorServer) is null))

                {

                    await this.concentratorServer.Register(this.connectionsSource = new ConnectionsSource());

                    await this.concentratorServer.Register(new GatewayConfigSource());

                    await this.concentratorServer.Register(new PersistedDataSource());

                    await this.concentratorServer.Register(new ProgramDataSource());

                    await this.concentratorServer.Register(new ProtocolsSource(new INode[]

                    {

                        new HttpProtocol(this.httpServer),

                        new XmppProtocol(this.xmppServer)

                    }));

                }


                foreach (PubSubNode Node in await Database.Find<PubSubNode>(new FilterAnd(

                    new FilterFieldEqualTo("Service", string.Empty), new FilterFieldEqualTo("IsRoot", true),

                    new FilterFieldEqualTo("PublishOnWeb", true))))

                {

                    this.WebNodeStatus(Node.Name, Node.PublishOnWeb);

                }


                await this.CheckRegistration();


                if (!(Gateway.ProvisioningClient is null))

                    Gateway.ProvisioningClient.ManagePresenceSubscriptionRequests = false;


                if (!(Gateway.SoftwareUpdateClient is null))

                {

                    Gateway.SoftwareUpdateClient.OnSoftwareUpdated += this.SoftwareUpdateClient_OnSoftwareUpdated;

                    Gateway.SoftwareUpdateClient.OnSoftwareValidation += this.SoftwareUpdateClient_OnSoftwareValidation;

                    Gateway.SoftwareUpdateClient.OnSoftwareDownloaded += this.SoftwareUpdateClient_OnSoftwareDownloaded;

                    Gateway.SoftwareUpdateClient.OnSoftwareDeleted += this.SoftwareUpdateClient_OnSoftwareDeleted;

                    Gateway.SoftwareUpdateClient.OnDownloadedSoftwareDeleted += this.SoftwareUpdateClient_OnDownloadedSoftwareDeleted;

                }


                Gateway.XmppClient.OnStateChanged += this.XmppClient_OnStateChanged;

                Gateway.XmppClient.OnChatMessage += this.XmppClient_OnChatMessage;


                if (!(Gateway.MucClient is null))

                {

                    Gateway.XmppClient.OnGroupChatMessage += this.XmppClient_OnGroupChatMessage;

                    Gateway.XmppClient.OnValidateSender += this.XmppClient_OnValidateSender;


                    Gateway.MucClient.RoomInvitationReceived += this.MucClient_RoomInvitationReceived;

                    Gateway.MucClient.DirectInvitationReceived += this.MucClient_DirectInvitationReceived;

                    Gateway.MucClient.OccupantPresence += this.MucClient_OccupantPresence;

                    Gateway.MucClient.PrivateMessageReceived += this.MucClient_PrivateMessageReceived;

                    Gateway.MucClient.RoomDestroyed += this.MucClient_RoomDestroyed;


                    await this.LoadPermanentRooms();

                }


                await Gateway.XmppClient.SetPresence(Networking.XMPP.Availability.Chat);


                TP = await RuntimeSettings.GetAsync(AutoInstallTimeParameterName, DateTime.MinValue);

                if (TP > DateTime.MinValue)

                    autoUpdateTP = Gateway.ScheduleEvent(this.UpdateSoftware, TP, null);


                StringBuilder sb = new StringBuilder();

                SortedDictionary<string, bool> AlphabeticalOrder = new SortedDictionary<string, bool>();


                foreach (Assembly A in Types.Assemblies)

                    AlphabeticalOrder[A.FullName] = true;


                foreach (string Name in AlphabeticalOrder.Keys)

                    sb.AppendLine(Name);


                string H = Hashes.ComputeSHA256HashString(Encoding.UTF8.GetBytes(sb.ToString()));

                string H2 = await RuntimeSettings.GetAsync("BrokerVersion", string.Empty);

                bool Updated = H != H2;


                if (Gateway.Domain != "example.com" &&

                    Gateway.Domain != "example2.com" &&

                    Gateway.Domain != "example3.com" &&

                    Gateway.Domain != "localhost" &&

                    !string.IsNullOrEmpty(Gateway.Domain))

                {

                    Now = DateTime.Now;


                    sb.Clear();


                    sb.Append("XMPP server at [`");

                    sb.Append(Gateway.Domain);

                    sb.Append("`](http://");

                    sb.Append(Gateway.Domain);

                    sb.Append("/) ");


                    if (Updated)

                        sb.Append("updated and ");


                    sb.Append("restarted at ");

                    sb.Append(Now.ToShortDateString());

                    sb.Append(", ");

                    sb.Append(Now.ToLongTimeString());

                    sb.Append('.');


                    if (Updated)

                        sb.Append(" [Release Notes](https://lab.tagroot.io/ReleaseNotes)");


                    await Gateway.SendNotification(sb.ToString());

                }


                if (Updated)

                    await RuntimeSettings.SetAsync("BrokerVersion", H);


                await LegalComponent.CheckLegalIdentityReferences();

                await PaiwiseProcessor.QueueUnprocessedPayments(this.eDalerComponent);

                await ComponentSynchronization.QueueUnprocessedMessages();

                await MarketplaceProcessor.LoadActiveItems(this.eDalerComponent);

                await StateMachineProcessor.ModuleStarted(this.legalComponent, this.eDalerComponent);


                if (!string.IsNullOrEmpty(Gateway.Domain) && DomainConfiguration.Instance.UseEncryption)    // i.e. accessible from the Internet using domain name.

                    Gateway.HttpxProxy.PostResource = this.xmppOverHttp;

                /*{

                    IPAddress MyExternalIp = null;

                    IPAddress MyLocalIp = null;


                    try

                    {

                        WebPoster Poster = new WebPoster();


                        object Response = await InternetContent.PostAsync(new Uri("https://" + XmppConfiguration.Instance.Host + "/WMEP"), null);

                        if (Response is string PlainText)

                        {

                            int i = PlainText.LastIndexOf(':');

                            if (i > 0)

                            {

                                PlainText = PlainText.Substring(0, i);

                                if (IPAddress.TryParse(PlainText, out IPAddress Address))

                                {

                                    if (InternetGatewayRegistrator.IsPublicAddress(Address))

                                    {

                                        Gateway.HttpxProxy.PostResource = "https://" + MyExternalIp.ToString() + "/HTTPX";


                                        using (TcpClient Client = new TcpClient())

                                        {

                                            await Client.ConnectAsync(XmppConfiguration.Instance.Host, XmppConfiguration.Instance.Port);

                                            if (Client.Client.LocalEndPoint is IPEndPoint Endpoint)

                                            {

                                                MyLocalIp = Endpoint.Address;

                                                MyExternalIp = Address;

                                            }


                                            Client.Close();

                                        }

                                    }

                                }

                            }

                        }

                    }

                    catch (Exception)

                    {

                        // Unable to get public IP from parent neuron.

                    }

                }*/


                Gateway.ScheduleEvent(this.ImportIpLocalizationDatabase, DateTime.Now.AddMinutes(15), null);


                Gateway.OnTerminate += this.Gateway_OnTerminate;


                Log.Informational("XMPP Server started.");

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        private Task Gateway_OnTerminate(object Sender, EventArgs e)

        {

            System.Timers.Timer Timer1 = new System.Timers.Timer(90000);

            Timer1.Elapsed += this.CloseProcess;


            System.Timers.Timer Timer2 = new System.Timers.Timer(110000);

            Timer1.Elapsed += this.KillProcess;


            return Task.CompletedTask;

        }


        private void CloseProcess(object Sender, System.Timers.ElapsedEventArgs e)

        {

            Process.GetCurrentProcess().Close();

        }


        private void KillProcess(object Sender, System.Timers.ElapsedEventArgs e)

        {

            Process.GetCurrentProcess().Kill();

        }


        private async Task Root_FileNotFound(object Sender, FileNotFoundEventArgs e)

        {

            try

            {

                NotFoundException ex = e.Exception;

                string s = e.Request.SubPath;

                if (s.StartsWith("/"))

                    s = s.Substring(1);


                if (!(this.vulnerableResources?.ContainsKey(s) ?? false))

                    return;


                e.Exception = null;


                bool Blocked = await Gateway.LoginAuditor.ProcessLoginFailure(e.Request.RemoteEndPoint, "HTTP", DateTime.Now,

                    "Scanning for vulnerable web resources.");


                Log.Warning("Honey-pot resource requested.", "/" + s, e.Request.RemoteEndPoint, "HoneyPot",

                    new KeyValuePair<string, object>("Blocked", Blocked));

                e.Request.Session?.Add("HoneyPotBlocked", Blocked);


                await Task.Delay(60000);    // Wait one minute before returning response. (After 2 minutes, the request is removed from the server.)


                string ContentType = ex.ContentType;

                byte[] Content = ex.Content;


                if (Content is null)

                {

                    object ContentObject = await ex.GetContentObjectAsync();


                    if (ContentObject is null)

                    {

                        Content = Encoding.UTF8.GetBytes(ex.Message);

                        ContentType = "text/plain; charset=utf-8";

                    }

                    else

                    {

                        KeyValuePair<byte[], string> P = await InternetContent.EncodeAsync(ContentObject, Encoding.UTF8);

                        Content = P.Key;

                        ContentType = P.Value;

                    }

                }


                string Html = await Gateway.GetCustomErrorHtml(e.Request, "HoneyPot.md", ContentType, Content);

                if (!string.IsNullOrEmpty(Html))

                {

                    e.Response.StatusCode = ex.StatusCode;

                    e.Response.StatusMessage = ex.Message;


                    if (!(ex.HeaderFields is null))

                    {

                        foreach (KeyValuePair<string, string> P in ex.HeaderFields)

                        {

                            if (string.Compare(P.Key, "Content-Type", true) != 0)

                                e.Response.SetHeader(P.Key, P.Value);

                        }

                    }


                    e.Response.ContentType = "text/html; charset=utf-8";

                    await e.Response.Write(Encoding.UTF8.GetBytes(Html));

                    await e.Response.SendResponse();

                }

                else

                    await e.Response.SendResponse(ex);


                await e.Response.DisposeAsync();

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        private bool subscribingSWUpdates = false;

        private bool subscribedToPackages = false;


        private async Task XmppClient_OnStateChanged(object Sender, Networking.XMPP.XmppState NewState)

        {

            if (NewState == Networking.XMPP.XmppState.Connected)

            {

                if (!(Gateway.SoftwareUpdateClient is null) &&

                    !this.subscribingSWUpdates &&

                    string.Compare(Gateway.XmppClient.Domain, this.xmppServer?.Domain, true) != 0)

                {

                    this.subscribingSWUpdates = true;

                    try

                    {

                        DateTime LastUpdate = await RuntimeSettings.GetAsync("SW.Update.Last", DateTime.MinValue);


                        if ((DateTime.Now - LastUpdate).TotalDays >= 7 || !this.subscribedToPackages)

                        {

                            await Gateway.SoftwareUpdateClient.SubscribeAsync("*");

                            this.subscribedToPackages = true;


                            foreach (Networking.XMPP.Software.Package Package in await Gateway.SoftwareUpdateClient.GetPackagesAsync())

                                await this.CheckSoftwarePackage(Package, (P, MessageId) => Task.FromResult<string>(MessageId));


                            await RuntimeSettings.SetAsync("SW.Update.Last", DateTime.Now);

                        }

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                    }

                    finally

                    {

                        this.subscribingSWUpdates = false;

                    }

                }


                await this.RejoinRooms();

            }

        }


        private Task Gateway_OnNewCertificate(object Sender, IoTGateway.Events.CertificateEventArgs e)

        {

            this.smtpServer?.UpdateCertificate(e.Certificate);

            this.xmppServer?.UpdateCertificate(e.Certificate);


            return Task.CompletedTask;

        }


        internal void WebNodeStatus(CaseInsensitiveString NodeName, bool Visible)

        {

            WebNode WebNode;


            if (Visible)

            {

                lock (this.webNodes)

                {

                    if (this.webNodes.ContainsKey(NodeName))

                        return;


                    WebNode = new WebNode(NodeName);

                    this.webNodes[NodeName] = WebNode;

                }


                try

                {

                    this.httpServer.Register(WebNode);

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);


                    lock (this.webNodes)

                    {

                        this.webNodes.Remove(NodeName);

                    }

                }

            }

            else

            {

                lock (this.webNodes)

                {

                    if (!this.webNodes.TryGetValue(NodeName, out WebNode))

                        return;


                    this.webNodes.Remove(NodeName);

                }


                this.httpServer.Unregister(WebNode);

            }

        }


        public async Task DoImportIpLocalizationDatabase()

        {

            string s = Path.Combine(PackagesFolder, Ip2LocalizationPackageName);

            await RuntimeSettings.SetAsync(s, DateTime.MinValue);

            this.ImportIpLocalizationDatabase(null);

        }


        private static bool importingIp = false;


        private async void ImportIpLocalizationDatabase(object State)

        {

            if (!importingIp)

            {

                importingIp = true;

                try

                {

                    string s = Path.Combine(PackagesFolder, Ip2LocalizationPackageName);


                    if (File.Exists(s))

                    {

                        DateTime TP = File.GetLastWriteTime(s);

                        DateTime Last = await RuntimeSettings.GetAsync(s, DateTime.MinValue);


                        if (TP > Last)

                        {

                            StringBuilder sb = new StringBuilder("Samples:=[");

                            DateTime Start = DateTime.Now;

                            long Count = 0;

                            long Skipped = 0;

                            bool First = true;


                            Log.Informational("Starting import of IP localization database.");

                            await Gateway.SendNotification("Starting import of IP localization database.");


                            await Database.Clear("IP4Localization");


                            try

                            {

                                await FindIpAddress("127.0.0.1");  // Makes sure indices are created.

                            }

                            catch (Exception ex)

                            {

                                Log.Exception(ex);

                            }


                            await Database.StartBulk();

                            try

                            {

                                using (FileStream fs = File.OpenRead(s))

                                {

                                    using (StreamReader r = new StreamReader(fs))

                                    {

                                        while (!r.EndOfStream)

                                        {

                                            string Row = await r.ReadLineAsync();

                                            string[][] Records = CSV.Parse(Row);


                                            foreach (string[] Record in Records)

                                            {

                                                if (Record.Length >= 6 &&

                                                    uint.TryParse(Record[0], out uint IpRangeFrom) &&

                                                    uint.TryParse(Record[1], out uint IpRangeTo))

                                                {

                                                    Count++;


                                                    IP4Localization Rec = new IP4Localization()

                                                    {

                                                        RangeStart = IpRangeFrom,

                                                        RangeEnd = IpRangeTo,

                                                        CountryCode = Record[2],

                                                        Country = Record[3],

                                                        Region = Record[4],

                                                        City = Record[5]

                                                    };


                                                    await Database.Insert(Rec);


                                                    if (Count % 10000 == 0)

                                                    {

                                                        await Database.EndBulk();

                                                        await Database.StartBulk();


                                                        if (First)

                                                            First = false;

                                                        else

                                                            sb.AppendLine(",");


                                                        sb.Append('[');

                                                        sb.Append(Count.ToString());

                                                        sb.Append(',');

                                                        sb.Append(CommonTypes.Encode((DateTime.Now - Start).TotalSeconds));

                                                        sb.Append(']');

                                                    }

                                                }

                                                else

                                                    Skipped++;

                                            }

                                        }


                                    }

                                }

                            }

                            finally

                            {

                                await Database.EndBulk();

                            }


                            if (!First)

                                sb.AppendLine(",");


                            sb.Append('[');

                            sb.Append(Count.ToString());

                            sb.Append(',');

                            sb.Append(CommonTypes.Encode((DateTime.Now - Start).TotalSeconds));

                            sb.AppendLine("]];");


                            sb.AppendLine("Objects:=Samples[0,];");

                            sb.AppendLine("Seconds:=Samples[1,];");

                            sb.AppendLine("ObjOverTime:=plot2dcurve(Seconds,Objects);");

                            sb.AppendLine("ObjOverTime.Title:=\"Objects imported over time\";");

                            sb.AppendLine("ObjOverTime.LabelX:=\"Seconds\";");

                            sb.AppendLine("ObjOverTime.LabelY:=\"#Objects\";");


                            sb.AppendLine("NrSamples:=count(Objects);");

                            sb.AppendLine("DeltaSeconds:=Seconds[1..(NrSamples-1)]-Seconds[0..(NrSamples-2)];");

                            sb.AppendLine("DeltaObjects:=Objects[1..(NrSamples-1)]-Objects[0..(NrSamples-2)];");

                            sb.AppendLine("ObjectsPerSecond:=DeltaObjects./DeltaSeconds;");

                            sb.AppendLine("SpeedOverTime:=plot2dcurve(Seconds[1..(NrSamples-1)],ObjectsPerSecond);");

                            sb.AppendLine("SpeedOverTime.Title:=\"Objects/s imported over time\";");

                            sb.AppendLine("SpeedOverTime.LabelX:=\"Seconds\";");

                            sb.AppendLine("SpeedOverTime.LabelY:=\"#Objects/s\";");


                            File.WriteAllText(appData + "ImportTimes.script", sb.ToString());


                            Log.Informational("Import of IP localization database completed.",

                                new KeyValuePair<string, object>("NrImported", Count),

                                new KeyValuePair<string, object>("NrSkipped", Skipped));


                            await RuntimeSettings.SetAsync(s, TP);


                            await Gateway.SendNotification("Import of IP localization database completed. " +

                                Count.ToString() + " records imported. " + Skipped.ToString() + " " +

                                (Skipped == 1 ? "record" : "records") + " skipped.");


                            try

                            {

                                Expression Exp = new Expression(sb.ToString());

                                Variables Variables = HttpServer.CreateVariables();


                                await Exp.EvaluateAsync(Variables);


                                if (Variables.TryGetVariable("ObjOverTime", out Variable v) && v.ValueObject is Graph ObjOverTime)

                                    await Gateway.SendNotification(ObjOverTime);


                                if (Variables.TryGetVariable("SpeedOverTime", out v) && v.ValueObject is Graph SpeedOverTime)

                                    await Gateway.SendNotification(SpeedOverTime);

                            }

                            catch (Exception ex)

                            {

                                Log.Exception(ex);

                            }

                        }

                    }

                }

                catch (Exception ex)

                {

                    Log.Error("Unable to import IP localization database.\r\n\r\n" + ex.Message, Ip2LocalizationPackageName);

                }

                finally

                {

                    importingIp = false;

                }

            }

        }


        private async Task LoginAuditor_AnnotateEndpoint(object Sender, AnnotateEndpointEventArgs e)

        {

            if (this.ip4LocalizationCache is null)

                return;


            if (!this.ip4LocalizationCache.TryGetValue(e.RemoteEndpoint, out IP4Localization Location))

            {

                Location = await FindIpAddress(e.RemoteEndpoint);

                this.ip4LocalizationCache?.Add(e.RemoteEndpoint, Location);

            }


            if (!(Location is null))

            {

                e.AddTag("City", Location.City);

                e.AddTag("Region", Location.Region);

                e.AddTag("Country", Location.Country);

                e.AddTag("Code", Location.CountryCode);


                string s = "flag-" + Location.CountryCode?.ToLower();

                if (EmojiUtilities.TryGetEmoji(s, out EmojiInfo _))

                    e.AddTag("Flag", ":" + s + ":");


                e.AddTag("Acknowledgement", "This site or product includes IP2Location LITE data available from http://www.ip2location.com.");

            }

        }


        public static Task<IP4Localization> FindIpAddress(string RemoteEndpoint)

        {

            int i = RemoteEndpoint.LastIndexOf(':');

            if (i > 0 && int.TryParse(RemoteEndpoint.Substring(i + 1), out int _))

                RemoteEndpoint = RemoteEndpoint.Substring(0, i);


            if (!IPAddress.TryParse(RemoteEndpoint, out IPAddress Addr))

                return Task.FromResult<IP4Localization>(null);


            return FindIpAddress(Addr);

        }


        public static async Task<IP4Localization> FindIpAddress(IPAddress Addr)

        {

            if (Addr.AddressFamily != AddressFamily.InterNetwork)

                return null;


            byte[] Bytes = Addr.GetAddressBytes();


            uint Value = Bytes[0];

            Value <<= 8;

            Value |= Bytes[1];

            Value <<= 8;

            Value |= Bytes[2];

            Value <<= 8;

            Value |= Bytes[3];


            try

            {

                foreach (IP4Localization Loc in await Database.Find<IP4Localization>(0, 1, new FilterFieldLesserOrEqualTo("RangeStart", Value), "-RangeStart"))

                {

                    if (Value >= Loc.RangeStart && Value <= Loc.RangeEnd)

                        return Loc;

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }


            return null;

        }


        public async static Task AppendRemoteEndpointToTable(StringBuilder Markdown, string RemoteEndpoint)

        {

            Markdown.Append("| Remote Endpoint: | ");

            Markdown.Append(RemoteEndpoint);

            Markdown.AppendLine(" |");


            foreach (KeyValuePair<string, object> P in await LoginAuditor.Annotate(RemoteEndpoint))

            {

                Markdown.Append("| ");

                Markdown.Append(MarkdownDocument.Encode(P.Key));

                Markdown.Append(" | ");

                Markdown.Append(MarkdownDocument.Encode(P.Value?.ToString() ?? string.Empty));

                Markdown.AppendLine(" |");

            }

        }


        private async void Service_OnAfterBackup(object P)

        {

            try

            {

                if (!(this.httpServer is null))

                {

                    Networking.HTTP.CommunicationStatistics Stat = this.httpServer.GetCommunicationStatisticsSinceLast();


                    Sources.Protocols.Commands.HttpStatistic HttpStatistic = new Sources.Protocols.Commands.HttpStatistic()

                    {

                        Start = Stat.LastStat,

                        Timestamp = Stat.CurrentStat,

                        NrBytesRx = Stat.NrBytesRx,

                        NrBytesTx = Stat.NrBytesTx,

                        NrCalls = Stat.NrCalls,

                        CallsPerMethod = this.Convert(Stat.CallsPerMethod),

                        CallsPerUserAgent = this.Convert(Stat.CallsPerUserAgent),

                        CallsPerFrom = this.Convert(Stat.CallsPerFrom),

                        CallsPerResource = this.Convert(Stat.CallsPerResource)

                    };


                    await Database.InsertLazy(HttpStatistic);

                }


                if (!(this.xmppServer is null))

                {

                    Networking.XMPP.Server.Statistics.CommunicationStatistics Stat = this.xmppServer.GetCommunicationStatisticsSinceLast();


                    Sources.Protocols.Commands.XmppStatistic XmppStatistic = new Sources.Protocols.Commands.XmppStatistic()

                    {

                        Start = Stat.LastStat,

                        Timestamp = Stat.CurrentStat,

                        NrBytesRx = Stat.NrBytesRx,

                        NrBytesTx = Stat.NrBytesTx,

                        NrStanzas = Stat.NrStanzas,

                        StanzasPerStanzaType = this.Convert(Stat.StanzasPerStanzaType),

                        StanzasPerFromDomain = this.Convert(Stat.StanzasPerFromDomain),

                        StanzasPerToDomain = this.Convert(Stat.StanzasPerToDomain),

                        StanzasPerFromBareJid = this.Convert(Stat.StanzasPerFromBareJid),

                        StanzasPerToBareJid = this.Convert(Stat.StanzasPerToBareJid),

                        StanzasPerNamespace = this.Convert(Stat.StanzasPerNamespace),

                        StanzasPerFqn = this.Convert(Stat.StanzasPerFqn)

                    };


                    await Database.InsertLazy(XmppStatistic);

                }


                if (!(this.eventStatistics is null))

                {

                    EventStatistics Stat = this.eventStatistics.GetStatisticsSinceLast();


                    Sources.PersistedData.Commands.EventStatistic EventStatistic = new Sources.PersistedData.Commands.EventStatistic()

                    {

                        Start = Stat.LastStat,

                        Timestamp = Stat.CurrentStat,

                        PerType = this.Convert(Stat.PerType),

                        PerLevel = this.Convert(Stat.PerLevel),

                        PerEventId = this.Convert(Stat.PerEventId),

                        PerActor = this.Convert(Stat.PerActor),

                        PerModule = this.Convert(Stat.PerModule),

                        PerFacility = this.Convert(Stat.PerFacility),

                        PerStackTrace = this.Convert(Stat.PerStackTrace)

                    };


                    await Database.InsertLazy(EventStatistic);

                }


                DateTime TimeLimit = DateTime.Now.AddDays(-30);  // TODO: Make configurable.

                int Nr, Nr2;


                if (!(this.persistenceLayer is null))

                {

                    Nr = await this.persistenceLayer.DeleteOfflineMessages(TimeLimit);

                    if (Nr > 0)

                        Log.Informational(Nr.ToString() + " offline messages deleted.");

                }


                if (!(this.xmppServer is null))

                {

                    Nr = await this.xmppServer.DeleteOldMailContent(TimeLimit);

                    if (Nr > 0)

                        Log.Informational("Mail content from " + Nr.ToString() + " old messages deleted.");

                }


                if (!(this.pubSubComponent is null))

                {

                    (Nr, Nr2) = await this.pubSubComponent.DeleteExpiredNodes();

                    if (Nr > 0)

                        Log.Informational(Nr.ToString() + " pubsub nodes (and " + Nr2.ToString() + " items) deleted.");

                }


                (int NrTokens, int NrEvents, int NrTags) = await NeuroFeatures.NeuroFeaturesProcessor.DeleteExpiredTokens();

                if (NrTokens > 0)

                    Log.Informational(NrTokens.ToString() + " tokens, " + NrTags.ToString() + " tags and " + NrEvents.ToString() + " events deleted.");


                (int NrMachines, int NrEventHandlers, int NrCurrentStates, int NrSamples) =

                    await StateMachineProcessor.DeleteExpiredMachines();

                if (NrMachines > 0)

                    Log.Informational(NrMachines.ToString() + " state machines, " + NrEventHandlers.ToString() + " event handlers and " + NrSamples.ToString() + " samples deleted.");

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

            finally

            {

                Gateway.ScheduleEvent(this.Service_OnAfterBackup, DateTime.Today.AddDays(1), null);

            }

        }


        private Sources.PersistedData.Commands.Statistic[] Convert(Dictionary<string, Statistic> Statistics)

        {

            List<Sources.PersistedData.Commands.Statistic> Result = new List<Sources.PersistedData.Commands.Statistic>();


            foreach (KeyValuePair<string, Statistic> P in Statistics)

            {

                Result.Add(new Sources.PersistedData.Commands.Statistic()

                {

                    Name = P.Key,

                    Count = P.Value.Count,

                    First = P.Value.First,

                    Last = P.Value.Last

                });

            }


            return Result.ToArray();

        }


        public async Task Stop()

        {

            Log.Informational("XMPP Server shutting down.");


            await PaiwiseProcessor.StopProcessingPayments();

            await StateMachineProcessor.ModuleStopped();


            Gateway.OnNewCertificate -= this.Gateway_OnNewCertificate;

            Gateway.OnTerminate -= this.Gateway_OnTerminate;


            if (!(Gateway.SoftwareUpdateClient is null))

            {

                Gateway.SoftwareUpdateClient.OnSoftwareUpdated -= this.SoftwareUpdateClient_OnSoftwareUpdated;

                Gateway.SoftwareUpdateClient.OnSoftwareValidation -= this.SoftwareUpdateClient_OnSoftwareValidation;

                Gateway.SoftwareUpdateClient.OnSoftwareDownloaded -= this.SoftwareUpdateClient_OnSoftwareDownloaded;

                Gateway.SoftwareUpdateClient.OnSoftwareDeleted -= this.SoftwareUpdateClient_OnSoftwareDeleted;

                Gateway.SoftwareUpdateClient.OnDownloadedSoftwareDeleted -= this.SoftwareUpdateClient_OnDownloadedSoftwareDeleted;

            }


            if (!(Gateway.MucClient is null))

            {

                Gateway.XmppClient.OnGroupChatMessage -= this.XmppClient_OnGroupChatMessage;

                Gateway.XmppClient.OnValidateSender -= this.XmppClient_OnValidateSender;


                Gateway.MucClient.RoomInvitationReceived -= this.MucClient_RoomInvitationReceived;

                Gateway.MucClient.DirectInvitationReceived -= this.MucClient_DirectInvitationReceived;

                Gateway.MucClient.OccupantPresence -= this.MucClient_OccupantPresence;

                Gateway.MucClient.PrivateMessageReceived -= this.MucClient_PrivateMessageReceived;

                Gateway.MucClient.RoomDestroyed -= this.MucClient_RoomDestroyed;

            }


            this.sampleTimer?.Dispose();

            this.sampleTimer = null;


            await this.LeaveAllRooms();


            LoginAuditor.AnnotateEndpoint -= this.LoginAuditor_AnnotateEndpoint;

            this.ip4LocalizationCache?.Dispose();

            this.ip4LocalizationCache = null;


            if (!(this.eventStatistics is null))

            {

                Log.Unregister(this.eventStatistics);

                this.eventStatistics.Dispose();

                this.eventStatistics = null;

            }


            instance = null;


            if (!(this.vulnerableResources is null))

            {

                this.vulnerableResources = null;


                if (!(Gateway.Root is null))

                    Gateway.Root.FileNotFound -= this.Root_FileNotFound;

            }


            if (!(this.httpServer is null))

            {

                Export.OnExportFolderUpdated -= this.Export_OnExportFolderUpdated;

                Export.OnExportKeyFolderUpdated -= this.Export_OnExportKeyFolderUpdated;


                this.httpServer.Unregister(this.webClient1);

                this.httpServer.Unregister(this.webClient2);

                this.httpServer.Unregister(this.webSocketClient);

                this.httpServer.Unregister(this.webHostMetaDataXml);

                this.httpServer.Unregister(this.webHostMetaDataJson);

                this.httpServer.Unregister(this.packages);

                this.httpServer.Unregister(this.createApiKey);

                this.httpServer.Unregister(this.updateApiKey);

                this.httpServer.Unregister(this.createAccount);

                this.httpServer.Unregister(this.updateAccount);

                this.httpServer.Unregister(this.deleteAccount);

                this.httpServer.Unregister(this.updatePubSubNode);

                this.httpServer.Unregister(this.deletePubSubNode);

                this.httpServer.Unregister(this.loadMoreItems);

                this.httpServer.Unregister(this.feedback);

                this.httpServer.Unregister(this.requestAccount);

                this.httpServer.Unregister(this.requestApiKey);

                this.httpServer.Unregister(this.searchEvents);

                this.httpServer.Unregister(this.sendMessage);

                this.httpServer.Unregister(this.setContractState);

                this.httpServer.Unregister(this.publisherAvatar);

                this.httpServer.Unregister(this.legalIdentityStateChanged);

                this.httpServer.Unregister(this.qr);

                this.httpServer.Unregister(this.uploadPackage);

                this.httpServer.Unregister(this.uploadSignature);

                this.httpServer.Unregister(this.deletePackage);

                this.httpServer.Unregister(this.installPackage);

                this.httpServer.Unregister(this.uninstallPackage);

                this.httpServer.Unregister(this.dnsOverHttps);

                this.httpServer.Unregister(this.validateLegalId);

                this.httpServer.Unregister(this.validateContract);

                this.httpServer.Unregister(this.mfa);

                this.httpServer.Unregister(this.quickLogin);

                this.httpServer.Unregister(this.whatsMyEndpointResource);

                this.httpServer.Unregister(this.addNote);

                this.httpServer.Unregister(this.chatFile);

                this.httpServer.Unregister(this.xmppOverHttp);


                this.httpxServer?.Dispose();

                this.httpxServer = null;


                if (!(this.httpFileUploadResource is null))

                    this.httpServer.Unregister(this.httpFileUploadResource);


                if (!(this.httpEncryptedFileUploadResource is null))

                    this.httpServer.Unregister(this.httpEncryptedFileUploadResource);


                if (!(this.httpPubSubFileUploadResource is null))

                    this.httpServer.Unregister(this.httpPubSubFileUploadResource);


                if (!(this.webNodes is null))

                {

                    WebNode[] Nodes;


                    lock (this.webNodes)

                    {

                        Nodes = new WebNode[this.webNodes.Count];

                        this.webNodes.Values.CopyTo(Nodes, 0);

                        this.webNodes.Clear();

                    }


                    foreach (WebNode WebNode in Nodes)

                        this.httpServer.Unregister(WebNode);

                }


                this.webClient1 = null;

                this.webClient2 = null;

                this.webSocketClient = null;

                this.webHostMetaDataXml = null;

                this.webHostMetaDataJson = null;

                this.createApiKey = null;

                this.updateApiKey = null;

                this.createAccount = null;

                this.updateAccount = null;

                this.deleteAccount = null;

                this.updatePubSubNode = null;

                this.deletePubSubNode = null;

                this.loadMoreItems = null;

                this.feedback = null;

                this.requestAccount = null;

                this.requestApiKey = null;

                this.searchEvents = null;

                this.sendMessage = null;

                this.setContractState = null;

                this.publisherAvatar = null;

                this.legalIdentityStateChanged = null;

                this.qr = null;

                this.uploadPackage = null;

                this.uploadSignature = null;

                this.deletePackage = null;

                this.installPackage = null;

                this.uninstallPackage = null;

                this.dnsOverHttps = null;

                this.validateLegalId = null;

                this.validateContract = null;

                this.mfa = null;

                this.quickLogin?.Dispose();

                this.quickLogin = null;

                this.whatsMyEndpointResource = null;

                this.addNote = null;

                this.chatFile = null;

                this.xmppOverHttp = null;

                this.httpFileUploadResource = null;

                this.httpEncryptedFileUploadResource = null;

                this.httpPubSubFileUploadResource = null;


                this.httpServer = null;

            }


            this.httpFileUploadComponent?.Dispose();

            this.httpFileUploadComponent = null;


            this.socks5Component?.Dispose();

            this.socks5Component = null;


            this.serviceRegistrationComponent?.Dispose();

            this.serviceRegistrationComponent = null;


            this.pubSubComponent?.Dispose();

            this.pubSubComponent = null;


            this.mucComponent?.Dispose();

            this.mucComponent = null;


            this.provisioningComponent?.Dispose();

            this.provisioningComponent = null;


            this.legalComponent?.Dispose();

            this.legalComponent = null;


            this.eDalerComponent?.Dispose();

            this.eDalerComponent = null;


            this.eventLogComponent?.Dispose();

            this.eventLogComponent = null;


            if (!(this.xmppServer is null))

            {

                this.xmppServer.ClientConnectionAdded -= this.XmppServer_ClientConnectionAdded;

                this.xmppServer.ClientConnectionRemoved -= this.XmppServer_ClientConnectionRemoved;

                this.xmppServer.ClientConnectionUpdated -= this.XmppServer_ClientConnectionUpdated;

                this.xmppServer.ServerConnectionAdded -= this.XmppServer_ServerConnectionAdded;

                this.xmppServer.ServerConnectionRemoved -= this.XmppServer_ServerConnectionRemoved;

                this.xmppServer.ServerConnectionUpdated -= this.XmppServer_ServerConnectionUpdated;


                this.xmppServer.Dispose();

                this.xmppServer = null;

            }


            this.smtpServer?.Dispose();

            this.smtpServer = null;


            this.chatSessions?.Dispose();

            this.chatSessions = null;


            this.consolidators?.Dispose();

            this.consolidators = null;


            this.ssoTokens?.Dispose();

            this.ssoTokens = null;


            this.jwtFactory?.Dispose();

            this.jwtFactory = null;


            Log.Informational("XMPP Server shut down.");

        }


        public static XmppServerModule Instance => instance;

        public static XmppServer Server => instance?.xmppServer;

        public static SmtpServer MailServer => instance?.smtpServer;

        public static Socks5Component Socks5 => instance?.socks5Component;

        public static ProvisioningComponent Provisioning => instance?.provisioningComponent;

        public static LegalComponent Legal => instance?.legalComponent;

        public static EDalerComponent EDaler => instance?.eDalerComponent;

        public static PubSubComponent PubSub => instance?.pubSubComponent;

        public static MultiUserChatComponent Muc => instance?.mucComponent;

        public static ServiceRegistrationComponent ServiceRegistry => instance?.serviceRegistrationComponent;

        public static EventLogComponent EventLog => instance?.eventLogComponent;

        public static PersistenceLayer PersistenceLayer => instance?.persistenceLayer;


        public static string PackagesFolder

        {

            get { return Gateway.SoftwareUpdateClient?.PackageFolder ?? Path.Combine(Gateway.AppDataFolder, "Packages"); }

        }


        public static string DownloadsFolder

        {

            get { return Path.Combine(Gateway.RootFolder, "Downloads"); }

        }


        public static ApiKey GetApiKey(string Key)

        {

            ApiKey Result = GetApiKeyAsync(Key).Result

                ?? throw new NotFoundException();


            return Result;

        }


        public static async Task<ApiKey> GetApiKeyAsync(string Key)

        {

            if (string.IsNullOrEmpty(Key))

            {

                return new ApiKey()

                {

                    // TODO: Add statistics.

                };

            }

            else

            {

                foreach (ApiKey ApiKey in await Database.Find<ApiKey>(new FilterFieldEqualTo("Key", Key)))

                    return ApiKey;


                return null;

            }

        }


        public static IAccount GetAccount(CaseInsensitiveString UserName)

        {

            IAccount Result = GetAccountAsync(UserName).Result

                ?? throw new NotFoundException();


            return Result;

        }


        public static Task<IAccount> GetAccountAsync(CaseInsensitiveString UserName)

        {

            if (instance is null)

                return GetAccountAsyncNoInit(UserName);

            else

                return ((IXmppServerPersistenceLayer)instance.persistenceLayer).GetAccount(UserName);

        }


        private static async Task<IAccount> GetAccountAsyncNoInit(CaseInsensitiveString UserName)

        {

            foreach (Account Account in await Database.Find<Account>(new FilterFieldEqualTo("UserName", UserName)))

                return Account;


            return null;

        }


        public static Task<IRosterItem> GetRosterItemAsync(CaseInsensitiveString UserName, CaseInsensitiveString Jid)

        {

            if (instance is null)

                return GetRosterItemAsyncNoInit(UserName, Jid);

            else

                return instance.persistenceLayer.GetRosterItem(UserName, Jid);

        }


        private static async Task<IRosterItem> GetRosterItemAsyncNoInit(CaseInsensitiveString UserName, CaseInsensitiveString Jid)

        {

            foreach (RosterItem Item in await Database.Find<RosterItem>(new FilterAnd(

                new FilterFieldEqualTo("UserName", UserName),

                new FilterFieldEqualTo("BareJid", Jid))))

            {

                return Item;

            }


            return null;

        }


        public static Task<IEnumerable<IRosterItem>> GetRosterAsync(CaseInsensitiveString UserName)

        {

            if (instance is null)

                return GetRosterAsyncNoInit(UserName);

            else

                return instance.persistenceLayer.GetRoster(UserName);

        }


        private static async Task<IEnumerable<IRosterItem>> GetRosterAsyncNoInit(CaseInsensitiveString UserName)

        {

            return await Database.Find<RosterItem>(new FilterAnd(

                new FilterFieldEqualTo("UserName", UserName)));

        }


        private static Stopwatch CreateWatch()

        {

            Stopwatch Watch = new Stopwatch();

            Watch.Start();


            calibration = Calibrate(Watch);


            return Watch;

        }


        public static void Calibrate()

        {

            calibration = Calibrate(clock);

        }


        private static Calibration Calibrate(Stopwatch Clock)

        {

            DateTime TP = DateTime.Now;

            long Ticks = TP.Ticks;

            long HF = 0;

            int i;


            for (i = 0; i < 3; i++)   // An extra round, to avoid JIT effects.

            {

                while ((TP = DateTime.UtcNow).Ticks == Ticks)

                    ;


                HF = Clock.ElapsedTicks;

                Ticks = TP.Ticks;

            }


            return new Calibration()

            {

                Reference = TP,

                ReferenceHfTick = HF,

                TicksTo100Ns = 1e7 / Stopwatch.Frequency

            };

        }


        public static DateTimeHF Now

        {

            get

            {

                DateTime NowRef = DateTime.UtcNow;

                long Ticks = clock.ElapsedTicks;

                Calibration Calibration = calibration;


                Ticks -= Calibration.ReferenceHfTick;


                long Ns100 = (long)(Ticks * Calibration.TicksTo100Ns + 0.5);

                long Milliseconds = Ns100 / 10000;


                DateTime Now = Calibration.Reference.AddMilliseconds(Milliseconds);


                if ((Now - NowRef).TotalSeconds >= 1)

                {

                    Calibrate();

                    return XmppServerModule.Now;

                }

                else

                {

                    Ns100 %= 10000;


                    return new DateTimeHF(Now, (int)(Ns100 / 10), (int)(Ns100 % 10), Ticks);

                }

            }

        }


        private async Task DnsRequest(object Sender, IqEventArgs e)

        {

            try

            {

                byte[] ReqBin = System.Convert.FromBase64String(e.Query.InnerText);


                DnsMessage Msg = new DnsMessage(ReqBin);


                foreach (Question Question in Msg.Questions)

                {

                    DnsResponse DnsResponse = await DnsResolver.Query(Question.QNAME, Question.QTYPE, Question.QCLASS);

                    if (DnsResponse is null)

                        await e.IqErrorBadRequest(e.To, "Unable to resolve query.", "en");

                    else

                    {

                        byte[] RespBin = (byte[])DnsResponse.Raw.Clone();


                        RespBin[0] = ReqBin[0];     // Use same ID as in request.

                        RespBin[1] = ReqBin[1];


                        StringBuilder Xml = new StringBuilder();


                        Xml.Append("<dns xmlns='");

                        Xml.Append(NamespaceDnsOverXmpp);

                        Xml.Append("'>");

                        Xml.Append(System.Convert.ToBase64String(RespBin));

                        Xml.Append("</dns>");


                        await e.IqResult(Xml.ToString(), e.To);

                    }

                    return;

                }


                await e.IqErrorBadRequest(e.To, "No question in request.", "en");

            }

            catch (Exception ex)

            {

                await e.IqError(ex, e.To);

            }

        }


        public static PubSubNode GetPubSubNode(CaseInsensitiveString NodeName)

        {

            PubSubNode Result = GetPubSubNodeAsync(NodeName).Result

                ?? throw new NotFoundException();


            return Result;

        }


        public static Task<PubSubNode> GetPubSubNodeAsync(CaseInsensitiveString NodeName)

        {

            if (instance is null)

                return GetPubSubNodeAsyncNoInit(NodeName);

            else

                return instance.pubSubComponent.GetNodeAsync(CaseInsensitiveString.Empty, NodeName, null, XmppAddress.Empty, null);

        }


        private static async Task<PubSubNode> GetPubSubNodeAsyncNoInit(CaseInsensitiveString NodeName)

        {

            foreach (PubSubNode PubSubNode in await Database.Find<PubSubNode>(new FilterAnd(

                new FilterFieldEqualTo("Service", string.Empty), new FilterFieldEqualTo("Name", NodeName))))

            {

                return PubSubNode;

            }


            return null;

        }


        public static IClientConnection[] GetClientConnections()

        {

            return instance.xmppServer.GetClientConnections();

        }


        public static IClientConnection GetClientConnection(string FullJid)

        {

            if (instance.xmppServer.TryGetClientConnection(FullJid, out IClientConnection Result))

                return Result;

            else

                throw new NotFoundException("Client resource not connected: " + FullJid);

        }


        public static S2sEndpointStatistics[] GetServerConnectionStatistics()

        {

            return instance.xmppServer.GetServerConnectionStatistics();

        }


        public static IS2SEndpoint GetS2sConnection(string Domain)

        {

            if (instance.xmppServer.TryGetS2sEndpoint(Domain, out IS2SEndpoint Result))

                return Result;

            else

                throw new NotFoundException("Domain not connected: " + Domain);

        }


        public static Task<bool> IsAdmin(CaseInsensitiveString Jid)

        {

            return IsAdmin(Jid, null);

        }


        public static async Task<bool> IsAdmin(CaseInsensitiveString Jid, IUser User)

        {

            Jid = Networking.XMPP.XmppClient.GetBareJID(Jid);

            if (!(Gateway.XmppClient is null) && string.Compare(Gateway.XmppClient.BareJID, Jid, true) == 0)

                return true;


            CaseInsensitiveString[] Admins = Gateway.GetNotificationAddresses();


            foreach (CaseInsensitiveString s in Admins)

            {

                if (string.Compare(s, Jid, true) == 0)

                    return true;

            }


            if (User is null)

                User = await Users.GetUser(Jid, false);


            if (User is null)

                return false;


            return User.HasPrivilege("Admin");

        }


        public static string DateTimesToHTML(DateTime Created, DateTime Updated)

        {

            StringBuilder Result = new StringBuilder();


            Created = Created.ToLocalTime();


            if (Updated != DateTime.MinValue)

                Updated = Updated.ToLocalTime();


            Result.Append("<span class=\"ContentItemTimestamp\">");

            Result.Append(Created.ToShortDateString());

            Result.Append(", ");

            Result.Append(Created.ToLongTimeString());

            Result.Append("</span>");


            if (Updated != Created && Updated != DateTime.MinValue)

            {

                Result.Append("<span class=\"ContentItemUpdated\">");

                Result.Append(Updated.ToShortDateString());

                Result.Append(", ");

                Result.Append(Updated.ToLongTimeString());

                Result.Append("</span>");

            }


            return Result.ToString();

        }


        private async Task CheckRegistration()

        {

            try

            {

                if (!(Gateway.XmppClient is null) && Gateway.XmppClient.State == Networking.XMPP.XmppState.Connected)

                {

                    if (this.serviceRegistrationClient is null)

                        this.serviceRegistrationClient = new ServiceRegistrationClient(Gateway.XmppClient, "services.tagroot.io");


                    await this.serviceRegistrationClient.CheckRegistration();


                    if (!string.IsNullOrEmpty(Gateway.Domain))

                    {

                        string VCardDomain = await RuntimeSettings.GetAsync("VCard.Domain", string.Empty);

                        if (VCardDomain != Gateway.Domain)

                        {

                            // XEP-0054 - vcard-temp: http://xmpp.org/extensions/xep-0054.html

                            // XEP-0153 - vCard-Based Avatars: http://xmpp.org/extensions/xep-0153.html


                            StringBuilder Xml = new StringBuilder();

                            string BareJid = Gateway.XmppClient.BareJID;

                            byte[] Avatar = Resources.LoadResource(typeof(XmppServerModule).Namespace + ".Graphics.XMPP_logo.png");


                            Xml.Append("<vCard xmlns='vcard-temp'>");

                            Xml.Append("<FN>XMPP Broker on ");

                            Xml.Append(XML.Encode(Gateway.Domain));

                            Xml.Append("</FN>");

                            Xml.Append("<URL>");

                            Xml.Append(Gateway.GetUrl("/"));

                            Xml.Append("</URL>");

                            Xml.Append("<JABBERID>");

                            Xml.Append(XML.Encode(BareJid));

                            Xml.Append("</JABBERID>");

                            Xml.Append("<PHOTO><TYPE>image/png</TYPE><BINVAL>");

                            Xml.Append(System.Convert.ToBase64String(Avatar, Base64FormattingOptions.None));

                            Xml.Append("</BINVAL></PHOTO>");

                            Xml.Append("</vCard>");


                            await Gateway.AvatarClient.UpdateLocalAvatarAsync("image/png", Avatar, 96, 96, true);

                            await Gateway.XmppClient.IqSetAsync(BareJid, Xml.ToString());

                            await RuntimeSettings.SetAsync("VCard.Domain", Gateway.Domain);

                        }

                    }

                    return;

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }


            Gateway.ScheduleEvent((P) => Task.Run(() => this.CheckRegistration()), DateTime.Now.AddMinutes(15), null);

        }


        private Task XmppServer_ClientConnectionAdded(object Sender, Networking.XMPP.Server.ClientConnectionEventArgs e)

        {

            return this.connectionsSource?.ClientConnectionAdded(Sender, e) ?? Task.CompletedTask;

        }


        private Task XmppServer_ClientConnectionRemoved(object Sender, Networking.XMPP.Server.ClientConnectionEventArgs e)

        {

            return this.connectionsSource?.ClientConnectionRemoved(Sender, e) ?? Task.CompletedTask;

        }


        private Task XmppServer_ClientConnectionUpdated(object Sender, Networking.XMPP.Server.ClientConnectionEventArgs e)

        {

            return this.connectionsSource?.ClientConnectionUpdated(Sender, e) ?? Task.CompletedTask;

        }


        private Task XmppServer_ServerConnectionAdded(object Sender, Networking.XMPP.Server.ServerConnectionEventArgs e)

        {

            return this.connectionsSource?.ServerConnectionAdded(Sender, e) ?? Task.CompletedTask;

        }


        private Task XmppServer_ServerConnectionRemoved(object Sender, Networking.XMPP.Server.ServerConnectionEventArgs e)

        {

            return this.connectionsSource?.ServerConnectionRemoved(Sender, e) ?? Task.CompletedTask;

        }


        private Task XmppServer_ServerConnectionUpdated(object Sender, Networking.XMPP.Server.ServerConnectionEventArgs e)

        {

            return this.connectionsSource?.ServerConnectionUpdated(Sender, e) ?? Task.CompletedTask;

        }


        internal async Task<bool> CheckSoftwarePackage(Networking.XMPP.Software.Package RemotePackage, ResponseCallbackHandler ResponseCallback)

        {

            try

            {

                Package LocalPackage = await ProvisioningComponent.GetPackage(RemotePackage.FileName);


                if (LocalPackage is null || LocalPackage.Published < RemotePackage.Published)

                {

                    string MessageId = await ResponseCallback("Downloading `" + RemotePackage.FileName + "`", string.Empty);

                    string FileName = await Gateway.SoftwareUpdateClient.DownloadPackageAsync(RemotePackage);


                    await this.PackageDownloaded(RemotePackage, Gateway.SoftwareUpdateClient.ComponentAddress, MessageId, ResponseCallback);


                    return true;

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }


            return false;

        }


        private Task SoftwareUpdateClient_OnSoftwareUpdated(object Sender, Networking.XMPP.Software.PackageUpdatedEventArgs e)

        {

            Log.Informational("New software package available.", PackageTags(e.Package));

            e.Download = true;


            return Task.CompletedTask;

        }


        private static KeyValuePair<string, object>[] PackageTags(Networking.XMPP.Software.Package Package)

        {

            return new KeyValuePair<string, object>[]

            {

                new KeyValuePair<string, object>("FileName", Package.FileName),

                new KeyValuePair<string, object>("Bytes", Package.Bytes),

                new KeyValuePair<string, object>("Published", Package.Published),

                new KeyValuePair<string, object>("Supersedes", Package.Supersedes),

                new KeyValuePair<string, object>("Created", Package.Created),

                new KeyValuePair<string, object>("Signature", System.Convert.ToBase64String(Package.Signature ?? new byte[0])),

                new KeyValuePair<string, object>("URL", Package.Url)

            };

        }


        private async Task SoftwareUpdateClient_OnSoftwareValidation(object Sender, Networking.XMPP.Software.PackageFileEventArgs e)

        {

            string FileName = Path.GetFileName(e.LocalFileName);


            if (string.Compare(FileName, BrokerPackage.FileName, true) == 0)

            {

                if (!ValidateIoTBrokerPackage(e.LocalFileName, e.Package.Signature))

                    throw new Exception("Invalid signature.");

            }

            else

            {

                Package Package = await ProvisioningComponent.GetPackage(FileName);

                if (!(Package is null) && Package.Installed > DateTime.MinValue && !(Package.PublicKey is null))

                {

                    if (!ValidatePackage(e.LocalFileName, Package.PublicKey, e.Package.Signature))

                        throw new Exception("Invalid signature.");

                }

            }

        }


        internal static bool ValidateIoTBrokerPackage(string FileName, byte[] Signature)

        {

            Log.Notice("Validating package.", FileName);


            using (FileStream f = File.OpenRead(FileName))

            {

                bool Result = ValidateIoTBrokerPackage(f, Signature);


                if (Result)

                    Log.Informational("Package valid.", FileName);

                else

                    Log.Error("Package not valid.", FileName);


                return Result;

            }

        }


        internal static bool ValidatePackage(string FileName, byte[] PublicKey, byte[] Signature)

        {

            Log.Notice("Validating package.", FileName);


            using (FileStream f = File.OpenRead(FileName))

            {

                bool Result = ValidatePackage(f, PublicKey, Signature);


                if (Result)

                    Log.Informational("Package valid.", FileName);

                else

                    Log.Error("Package not valid.", FileName);


                return Result;

            }

        }


        internal static bool ValidateIoTBrokerPackage(Stream Data, byte[] Signature)

        {

            return ValidatePackage(Data, iotBrokerPackagePublicKey, Signature);

        }


        internal static bool ValidatePackage(Stream Data, byte[] PublicKey, byte[] Signature)

        {

            return ed448.Verify(Data, PublicKey, Signature);

        }


        private Task SoftwareUpdateClient_OnSoftwareDownloaded(object Sender, Networking.XMPP.Software.PackageFileEventArgs e)

        {

            return this.PackageDownloaded(e.Package, e.From, string.Empty, (Markdown, MessageId) => Task.FromResult(MessageId));

        }


        private async Task PackageDownloaded(Networking.XMPP.Software.Package DownloadedPackage, string RemoteEndpoint, string MessageId,

            ResponseCallbackHandler ResponseCallback)

        {

            Log.Notice("New software package downloaded.", PackageTags(DownloadedPackage));


            await ResponseCallback("Software package downloaded: `" + DownloadedPackage.FileName + "`", MessageId);


            DateTime Now = DateTime.UtcNow;

            Package Package = await ProvisioningComponent.GetPackage(DownloadedPackage.FileName);


            if (Package is null)

            {

                Package = new Package()

                {

                    FileName = DownloadedPackage.FileName,

                    Signature = DownloadedPackage.Signature,

                    RemoteEndpoint = RemoteEndpoint,

                    Published = Now,

                    Supersedes = DateTime.MinValue,

                    Created = Now,

                    Bytes = DownloadedPackage.Bytes,

                    AesKey = null,

                    Installed = DateTime.MinValue,

                    PublicKey = null,

                    Downloadable = false

                };


                await Database.Insert(Package);

            }

            else

            {

                Package.Signature = DownloadedPackage.Signature;

                Package.RemoteEndpoint = RemoteEndpoint;

                Package.Supersedes = Package.Published;

                Package.Published = Now;

                Package.Bytes = DownloadedPackage.Bytes;


                if (!(Package.AesKey is null))

                    Package.ContentOnly = IsContentPackage(Package);


                await Database.Update(Package);

            }


            if (!(this.provisioningComponent is null))

                await this.provisioningComponent.NewPackage(Package);


            if (string.Compare(DownloadedPackage.FileName, BrokerPackage.FileName, true) == 0 ||

                Package.Installed > DateTime.MinValue)

            {

                await this.NewSoftwareAvailable(Package, RemoteEndpoint);

            }

            else if (string.Compare(DownloadedPackage.FileName, Ip2LocalizationPackageName, true) == 0)

                Gateway.ScheduleEvent(this.ImportIpLocalizationDatabase, DateTime.Now.AddMinutes(5), null);


            // TODO: PlantUML package

            // TODO: GraphViz package

        }


        internal async Task NewSoftwareAvailable(Package DownloadedPackage, string RemoteEndpoint)

        {

            StringBuilder Markdown = new StringBuilder();

            DateTime Now = DateTime.Now;

            long DelayMinutes;


            if (DownloadedPackage.ContentOnly)

            {

                bool InstallPackage = await RuntimeSettings.GetAsync(AutoInstallContentOnlyParameterName, false);


                if (InstallPackage)

                    DelayMinutes = 1;

                else

                    DelayMinutes = await RuntimeSettings.GetAsync(AutoInstallDelayParameterName, 0);

            }

            else

                DelayMinutes = await RuntimeSettings.GetAsync(AutoInstallDelayParameterName, 0);


            Markdown.AppendLine("New version of installed software has been downloaded");

            Markdown.AppendLine("==========================================================");

            Markdown.AppendLine();

            Markdown.AppendLine("| Package ||");

            Markdown.AppendLine("|:------|:-------|");

            Markdown.AppendLine("| Filename: | `" + DownloadedPackage.FileName + "` |");

            Markdown.AppendLine("| Size: | " + Export.FormatBytes(DownloadedPackage.Bytes) + " |");

            Markdown.AppendLine("| From: | `" + RemoteEndpoint + "` |");

            Markdown.AppendLine("| Published: | " + MarkdownDocument.Encode(DownloadedPackage.Published.ToString()) + " |");


            if (DownloadedPackage.Supersedes != DateTime.MinValue)

                Markdown.AppendLine("| Supersedes: | " + MarkdownDocument.Encode(DownloadedPackage.Supersedes.ToString()) + " |");


            Markdown.AppendLine("| Signature: | " + System.Convert.ToBase64String(DownloadedPackage.Signature) + " |");

            Markdown.AppendLine("| Download: | [" + MarkdownDocument.Encode(DownloadedPackage.FileName) + "](" + DownloadedPackage.Url + ") |");

            Markdown.Append("| Date | ");

            Markdown.Append(MarkdownDocument.Encode(Now.ToShortDateString()));

            Markdown.AppendLine(" |");

            Markdown.Append("| Time | ");

            Markdown.Append(MarkdownDocument.Encode(Now.ToLongTimeString()));

            Markdown.AppendLine(" |");

            Markdown.AppendLine();


            if (string.Compare(DownloadedPackage.FileName, BrokerPackage.FileName, true) == 0)

            {

                Markdown.AppendLine("See [Release Notes](https://lab.tagroot.io/ReleaseNotes) for information about what is new.");

                Markdown.AppendLine();

            }


            if (DelayMinutes > 0)

            {

                if (DownloadedPackage.ContentOnly)

                {

                    try

                    {

                        Log.Notice("Updating software.", DownloadedPackage.FileName);


                        await this.UpdateSoftware(DownloadedPackage, false);


                        Log.Notice("Software successfully updated.", DownloadedPackage.FileName);


                        Markdown.AppendLine("The new software has been automatically installed.");

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex, DownloadedPackage.FileName);


                        Markdown.AppendLine("Unable to install the new software. The following error was reported: ");

                        Markdown.AppendLine();

                        Markdown.AppendLine("```");

                        Markdown.AppendLine(ex.Message.Trim());

                        Markdown.AppendLine("```");

                    }

                }

                else

                {

                    if (autoUpdateTP > DateTime.MinValue)

                    {

                        Gateway.CancelScheduledEvent(autoUpdateTP);

                        autoUpdateTP = DateTime.MinValue;

                    }


                    DateTime TP = Now.AddMinutes(DelayMinutes);

                    autoUpdateTP = Gateway.ScheduleEvent(this.UpdateSoftware, TP, null);


                    await RuntimeSettings.SetAsync(AutoInstallTimeParameterName, autoUpdateTP);


                    Markdown.Append("The new software will be automatically installed");


                    if (DelayMinutes == 1)

                        Markdown.Append(" in 1 minute");

                    else if (DelayMinutes <= 60)

                        Markdown.Append(" in " + DelayMinutes.ToString() + " minutes");

                    else

                    {

                        Markdown.Append(" at ");


                        if (TP.Date == Now.Date)

                            Markdown.Append(TP.ToShortTimeString());

                        else

                        {

                            Markdown.Append(TP.ToShortDateString());

                            Markdown.Append(", ");

                            Markdown.Append(TP.ToShortTimeString());

                        }

                    }


                    Markdown.AppendLine(", unless cancelled from the chat interface.");

                }

            }

            else

                Markdown.AppendLine("You can update the server with the new package from the chat interface.");


            await Gateway.SendNotification(Markdown.ToString());

        }


        internal static bool IsContentPackage(Package Package)

        {

            try

            {

                string FileName = Path.Combine(PackagesFolder, Package.FileName);

                if (!File.Exists(FileName))

                    return false;


                StringBuilder sb = new StringBuilder();


                sb.Append(Package.FileName);

                sb.Append(":");


                if (!(Package.AesKey is null))

                    sb.Append(Hashes.BinaryToString(Package.AesKey));


                sb.Append(":Waher.Utility.Install");


                SHAKE256 H = new SHAKE256(384);

                byte[] Digest = H.ComputeVariable(Encoding.UTF8.GetBytes(sb.ToString()));

                byte[] AesKey = new byte[32];

                byte[] IV = new byte[16];

                Aes Aes = null;

                FileStream fs = null;

                ICryptoTransform AesTransform = null;

                CryptoStream Decrypted = null;

                GZipStream Decompressed = null;


                Array.Copy(Digest, 0, AesKey, 0, 32);

                Array.Copy(Digest, 32, IV, 0, 16);


                try

                {

                    Aes = Aes.Create();

                    Aes.BlockSize = 128;

                    Aes.KeySize = 256;

                    Aes.Mode = CipherMode.CBC;

                    Aes.Padding = PaddingMode.Zeros;


                    fs = File.OpenRead(FileName);

                    AesTransform = Aes.CreateDecryptor(AesKey, IV);

                    Decrypted = new CryptoStream(fs, AesTransform, CryptoStreamMode.Read);

                    Decompressed = new GZipStream(Decrypted, CompressionMode.Decompress);


                    byte b = ReadByte(Decompressed);

                    byte[] Bin;


                    if (b > 0)

                    {

                        Bin = new byte[b];

                        Decompressed.ReadAll(Bin, 0, b);

                    }


                    Bin = ReadBin(Decompressed);

                    if (Encoding.ASCII.GetString(Bin) != "IoTGatewayPackage")

                        throw new Exception("Invalid package file.");


                    while ((b = ReadByte(Decompressed)) != 0)

                    {

                        string RelativeName = Encoding.UTF8.GetString(ReadBin(Decompressed));          // RelativeName

                        ReadVarLenUInt(Decompressed);   // FileAttributes

                        ReadVarLenUInt(Decompressed);   // CreationTimeUtc

                        ReadVarLenUInt(Decompressed);   // LastAccessTimeUtc

                        ReadVarLenUInt(Decompressed);   // LastWriteTimeUtc

                        ulong Bytes = ReadVarLenUInt(Decompressed);


                        switch (b)

                        {

                            case 1: // Program file in installation folder, not assembly file

                                SkipBytes(Decompressed, Bytes);

                                break;


                            case 2: // Assembly file

                            case 5: // External program file

                            case 6: // External program folder

                                return false;


                            case 3: // Content file (copy if newer)

                            case 4: // Content file (always copy)

                                SkipBytes(Decompressed, Bytes);

                                break;


                            default:

                                throw new Exception("Invalid package file.");

                        }

                    }

                }

                finally

                {

                    Decompressed?.Dispose();

                    Decrypted?.Dispose();

                    AesTransform?.Dispose();

                    Aes?.Dispose();

                    fs?.Dispose();

                }


                return true;

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

                return false;

            }

        }


        private static byte[] ReadBin(Stream Input)

        {

            ulong Len = ReadVarLenUInt(Input);

            if (Len > int.MaxValue)

                throw new Exception("Invalid package.");


            int c = (int)Len;

            byte[] Result = new byte[c];


            Input.ReadAll(Result, 0, c);


            return Result;

        }


        private static ulong ReadVarLenUInt(Stream Input)

        {

            ulong Len = 0;

            int Offset = 0;

            byte b;


            do

            {

                b = ReadByte(Input);


                Len |= ((ulong)(b & 127)) << Offset;

                Offset += 7;

            }

            while ((b & 0x80) != 0);


            return Len;

        }


        private static byte ReadByte(Stream Input)

        {

            int i = Input.ReadByte();

            if (i < 0)

                throw new EndOfStreamException("Reading past end-of-file.");


            return (byte)i;

        }


        private static void SkipBytes(Stream Input, ulong Bytes)

        {

            int c = 65536;

            if (Bytes < (ulong)c)

                c = (int)Bytes;


            byte[] Buffer = new byte[c];


            Input.ReadAll(Buffer, 0, c);

        }


        internal async void UpdateSoftware(object P)

        {

            try

            {

                Package Package = P as Package;

                await this.UpdateSoftware(Package, true);

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        internal Task UpdateSoftware(Package Package, bool Backup)

        {

            ChatState State = new ChatState(HttpServer.CreateVariables())

            {

                To = string.Empty,

                Folder = PackagesFolder

            };


            return this.UpdateSoftware(Package, State, Backup);

        }


        internal Task UpdateSoftware(Package Package, ChatState State, bool Backup)

        {

            return this.UpdateSoftware(Package, State, Backup, (Msg, MessageId) => Task.FromResult<string>(MessageId));

        }


        internal async Task UpdateSoftware(Package Package, ChatState State, bool Backup, ResponseCallbackHandler ResponseCallback)

        {

            string MessageId = string.Empty;


            if (Backup && (Package is null || !Package.ContentOnly))

            {

                MessageId = await ResponseCallback("Performing backup.", MessageId);

                await Gateway.DoBackup();

            }


            StringBuilder sb = new StringBuilder();

            Package[] Packages = await ProvisioningComponent.GetPackages();

            bool RestartRequired;

            string ServerFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, AppDomain.CurrentDomain.FriendlyName + FileSystem.ExecutableExtension);

            if (!File.Exists(ServerFileName))

                ServerFileName = Path.ChangeExtension(ServerFileName, "dll");


            sb.Append("Install -d \"");

            sb.Append(Gateway.AppDataFolder.Substring(0, Gateway.AppDataFolder.Length - 1));

            sb.Append("\" -s \"");

            sb.Append(ServerFileName);

            sb.Append('"');


            string BrokerPackageFileName = Path.Combine(PackagesFolder, BrokerPackage.FileName);

            bool UpdateBroker = false;


            if (Package is null || !Package.ContentOnly)

            {

                autoUpdateTP = DateTime.MinValue;

                await RuntimeSettings.SetAsync(AutoInstallTimeParameterName, DateTime.MinValue);


                if (!File.Exists(BrokerPackageFileName))

                {

                    await ResponseCallback("`" + BrokerPackage.FileName + "` not found.", string.Empty);

                    return;

                }


                UpdateBroker = true;


                List<Package> ToInstall = new List<Package>();


                foreach (Package Package2 in Packages)

                {

                    if (Package2.Installed == DateTime.MinValue)

                        continue;


                    if (Package2.FileName == BrokerPackage.FileName)

                        continue;


                    if (Package2.ContentOnly)

                        continue;


                    if (Package2.Published > Package2.Installed)

                    {

                        ToInstall.Add(Package2);


                        Package2.Installed = Package2.Published;

                        await Database.Update(Package2);

                    }

                    else if (Package2 == Package)

                        ToInstall.Add(Package2);

                }


                Packages = ToInstall.ToArray();

                RestartRequired = true;

            }

            else

            {

                if (!File.Exists(Path.Combine(PackagesFolder, Package.FileName)))

                {

                    await ResponseCallback("`" + Package.FileName + "` not found.", string.Empty);

                    return;

                }


                if (Package.Published > Package.Installed)

                {

                    Package.Installed = Package.Published;

                    await Database.Update(Package);

                }


                Packages = new Package[] { Package };

                RestartRequired = false;


                sb.Append(" -co");

            }


            foreach (Package Package2 in Packages)

            {

                string PackageFileName = Path.Combine(PackagesFolder, Package2.FileName);


                if (File.Exists(PackageFileName))

                {

                    sb.Append(" -p \"");

                    sb.Append(PackageFileName.Replace("\"", "\\\""));


                    if (!(Package2.AesKey is null))

                    {

                        sb.Append("\" -k \"");

                        sb.Append(Hashes.BinaryToString(Package2.AesKey));

                    }


                    sb.Append('"');

                }

            }


            if (UpdateBroker)

            {

                sb.Append(" -p \"");

                sb.Append(BrokerPackageFileName);

                sb.Append("\" -k \"");

                sb.Append(BrokerPackage.Key);

                sb.Append('"');

            }


            sb.Append(" -n \"");

            sb.Append(Gateway.InstanceName);

            sb.Append("\" -w 120000 -v -i > install.log");


            MessageId = await ResponseCallback("Starting update process...", MessageId);


            if (await this.ExecuteCommand(State.To, sb.ToString(), State, true, ResponseCallback))

            {

                if (RestartRequired)

                {

                    await ResponseCallback("Stopping service... Update procedure will continue when service has been stopped. Service will then restart using the updated version.", MessageId);


                    Gateway.ScheduleEvent((P) => Gateway.Terminate(), DateTime.Now.AddSeconds(1), null);

                }

                else

                {

                    await ResponseCallback("Package installed. No restart required.", MessageId);

                    await Gateway.ProcessNewServiceConfigurations();

                }

            }

        }


        internal async Task UninstallSoftware(string PackageFileName, byte[] AesKey)

        {

            string s = Path.Combine(PackagesFolder, PackageFileName);

            if (!File.Exists(s))

                return;


            string s2 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, AppDomain.CurrentDomain.FriendlyName + FileSystem.ExecutableExtension);

            if (!File.Exists(s2))

                s2 = s2.Substring(0, s2.Length - 3) + "dll";


            StringBuilder sb = new StringBuilder();


            sb.Append("Install -p \"");

            sb.Append(s);

            sb.Append("\" -d \"");

            sb.Append(Gateway.AppDataFolder.Substring(0, Gateway.AppDataFolder.Length - 1));

            sb.Append("\" -s \"");

            sb.Append(s2);


            if (!(AesKey is null))

            {

                sb.Append("\" -k \"");

                sb.Append(Hashes.BinaryToString(AesKey));

            }


            sb.Append('"');


            Package Package = await ProvisioningComponent.GetPackage(PackageFileName);

            bool RestartRequired = Package is null || !Package.ContentOnly;


            if (!RestartRequired)

                sb.Append(" -co");


            sb.Append(" -n \"");

            sb.Append(Gateway.InstanceName);

            sb.Append("\" -w 120000 -v -u > install.log");


            ChatState State = new ChatState(HttpServer.CreateVariables())

            {

                To = string.Empty,

                Folder = PackagesFolder

            };


            await Gateway.DoBackup();


            if (await this.ExecuteCommand(string.Empty, sb.ToString(), State, true,

                (Msg, MessageId) => Task.FromResult<string>(MessageId)) && RestartRequired)

            {

                Gateway.ScheduleEvent((P) => Gateway.Terminate(), DateTime.Now.AddSeconds(1), null);

            }

        }


        private Task SoftwareUpdateClient_OnSoftwareDeleted(object Sender, Networking.XMPP.Software.PackageDeletedEventArgs e)

        {

            Log.Informational("Software package deleted on server.", PackageTags(e.Package));

            e.Delete = true;


            return Task.CompletedTask;

        }


        private async Task SoftwareUpdateClient_OnDownloadedSoftwareDeleted(object Sender, Networking.XMPP.Software.PackageFileEventArgs e)

        {

            Log.Notice("Local copy of software package deleted.", PackageTags(e.Package));


            Package OldPackage = await ProvisioningComponent.GetPackage(e.Package.FileName);


            if (!(OldPackage is null))

            {

                await Database.Delete(OldPackage);


                if (!(this.provisioningComponent is null))

                    await this.provisioningComponent.PackageDeleted(OldPackage);

            }

        }


        private async Task<(string, string, bool)> GetPlainText(Networking.XMPP.Events.MessageEventArgs e, DateTime OfflineThreshold)

        {

            string s = e.Body?.Trim();


            string ReplaceObjectId = string.Empty;

            bool IsMarkdown = false;


            foreach (XmlNode N in e.Message.ChildNodes)

            {

                if (N is XmlElement E)

                {

                    switch (E.LocalName)

                    {

                        case "content":

                            if (E.NamespaceURI == "urn:xmpp:content" &&

                                string.Compare(XML.Attribute(E, "type"), MarkdownCodec.ContentType, true) == 0)

                            {

                                if (string.IsNullOrEmpty(s))

                                {

                                    MarkdownDocument Doc = await MarkdownDocument.CreateAsync(E.InnerText.Trim());

                                    s = await Doc.GeneratePlainText();

                                }


                                IsMarkdown = true;

                            }

                            break;


                        case "delay":

                            if (E.NamespaceURI == XmppServer.DelayedDeliveryNamespace &&

                                E.HasAttribute("stamp") &&

                                XML.TryParse(E.GetAttribute("stamp"), out DateTime Timestamp) &&

                                Timestamp.ToUniversalTime() < OfflineThreshold.ToUniversalTime())

                            {

                                return (string.Empty, string.Empty, false);

                            }

                            break;


                        case "replace":

                            if (E.NamespaceURI == "urn:xmpp:message-correct:0")

                                ReplaceObjectId = XML.Attribute(E, "id");

                            break;

                    }

                }

            }


            return (s, ReplaceObjectId, IsMarkdown);


        }


        private string GetMarkdown(Networking.XMPP.Events.MessageEventArgs e, DateTime OfflineThreshold, bool EncodeIfText, out string ReplaceObjectId, out bool IsMarkdown)

        {

            string s = e.Body?.Trim();


            ReplaceObjectId = string.Empty;

            IsMarkdown = false;


            foreach (XmlNode N in e.Message.ChildNodes)

            {

                if (N is XmlElement E)

                {

                    switch (E.LocalName)

                    {

                        case "content":

                            if (E.NamespaceURI == "urn:xmpp:content" &&

                                string.Compare(XML.Attribute(E, "type"), MarkdownCodec.ContentType, true) == 0)

                            {

                                s = E.InnerText.Trim();

                                IsMarkdown = true;

                            }

                            break;


                        case "delay":

                            if (E.NamespaceURI == XmppServer.DelayedDeliveryNamespace &&

                                E.HasAttribute("stamp") &&

                                XML.TryParse(E.GetAttribute("stamp"), out DateTime Timestamp) &&

                                Timestamp.ToUniversalTime() < OfflineThreshold.ToUniversalTime())

                            {

                                return string.Empty;

                            }

                            break;


                        case "replace":

                            if (E.NamespaceURI == "urn:xmpp:message-correct:0")

                                ReplaceObjectId = XML.Attribute(E, "id");

                            break;

                    }

                }

            }


            return EncodeIfText ? MarkdownDocument.Encode(s) : s;

        }


        private async Task XmppClient_OnChatMessage(object Sender, Networking.XMPP.Events.MessageEventArgs e)

        {

            (string Message, string _, bool IsMarkdown) = await this.GetPlainText(e, DateTime.UtcNow.AddMinutes(-1));


            Task _ = Task.Run(async () => await this.ProcessChatMessage(Message, e.From, e.ThreadID, async (Response, MessageId) =>

                {

                    KeyValuePair<string, string> P = await this.PrepareAdminResponse(Response, MessageId, IsMarkdown);

                    string Xml = P.Key;

                    MessageId = P.Value;


                    if (Xml is null)

                        Xml = "<muteDiff xmlns='http://waher.se/Schema/Editing.xsd'/>";

                    else

                        Xml += "<muteDiff xmlns='http://waher.se/Schema/Editing.xsd'/>";


                    await Gateway.XmppClient.SendMessage(Networking.XMPP.QoSLevel.Unacknowledged, Networking.XMPP.MessageType.Chat,

                        MessageId, e.From, Xml, string.Empty, string.Empty, string.Empty, e.ThreadID, string.Empty, null, null);


                    return MessageId;

                }, Gateway.XmppClient));

        }


        private Task XmppClient_OnValidateSender(object Sender, Networking.XMPP.Events.ValidateSenderEventArgs e)

        {

            if (e.MessageStanza is null || !e.Rejected)

                return Task.CompletedTask;


            switch (e.MessageStanza.Type)

            {

                case Networking.XMPP.MessageType.GroupChat:

                    bool InRoom;


                    lock (this.mucRooms)

                    {

                        InRoom = this.mucRooms.ContainsKey(e.FromBareJID);

                    }


                    if (InRoom)

                        e.Accept();

                    else

                        e.Reject();


                    break;


                case Networking.XMPP.MessageType.Normal:

                case Networking.XMPP.MessageType.Chat:

                    foreach (XmlNode N in e.MessageStanza.Message.ChildNodes)

                    {

                        if (!(N is XmlElement E))

                            continue;


                        switch (E.NamespaceURI)

                        {

                            case Networking.XMPP.MUC.MultiUserChatClient.NamespaceMuc:

                            case Networking.XMPP.MUC.MultiUserChatClient.NamespaceMucAdmin:

                            case Networking.XMPP.MUC.MultiUserChatClient.NamespaceMucOwner:

                            case Networking.XMPP.MUC.MultiUserChatClient.NamespaceMucUser:

                                lock (this.mucRooms)

                                {

                                    InRoom = this.mucRooms.ContainsKey(e.FromBareJID);

                                }


                                if (InRoom)

                                    e.Accept();

                                else

                                    e.Reject();

                                return Task.CompletedTask;

                        }

                    }

                    break;

            }


            return Task.CompletedTask;

        }


        private async Task MucClient_DirectInvitationReceived(object Sender, Networking.XMPP.MUC.DirectInvitationMessageEventArgs e)

        {

            if (await IsAdmin(e.From))

            {

                StringBuilder sb = new StringBuilder();

                string NickName = Gateway.Domain;


                if (string.IsNullOrEmpty(NickName))

                    NickName = XmppConfiguration.Instance.Account;


                sb.Append("Accepting an invitation from `");

                sb.Append(e.FromBareJID);

                sb.Append("` to join the room `");

                sb.Append(e.RoomId);

                sb.Append('@');

                sb.Append(e.Domain);

                sb.Append("` using nick-name `");

                sb.Append(NickName);

                sb.Append("`.");


                if (!string.IsNullOrEmpty(e.Reason))

                {

                    sb.AppendLine();

                    sb.Append(e.Reason);

                }


                await Gateway.SendNotification(sb.ToString());


                await Enter.Execute(e.RoomId, e.Domain, NickName, e.Password, true, true, (Markdown, MessageId) =>

                {

                    if (string.IsNullOrEmpty(MessageId))

                        MessageId = Guid.NewGuid().ToString();


                    Gateway.SendNotification(Markdown, MessageId);

                    return Task.FromResult<string>(MessageId);

                });

            }

        }


        private Task MucClient_RoomInvitationReceived(object Sender, Networking.XMPP.MUC.RoomInvitationMessageEventArgs e)

        {

            e.Decline("Only accepting direct invitations.", "en");

            return Task.CompletedTask;

        }


        internal async Task EnterRoom(string RoomId, string Domain, string NickName, string Password, bool Permanent)

        {

            RoomInfo Info = new RoomInfo(RoomId, Domain, NickName, Password, Permanent);

            string Jid = RoomId + "@" + Domain;

            bool Changed;


            lock (this.mucRooms)

            {

                Changed = (!this.mucRooms.TryGetValue(Jid, out RoomInfo PrevInfo)) || (PrevInfo.Permanent ^ Permanent);

                this.mucRooms[Jid] = Info;

            }


            if (Changed)

                await this.UpdatePermamentRooms();

        }


        internal bool TryGetNickName(string RoomId, string Domain, out string NickName)

        {

            string Jid = RoomId + "@" + Domain;


            lock (this.mucRooms)

            {

                if (this.mucRooms.TryGetValue(Jid, out RoomInfo RoomInfo))

                {

                    NickName = RoomInfo.NickName;

                    return true;

                }

                else

                {

                    NickName = string.Empty;

                    return false;

                }

            }

        }


        internal bool TryGetDomainAndNickName(string RoomId, out string Domain, out string NickName)

        {

            RoomInfo Result = null;


            lock (this.mucRooms)

            {

                foreach (RoomInfo RoomInfo in this.mucRooms.Values)

                {

                    if (string.Compare(RoomInfo.RoomId, RoomId, true) == 0)

                    {

                        if (Result is null)

                            Result = RoomInfo;

                        else

                        {

                            Domain = NickName = null;

                            return false;

                        }

                    }

                }

            }


            Domain = Result?.Domain;

            NickName = Result?.NickName;


            return !(Result is null);

        }


        internal async Task LeaveRoom(string RoomId, string Domain)

        {

            string Jid = RoomId + "@" + Domain;

            bool Changed;


            lock (this.mucRooms)

            {

                Changed = this.mucRooms.TryGetValue(Jid, out RoomInfo Info) && Info.Permanent;

                this.mucRooms.Remove(Jid);

            }


            if (Changed)

                await this.UpdatePermamentRooms();

        }


        private async Task UpdatePermamentRooms()

        {

            StringBuilder sb = new StringBuilder();


            lock (this.mucRooms)

            {

                foreach (RoomInfo Rec in this.mucRooms.Values)

                {

                    if (Rec.Permanent)

                    {

                        sb.Append(Rec.RoomId);

                        sb.Append(" | ");

                        sb.Append(Rec.Domain);

                        sb.Append(" | ");

                        sb.Append(Rec.NickName);


                        if (!string.IsNullOrEmpty(Rec.Password))

                        {

                            sb.Append(" | ");

                            sb.Append(Rec.Password);

                        }


                        sb.AppendLine();

                    }

                }

            }


            await RuntimeSettings.SetAsync("MUC.Rooms", sb.ToString().Trim());

        }


        private async Task LoadPermanentRooms()

        {

            string s = await RuntimeSettings.GetAsync("MUC.Rooms", string.Empty);

            string[] Rows = s.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);


            lock (this.adminCommands)

            {

                foreach (string Row in Rows)

                {

                    string[] Parts = Row.Split(new string[] { " | " }, StringSplitOptions.None);


                    switch (Parts.Length)

                    {

                        case 3:

                            this.mucRooms[Parts[0] + "@" + Parts[1]] = new RoomInfo(Parts[0], Parts[1], Parts[2], true);

                            break;


                        case 4:

                            this.mucRooms[Parts[0] + "@" + Parts[1]] = new RoomInfo(Parts[0], Parts[1], Parts[2], Parts[3], true);

                            break;

                    }

                }

            }


            if (Gateway.XmppClient.State == Networking.XMPP.XmppState.Connected)

                await this.RejoinRooms();


            Gateway.ScheduleEvent((P) => this.CheckRoomsAlive(), DateTime.Now.AddMinutes(1), null);

        }


        internal RoomInfo[] GetRooms()

        {

            RoomInfo[] Infos;


            lock (this.mucRooms)

            {

                Infos = new RoomInfo[this.mucRooms.Count];

                this.mucRooms.Values.CopyTo(Infos, 0);

            }


            return Infos;

        }


        private async Task RejoinRooms()

        {

            foreach (RoomInfo Info in this.GetRooms())

                await this.RejoinRoom(Info);

        }


        private Task RejoinRoom(RoomInfo Info)

        {

            return Gateway.MucClient?.EnterRoom(Info.RoomId, Info.Domain, Info.NickName, Info.Password, (Sender, e) =>

            {

                if (e.Ok)

                    Gateway.MucClient.SetPresence(Info.RoomId, Info.Domain, Info.NickName, Networking.XMPP.Availability.Chat, null, null);

                else

                    Gateway.ScheduleEvent((P) => this.RejoinRoom(Info), DateTime.Now.AddMinutes(1), null);


                return Task.CompletedTask;


            }, null) ?? Task.CompletedTask;

        }


        internal void CheckRoomsAlive()

        {

            try

            {

                if (Gateway.XmppClient.State == Networking.XMPP.XmppState.Connected)

                {

                    RoomInfo[] Infos = this.GetRooms();


                    foreach (RoomInfo Info in Infos)

                    {

                        Gateway.MucClient.SelfPing(Info.RoomId, Info.Domain, Info.NickName, (Sender, e) =>

                        {

                            if (!e.Ok)

                            {

                                if (e.StanzaError is Networking.XMPP.StanzaErrors.NotAcceptableException)   // Need to reconnect with room.

                                {

                                    RoomInfo Info2 = (RoomInfo)e.State;

                                    Gateway.MucClient.EnterRoom(Info2.RoomId, Info2.Domain, Info2.NickName, Info2.Password, async (sender2, e2) =>

                                    {

                                        if (e2.Ok)

                                            await Gateway.MucClient.SetPresence(Info2.RoomId, Info2.Domain, Info2.NickName, Networking.XMPP.Availability.Chat, null, null);

                                        else

                                        {

                                            RoomInfo Info3 = (RoomInfo)e2.State;


                                            if (e2.StanzaError is Networking.XMPP.StanzaErrors.ForbiddenException)   // Blocked

                                            {

                                                await this.LeaveRoom(Info3.RoomId, Info3.Domain);

                                                await Gateway.SendNotification("Left room `" + Info3.RoomId + "@" + Info3.Domain + "`; forbidden entry (blocked?).");

                                            }

                                            else if (e2.StanzaError is Networking.XMPP.StanzaErrors.NotAuthorizedException)  // Password changed, too many failed attempts

                                            {

                                                await this.LeaveRoom(Info3.RoomId, Info3.Domain);

                                                await Gateway.SendNotification("Left room `" + Info3.RoomId + "@" + Info3.Domain + "`; password changed.");

                                            }

                                            else if (e2.StanzaError is Networking.XMPP.StanzaErrors.RegistrationRequiredException)  // Not registered in room

                                            {

                                                await this.LeaveRoom(Info3.RoomId, Info3.Domain);

                                                await Gateway.SendNotification("Left room `" + Info3.RoomId + "@" + Info3.Domain + "`; no longer registered in room.");

                                            }

                                            else if (e2.StanzaError is Networking.XMPP.StanzaErrors.ItemNotFoundException)  // Room not found/locked

                                            {

                                                await this.LeaveRoom(Info3.RoomId, Info3.Domain);

                                                await Gateway.SendNotification("Left room `" + Info3.RoomId + "@" + Info3.Domain + "`; room not found, or is locked for other purposes.");

                                            }

                                            else if (e2.StanzaError is Networking.XMPP.StanzaErrors.ServiceUnavailableException)  // Room full

                                            {

                                                await this.LeaveRoom(Info3.RoomId, Info3.Domain);

                                                await Gateway.SendNotification("Left room `" + Info3.RoomId + "@" + Info3.Domain + "`; room is full.");

                                            }

                                            else if (e2.StanzaError is Networking.XMPP.StanzaErrors.ConflictException)  // Nick-name conflict

                                            {

                                                await this.LeaveRoom(Info3.RoomId, Info3.Domain);

                                                await Gateway.SendNotification("Left room `" + Info3.RoomId + "@" + Info3.Domain + "`; nick-name conflict.");

                                            }

                                        }

                                    }, Info2);

                                }

                            }


                            return Task.CompletedTask;

                        }, Info);

                    }

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

            finally

            {

                Gateway.ScheduleEvent((P) => this.CheckRoomsAlive(), DateTime.Now.AddMinutes(1), null);

            }

        }


        private async Task LeaveAllRooms()

        {

            RoomInfo[] Rooms = this.GetRooms();

            int i, c = Rooms.Length;

            TaskCompletionSource<bool>[] TaskCompletionSources = new TaskCompletionSource<bool>[c];

            Task[] Tasks = new Task[c];


            for (i = 0; i < c; i++)

            {

                RoomInfo Info = Rooms[i];

                TaskCompletionSources[i] = new TaskCompletionSource<bool>();

                Tasks[i] = TaskCompletionSources[i].Task;


                await Gateway.MucClient.SetPresence(Info.RoomId, Info.Domain, Info.NickName, Networking.XMPP.Availability.Offline,

                    (_, e) =>

                    {

                        ((TaskCompletionSource<bool>)e.State).TrySetResult(true);

                        return Task.CompletedTask;

                    }, TaskCompletionSources[i]);

            }


            _ = Task.Delay(5000).ContinueWith((_) =>

            {

                foreach (TaskCompletionSource<bool> T in TaskCompletionSources)

                    T.TrySetResult(false);

                return Task.CompletedTask;

            });


            await Task.WhenAll(Tasks);

        }


        private async Task XmppClient_OnGroupChatMessage(object Sender, Networking.XMPP.Events.MessageEventArgs e)

        {

            XmppAddress Addr = new XmppAddress(e.From);

            string RoomId = Addr.Account;

            string Domain = Addr.Domain;

            string NickName = Addr.Resource;

            (string Message, string _, bool IsMarkdown) = await this.GetPlainText(e, DateTime.UtcNow.AddMinutes(-1));


            Task _ = Task.Run(async () => await this.ProcessChatMessage(Message, this.GetOccupantRealJid(e), e.ThreadID, async (Response, MessageId) =>

            {

                KeyValuePair<string, string> P = await this.PrepareAdminResponse(Response, MessageId, IsMarkdown);

                string Xml = P.Key;

                MessageId = P.Value;


                if (Xml is null)

                    Xml = "<muteDiff xmlns='http://waher.se/Schema/Editing.xsd'/>";

                else

                    Xml += "<muteDiff xmlns='http://waher.se/Schema/Editing.xsd'/>";


                await Gateway.MucClient.SendCustomPrivateMessage(MessageId, RoomId, Domain, NickName, Xml, string.Empty, e.ThreadID, string.Empty);


                return MessageId;

            }, Gateway.XmppClient));

        }


        internal void RegisterConsolidator(string ThreadId, IConsolidator Consolidator)

        {

            if (this.consolidators is null)

            {

                this.consolidators = new Cache<string, IConsolidator>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromSeconds(30));

                this.consolidators.Removed += this.Consolidators_Removed;

            }


            this.consolidators[ThreadId] = Consolidator;

        }


        private Task Consolidators_Removed(object Sender, CacheItemEventArgs<string, IConsolidator> e)

        {

            e.Value.Dispose();

            return Task.CompletedTask;

        }


        private async Task MucClient_PrivateMessageReceived(object Sender, Networking.XMPP.MUC.RoomOccupantMessageEventArgs e)

        {

            if (!string.IsNullOrEmpty(e.ThreadID) &&

                !(this.consolidators is null) &&

                this.consolidators.TryGetValue(e.ThreadID, out IConsolidator Consolidator))

            {

                string Response = this.GetMarkdown(e, DateTime.UtcNow.AddMinutes(-1), false, out string ReplaceObjectId, out bool IsMarkdown);

                MarkdownDocument Doc = null;


                if (Consolidator is ScriptConsolidator)

                {

                    if (!string.IsNullOrEmpty(e.Body))

                        Response = e.Body;

                    else

                        Doc = await MarkdownDocument.CreateAsync(Response);

                }


                if (Doc is null)

                {

                    if (!string.IsNullOrEmpty(ReplaceObjectId))

                        await Consolidator.Update(e.NickName, Response, ReplaceObjectId);

                    else

                        await Consolidator.Add(e.NickName, Response, e.Id);

                }

                else

                {

                    if (!string.IsNullOrEmpty(ReplaceObjectId))

                        await Consolidator.Update(e.NickName, Doc, ReplaceObjectId);

                    else

                        await Consolidator.Add(e.NickName, Doc, e.Id);

                }

            }

            else

            {

                (string Message, string _, bool IsMarkdown) = await this.GetPlainText(e, DateTime.UtcNow.AddMinutes(-1));


                Task _ = Task.Run(async () => await this.ProcessChatMessage(Message, this.GetOccupantRealJid(e), e.ThreadID, async (Response, MessageId) =>

                {

                    KeyValuePair<string, string> P = await this.PrepareAdminResponse(Response, MessageId, IsMarkdown);

                    string Xml = P.Key;

                    MessageId = P.Value;


                    if (Xml is null)

                        Xml = "<muteDiff xmlns='http://waher.se/Schema/Editing.xsd'/>";

                    else

                        Xml += "<muteDiff xmlns='http://waher.se/Schema/Editing.xsd'/>";


                    await Gateway.MucClient.SendCustomPrivateMessage(MessageId, e.RoomId, e.Domain, e.NickName, Xml, string.Empty, e.ThreadID, string.Empty);


                    return MessageId;

                }, Gateway.XmppClient));

            }

        }


        private async Task<KeyValuePair<string, string>> PrepareAdminResponse(string Response, string MessageId, bool IncomingWasMarkdown)

        {

            string Xml;


            if (IncomingWasMarkdown)

                Xml = await Gateway.GetMultiFormatChatMessageXml(Response, false, false);

            else

                Xml = await Gateway.GetMultiFormatChatMessageXml(Response, true, true);


            if (string.IsNullOrEmpty(MessageId))

                MessageId = Guid.NewGuid().ToString();

            else

                Xml += "<replace id='" + MessageId + "' xmlns='urn:xmpp:message-correct:0'/>";


            return new KeyValuePair<string, string>(Xml, MessageId);

        }


        private Task MucClient_RoomDestroyed(object Sender, Networking.XMPP.MUC.UserPresenceEventArgs e)

        {

            lock (this.presenceByNickAndRoom)

            {

                this.presenceByNickAndRoom.Remove(e.RoomJid);

            }


            return Task.CompletedTask;

        }


        private Task MucClient_OccupantPresence(object Sender, Networking.XMPP.MUC.UserPresenceEventArgs e)

        {

            lock (this.presenceByNickAndRoom)

            {

                if (!this.presenceByNickAndRoom.TryGetValue(e.RoomJid, out SortedDictionary<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs> ByNick))

                {

                    if (e.Availability == Networking.XMPP.Availability.Offline)

                        ByNick = null;

                    else

                    {

                        ByNick = new SortedDictionary<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs>();

                        this.presenceByNickAndRoom[e.RoomJid] = ByNick;

                    }

                }


                if (!(ByNick is null))

                {

                    if (e.Availability == Networking.XMPP.Availability.Offline)

                    {

                        if (ByNick.Remove(e.NickName) && ByNick.Count == 0)

                            this.presenceByNickAndRoom.Remove(e.RoomId);

                    }

                    else

                        ByNick[e.NickName] = e;

                }

            }


            return Task.CompletedTask;

        }


        internal int GetNrOccupants(string RoomJid, string RoomId, string Domain, bool ExcludeSelf, bool ExcludeOffline)

        {

            string OwnNick;


            if (ExcludeSelf)

            {

                if (!this.TryGetNickName(RoomId, Domain, out OwnNick))

                    OwnNick = null;

            }

            else

                OwnNick = null;


            lock (this.presenceByNickAndRoom)

            {

                if (this.presenceByNickAndRoom.TryGetValue(RoomJid, out SortedDictionary<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs> ByNick))

                {

                    if (!ExcludeSelf && !ExcludeOffline)

                        return ByNick.Count;


                    int c = 0;


                    foreach (Networking.XMPP.MUC.UserPresenceEventArgs e in ByNick.Values)

                    {

                        if (ExcludeOffline && !e.IsOnline)

                            continue;


                        if (ExcludeSelf && !(OwnNick is null) && Networking.XMPP.XmppClient.GetResource(e.From) == OwnNick)

                            continue;


                        c++;

                    }


                    return c;

                }

                else

                    return 0;

            }

        }


        internal KeyValuePair<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs>[] GetOccupants(string RoomJid)

        {

            lock (this.presenceByNickAndRoom)

            {

                if (!this.presenceByNickAndRoom.TryGetValue(RoomJid, out SortedDictionary<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs> ByNick))

                    return null;


                KeyValuePair<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs>[] Result =

                    new KeyValuePair<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs>[ByNick.Count];


                ByNick.CopyTo(Result, 0);


                return Result;

            }

        }


        private string GetOccupantRealJid(Networking.XMPP.Events.MessageEventArgs e)

        {

            foreach (XmlNode N in e.Message.ChildNodes)

            {

                if (N is XmlElement E && E.LocalName == "addresses" && E.NamespaceURI == XmppServer.ExtendedAddressingNamespace)

                {

                    foreach (XmlNode N2 in E.ChildNodes)

                    {

                        if (N2 is XmlElement E2 &&

                            E2.LocalName == "address" &&

                            E2.NamespaceURI == E.NamespaceURI &&

                            E2.HasAttribute("type") &&

                            E2.GetAttribute("type") == "ofrom")

                        {

                            return XML.Attribute(E2, "jid");

                        }

                    }

                }

            }


            string OccupantJid = e.From;

            XmppAddress Addr = new XmppAddress(OccupantJid);

            CaseInsensitiveString RoomJid = Addr.BareJid;

            CaseInsensitiveString NickName = Addr.Resource;


            lock (this.presenceByNickAndRoom)

            {

                if (this.presenceByNickAndRoom.TryGetValue(RoomJid, out SortedDictionary<CaseInsensitiveString, Networking.XMPP.MUC.UserPresenceEventArgs> ByNick) &&

                    ByNick.TryGetValue(NickName, out Networking.XMPP.MUC.UserPresenceEventArgs e2))

                {

                    return string.IsNullOrEmpty(e2.FullJid) ? OccupantJid : e2.FullJid;

                }

            }


            return OccupantJid;

        }


        internal Task ProcessChatMessage(string s, string From, string ThreadId, ResponseCallbackHandler ResponseCallback, ICommunicationLayer Channel)

        {

            return this.ProcessChatMessage(s, From, null, ThreadId, ResponseCallback, Channel);

        }


        internal async Task ProcessChatMessage(string s, string From, IUser User, string ThreadId, ResponseCallbackHandler ResponseCallback, ICommunicationLayer Channel)

        {

            StringBuilder Markdown;


            try

            {

                if (string.IsNullOrEmpty(s))

                {

                    if (!(Channel is null))

                        await Channel.Information("(Ignored, since empty)");


                    return;

                }


                if (From == Gateway.XmppClient.FullJID)

                {

                    if (string.IsNullOrEmpty(ThreadId) ||

                        this.consolidators is null ||

                        !this.consolidators.ContainsKey(ThreadId))

                    {

                        string Msg = "Supressing query from self. No outstanding consolidation query registered: " + s;


                        if (!(Channel is null))

                            await Channel.Warning(Msg);


                        Log.Warning(Msg, Gateway.Domain, From);

                        return;

                    }

                }

                else if (!await IsAdmin(From, User))

                {

                    string Msg = "Ignoring incoming chat message (sender is not an administrator): " + s;


                    if (!(Channel is null))

                        await Channel.Warning(Msg);


                    Log.Warning(Msg, Gateway.Domain, From);

                    return;

                }


                if (!(Channel is null))

                    await Channel.Information("Chat command string accepted.");


                if (this.chatSessions is null)

                {

                    this.chatSessions = new Cache<string, Variables>(1000, TimeSpan.MaxValue, TimeSpan.FromMinutes(15), true);

                    this.chatSessions.Removed += this.ChatSessions_Removed;

                }


                if (!this.chatSessions.TryGetValue(From, out Variables Session))

                {

                    Session = HttpServer.CreateVariables();

                    this.chatSessions[From] = Session;

                }


                if (!Session.TryGetVariable(" State ", out Variable v) || !(v.ValueObject is ChatState State))

                {

                    State = new ChatState(Session)

                    {

                        To = From,

                        Folder = PackagesFolder

                    };

                    Session[" State "] = State;

                }


                StringBuilder sb = new StringBuilder();

                List<string> ArgumentsList = new List<string>();

                LinkedList<IAdminCommand> Commands;

                IAdminCommand Command;

                object Details;

                string[] Arguments;

                string CommandName = null;

                int c = 0;

                bool InQuote = false;

                bool Escape = false;


                foreach (char ch in s)

                {

                    if (char.IsWhiteSpace(ch) && !InQuote)

                    {

                        if (c > 0)

                        {

                            if (CommandName is null)

                                CommandName = sb.ToString().ToLower();

                            else

                                ArgumentsList.Add(sb.ToString());


                            sb.Clear();

                            c = 0;

                        }

                    }

                    else if (Escape)

                    {

                        sb.Append(ch);

                        c++;

                        Escape = false;

                    }

                    else if (ch == '\\')

                        Escape = true;

                    else if (ch == '"')

                        InQuote = !InQuote;

                    else

                    {

                        sb.Append(ch);

                        c++;

                    }

                }


                if (Escape)

                {

                    sb.Append('\\');

                    c++;

                }


                if (c > 0)

                {

                    if (CommandName is null)

                        CommandName = sb.ToString().ToLower();

                    else

                        ArgumentsList.Add(sb.ToString());

                }


                if (CommandName is null)

                {

                    if (!(Channel is null))

                        await Channel.Information("(Ignored, no command)");


                    return;

                }


                Arguments = ArgumentsList.ToArray();


                lock (this.adminCommands)

                {

                    if (this.adminCommands.Count == 0)

                    {

                        foreach (Type T in Types.GetTypesImplementingInterface(typeof(IAdminCommand)))

                        {

                            try

                            {

                                TypeInfo TI = T.GetTypeInfo();


                                if (TI.IsAbstract || TI.IsInterface || TI.IsGenericTypeDefinition)

                                    continue;


                                Command = (IAdminCommand)Types.Instantiate(T);


                                string s2 = Command.Name.ToLower();

                                if (!this.adminCommands.TryGetValue(s2, out Commands))

                                {

                                    Commands = new LinkedList<IAdminCommand>();

                                    this.adminCommands[s2] = Commands;

                                }


                                Commands.AddLast(Command);


                                string[] Aliases = Command.Aliases;


                                if (!(Aliases is null))

                                {

                                    foreach (string Alias in Aliases)

                                    {

                                        s2 = Alias.ToLower();

                                        if (!this.adminCommands.TryGetValue(s2, out Commands))

                                        {

                                            Commands = new LinkedList<IAdminCommand>();

                                            this.adminCommands[s2] = Commands;

                                        }


                                        Commands.AddLast(Command);

                                    }

                                }

                            }

                            catch (Exception ex)

                            {

                                Log.Exception(ex, T.FullName);

                            }

                        }

                    }


                    Commands = null;

                    Command = null;

                    Details = null;


                    if (this.adminCommands.TryGetValue(CommandName, out Commands))

                    {

                        foreach (IAdminCommand Alternative in Commands)

                        {

                            if (Alternative.AppliesTo(s, Arguments, out Details))

                            {

                                Command = Alternative;

                                break;

                            }

                        }

                    }

                }


                if (Command is null)

                {

                    if (Arguments.Length == 0 && !(Commands is null))

                        await this.ProcessChatMessage("help " + s, From, User, ThreadId, ResponseCallback, Channel);

                    else if (State.CommandMode)

                    {

                        foreach (string Row in s.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries))

                            await this.ExecuteCommand(From, Row.Trim(), State, false, ResponseCallback);

                    }

                    else

                    {

                        StringBuilder PrintOutput = new StringBuilder();

                        StringWriter PrintWriter = new StringWriter(PrintOutput);

                        Session.ConsoleOut = PrintWriter;

                        Expression Exp = new Expression(s);

                        IElement Result;

                        AdminScriptRec Rec = new AdminScriptRec()

                        {

                            ResponseCallback = ResponseCallback

                        };


                        Task Preview(object Sender, PreviewEventArgs e)

                        {

                            return this.ReturnScriptResult(e.Preview, Rec);

                        };


                        Session.OnPreview += Preview;

                        try

                        {

                            Result = await Exp.Root.EvaluateAsync(Session);

                        }

                        catch (ScriptReturnValueException ex)

                        {

                            Result = ex.ReturnValue;

                        }

                        catch (Exception ex)

                        {

                            Result = new ObjectValue(ex);

                        }

                        finally

                        {

                            Session.OnPreview -= Preview;

                        }


                        Session["Ans"] = Result;


                        string Printed = PrintOutput.ToString().Trim();

                        PrintOutput.Clear();


                        if (!string.IsNullOrEmpty(Printed))

                            await SendPrinted(Printed, string.Empty, ResponseCallback);


                        await this.ReturnScriptResult(Result, Rec);

                    }

                }

                else

                    await Command.Execute(State, ArgumentsList.ToArray(), s, Details, ResponseCallback);

            }

            catch (Exception ex)

            {

                try

                {

                    ex = Log.UnnestException(ex);


                    Markdown = new StringBuilder();


                    Markdown.AppendLine("An error occurred when processing request:");

                    Markdown.AppendLine();

                    Markdown.AppendLine("<font class=\"error\">");

                    Markdown.AppendLine();

                    Markdown.AppendLine(MarkdownDocument.Encode(ex.Message));

                    Markdown.AppendLine();

                    Markdown.AppendLine("```");

                    Markdown.AppendLine(Log.CleanStackTrace(ex.StackTrace));

                    Markdown.AppendLine("```");

                    Markdown.AppendLine();

                    Markdown.AppendLine("</font>");


                    await ResponseCallback(Markdown.ToString(), string.Empty);

                }

                catch (Exception ex2)

                {

                    Log.Exception(ex2);

                }

            }

        }


        private class AdminScriptRec

        {

            public string MessageId = string.Empty;

            public ResponseCallbackHandler ResponseCallback;

        }


        private async Task ReturnScriptResult(IElement Result, AdminScriptRec Rec)

        {

            StringBuilder sb = new StringBuilder();


            if (Result.AssociatedObjectValue is IToMatrix ToMatrix)

                Result = ToMatrix.ToMatrix();


            if (Result is Graph G)

            {

                sb.AppendLine("```Graph");

                G.ToXml(sb);

                sb.AppendLine();

                sb.AppendLine("```");


                Rec.MessageId = await Rec.ResponseCallback(sb.ToString(), Rec.MessageId);

            }

            else if (Result.AssociatedObjectValue is SKImage Img)

            {

                SKData Data = Img.Encode(SKEncodedImageFormat.Png, 100);

                byte[] Bin = Data.ToArray();

                Data.Dispose();


                sb.Append("![Image result](data:image/png;base64,");

                sb.Append(System.Convert.ToBase64String(Bin, 0, Bin.Length));

                sb.Append(')');


                Rec.MessageId = await Rec.ResponseCallback(sb.ToString(), Rec.MessageId);

            }

            else if (Result.AssociatedObjectValue is Exception ex)

            {

                ex = Log.UnnestException(ex);


                if (ex is AggregateException ex2)

                {

                    sb.Clear();


                    foreach (Exception ex3 in ex2.InnerExceptions)

                    {

                        sb.AppendLine(ex3.Message);

                        sb.AppendLine();

                    }


                    Rec.MessageId = await SendErrorMessage(MarkdownDocument.Encode(sb.ToString()), Rec.MessageId, Rec.ResponseCallback);

                }

                else

                    Rec.MessageId = await SendErrorMessage(MarkdownDocument.Encode(ex.Message), Rec.MessageId, Rec.ResponseCallback);

            }

            else if (Result.AssociatedObjectValue is ObjectMatrix M && !(M.ColumnNames is null))

            {

                sb.Clear();


                foreach (string s3 in M.ColumnNames)

                {

                    sb.Append("| ");

                    sb.Append(MarkdownDocument.Encode(s3));

                    sb.Append(' ');

                }


                sb.AppendLine("|");


                foreach (string _ in M.ColumnNames)

                    sb.Append("|---");


                sb.AppendLine("|");


                int x, y;


                for (y = 0; y < M.Rows; y++)

                {

                    for (x = 0; x < M.Columns; x++)

                    {

                        sb.Append("| ");


                        object Item = M.GetElement(x, y).AssociatedObjectValue;

                        if (!(Item is null))

                        {

                            if (Item is string s3)

                                s3 = MarkdownDocument.Encode(s3);

                            else if (Item is MarkdownElement Element)

                                s3 = Element.ToString();

                            else

                                s3 = MarkdownDocument.Encode(Expression.ToString(Item));


                            s3 = s3.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", "<br/>");

                            sb.Append(s3);

                            sb.Append(' ');

                        }

                    }


                    sb.AppendLine("|");

                }


                Rec.MessageId = await Rec.ResponseCallback(sb.ToString(), Rec.MessageId);

            }

            else

                Rec.MessageId = await SendResult(Expression.ToString(Result), Rec.MessageId, Rec.ResponseCallback);

        }


        internal bool TryGetAdminCommand(string CommandName, out LinkedList<IAdminCommand> Command)

        {

            lock (this.adminCommands)

            {

                return this.adminCommands.TryGetValue(CommandName, out Command);

            }

        }


        internal string[] AdminCommands

        {

            get

            {

                string[] Result;


                lock (this.adminCommands)

                {

                    Result = new string[this.adminCommands.Count];

                    this.adminCommands.Keys.CopyTo(Result, 0);

                }


                return Result;

            }

        }


        internal static async Task SendPrinted(string Msg, string MessageId, ResponseCallbackHandler ResponseCallback)

        {

            string PrintColor = Theme.CurrentTheme.LinkColorUnvisited.ToString();


            foreach (string Row in Msg.Replace("\r\n", "\n").Replace('\r', '\n').Split('\n'))

                await ResponseCallback("<font style=\"color:" + PrintColor + "\">" + Row + "</font>", MessageId);

        }


        internal static Task<string> SendResult(string Msg, string MessageId, ResponseCallbackHandler ResponseCallback)

        {

            StringBuilder sb = new StringBuilder();


            if (Msg.IndexOfAny(CommonTypes.CRLF) < 0)

            {

                sb.Append("<font class=\"result\">`");

                sb.Append(Msg);

                sb.Append("`</font>");

            }

            else

            {

                sb.AppendLine("<font class=\"result\">");

                sb.AppendLine();

                sb.AppendLine("```");


                Msg = Msg.Replace("\r\n", "\n").Replace("\r", "\n");

                foreach (string Row in Msg.Split('\n'))

                    sb.AppendLine(Row);


                sb.AppendLine("```");

                sb.AppendLine();

                sb.AppendLine("</font>");

            }


            return ResponseCallback(sb.ToString(), MessageId);

        }


        internal static Task<string> SendErrorMessage(string Msg, string MessageId, ResponseCallbackHandler ResponseCallback)

        {

            StringBuilder sb = new StringBuilder();


            sb.AppendLine("<font class=\"error\">");

            sb.AppendLine();

            sb.AppendLine(Msg);

            sb.AppendLine();

            sb.AppendLine("</font>");


            return ResponseCallback(sb.ToString(), MessageId);

        }


        internal async Task<bool> ExecuteCommand(string To, string Command, ChatState State, bool Shell, ResponseCallbackHandler ResponseCallback)

        {

            if (string.IsNullOrEmpty(Command))

                return false;


            int AppDataLen = Gateway.AppDataFolder.Length;

            bool Exists;

            string s;


            try

            {

                s = Path.GetFullPath(Path.Combine(State.Folder, Command));

                Exists = File.Exists(s);

            }

            catch (Exception)

            {

                Exists = false;

                s = null;

            }


            if (Exists)

            {

                if (s.Length < AppDataLen || string.Compare(Gateway.AppDataFolder, s.Substring(0, AppDataLen), true) != 0)

                {

                    await SendErrorMessage("Access to files outside of the application data folder not permitted.", string.Empty, ResponseCallback);

                    return false;

                }


                if (!string.IsNullOrEmpty(To))

                    await ResponseCallback(this.DownloadableFile(s, State, To), string.Empty);

                return true;

            }


            int i = Command.IndexOfAny(new char[] { ' ', '\t' });


            if (i < 0)

            {

                s = Command;

                i = Command.Length;

            }

            else

                s = Command.Substring(0, i);


            switch (s.ToLower())

            {

                case "analyzeclock":

                case "csp":

                case "exstat":

                case "extract":

                case "install":

                case "regex":

                case "sign":

                case "transform":


                    if (Shell && string.Compare(s, "install", true) == 0)

                        s = Path.Combine(Path.GetDirectoryName(typeof(Gateway).Assembly.Location), "InstallUtility", "Waher.Utility." + s + FileSystem.ExecutableExtension);

                    else

                        s = Path.Combine(Path.GetDirectoryName(typeof(Gateway).Assembly.Location), "Waher.Utility." + s + FileSystem.ExecutableExtension);


                    if (File.Exists(s))

                    {

                        Command = "\"" + s + "\"" + Command.Substring(i);

                        break;

                    }


                    s = s.Substring(0, s.Length - 3) + "dll";

                    if (File.Exists(s))

                    {

                        Command = "dotnet \"" + s + "\"" + Command.Substring(i);

                        break;

                    }


                    await SendErrorMessage("File not found: `" + s.Substring(0, s.Length - 3) + "exe`. Unable to execute command.", string.Empty, ResponseCallback);

                    return false;


                // Windows commands

                case "bcdedit":

                case "call":

                case "cmd":

                case "del":

                case "diskpart":

                case "doskey":

                case "erase":

                case "format":

                case "fsutil":

                case "label":

                case "md":

                case "mkdir":

                case "mode":

                case "move":

                case "openfiles":

                case "rd":

                case "ren":

                case "rename":

                case "replace":

                case "rmdir":

                case "robocopy":

                case "sc":

                case "schtasks":

                case "start":

                case "taskkill":

                case "xcopy":

                case "wmic":

                case "telnet":

                case "icacls":

                case "runas":

                case "notepad":

                case "cl":

                case "python":

                case "perl":


                // macOS commands

                // Linux commands

                case "bash":

                case "zh":

                case "zsh":

                case "source":

                case "rm":

                case "diskutil":

                case "fdisk":

                case "alias":

                case "erasedisk":

                case "mkfs":

                case "e2label":

                case "stty":

                case "setterm":

                case "mv":

                case "lsof":

                case "rsync":

                case "launchctl":

                case "systemctl":

                case "crontab":

                case "launchd":

                case "open":

                case "xdg-open":

                case "kill":

                case "dd":

                case "chmod":

                case "chown":

                case "sudo":

                case "su":

                case "killall":

                case "ssh":

                case "wget":

                case "curl":

                case "tar":

                case "unzip":

                case "zip":

                case "nano":

                case "vi":

                case "vim":

                case "emacs":

                case "script":

                case "screen":

                case "tmux":

                case "nohup":


                    await SendErrorMessage("Command not allowed.", string.Empty, ResponseCallback);

                    // TODO: Secure with provisioning on a command level.

                    return false;


                case "cd.":

                    return ChangeDirectory(State, ".", ResponseCallback);


                case "cd..":

                    return ChangeDirectory(State, "..", ResponseCallback);


                case "cd":

                case "chdir":

                    return ChangeDirectory(State, Command.Substring(s.Length).Trim(), ResponseCallback);


                case "dir":

                case "ls":

                    try

                    {

                        string Pattern = Command.Substring(s.Length).Trim();

                        if (string.IsNullOrEmpty(Pattern))

                            Pattern = "*.*";


                        DirectoryInfo Folder = new DirectoryInfo(State.Folder);

                        DirectoryInfo[] Folders;

                        System.IO.FileInfo[] Files;

                        StringBuilder Markdown = new StringBuilder();

                        Dictionary<string, long> Sizes = new Dictionary<string, long>();

                        Dictionary<string, DateTime> DateTimes = new Dictionary<string, DateTime>();

                        string MaxSizeFileName = null;

                        string MaxDateTimeFileName = null;

                        DateTime MaxDateTime = DateTime.MinValue;

                        long MaxSize = int.MinValue;

                        DateTime TP;

                        bool IsMax;


                        Markdown.AppendLine("| Name | Size | Date | Time |");

                        Markdown.AppendLine("|:-----|-----:|:----:|:----:|");


                        Folders = Folder.GetDirectories(Pattern, SearchOption.TopDirectoryOnly);


                        foreach (DirectoryInfo DirInfo in Folders)

                        {

                            try

                            {

                                DateTimes[DirInfo.Name] = DirInfo.LastWriteTime;

                                if (DirInfo.LastWriteTime > MaxDateTime)

                                {

                                    MaxDateTime = DirInfo.LastWriteTime;

                                    MaxDateTimeFileName = DirInfo.Name;

                                }

                            }

                            catch (Exception)

                            {

                                // Ignore.

                            }

                        }


                        foreach (DirectoryInfo DirInfo in Folders)

                        {

                            Markdown.Append("| ");

                            Markdown.Append(MarkdownDocument.Encode(Path.GetFileName(DirInfo.Name)));

                            Markdown.Append(" | \\<DIR\\> | ");


                            if (DateTimes.TryGetValue(DirInfo.Name, out TP))

                            {

                                if (IsMax = (DirInfo.Name == MaxDateTimeFileName))

                                    Markdown.Append("**");


                                Markdown.Append(TP.ToShortDateString());


                                if (IsMax)

                                    Markdown.Append("**");


                                Markdown.Append(" | ");


                                if (IsMax)

                                    Markdown.Append("**");


                                Markdown.Append(TP.ToLongTimeString());


                                if (IsMax)

                                    Markdown.Append("**");


                                Markdown.AppendLine(" |");

                            }

                            else

                                Markdown.AppendLine("N/A ||");

                        }


                        Files = Folder.GetFiles(Pattern, SearchOption.TopDirectoryOnly);

                        DateTimes.Clear();

                        MaxDateTime = DateTime.MinValue;


                        foreach (System.IO.FileInfo FileInfo in Files)

                        {

                            try

                            {

                                Sizes[FileInfo.Name] = FileInfo.Length;

                                if (FileInfo.Length > MaxSize)

                                {

                                    MaxSize = FileInfo.Length;

                                    MaxSizeFileName = FileInfo.Name;

                                }

                            }

                            catch (Exception)

                            {

                                // Ignore.

                            }


                            try

                            {

                                DateTimes[FileInfo.Name] = FileInfo.LastWriteTime;

                                if (FileInfo.LastWriteTime > MaxDateTime)

                                {

                                    MaxDateTime = FileInfo.LastWriteTime;

                                    MaxDateTimeFileName = FileInfo.Name;

                                }

                            }

                            catch (Exception)

                            {

                                // Ignore.

                            }

                        }


                        foreach (System.IO.FileInfo FileInfo in Files)

                        {

                            Markdown.Append("| ");

                            Markdown.Append(this.DownloadableFile(FileInfo.Name, State, To));

                            Markdown.Append(" | ");


                            if (Sizes.TryGetValue(FileInfo.Name, out long Size))

                            {

                                if (IsMax = (FileInfo.Name == MaxSizeFileName))

                                    Markdown.Append("**");


                                Markdown.Append(Export.FormatBytes(Size));


                                if (IsMax)

                                    Markdown.Append("**");

                            }

                            else

                                Markdown.Append("N/A");


                            Markdown.Append(" | ");


                            if (DateTimes.TryGetValue(FileInfo.Name, out TP))

                            {

                                if (IsMax = (FileInfo.Name == MaxDateTimeFileName))

                                    Markdown.Append("**");


                                Markdown.Append(TP.ToShortDateString());


                                if (IsMax)

                                    Markdown.Append("**");


                                Markdown.Append(" | ");


                                if (IsMax)

                                    Markdown.Append("**");


                                Markdown.Append(TP.ToLongTimeString());


                                if (IsMax)

                                    Markdown.Append("**");


                                Markdown.AppendLine(" |");

                            }

                            else

                                Markdown.AppendLine("N/A ||");

                        }


                        await ResponseCallback(Markdown.ToString(), string.Empty);

                        return true;

                    }

                    catch (Exception)

                    {

                        // Run as normal command.

                    }

                    break;


                default:

                    if (s.StartsWith("cd.") || s.StartsWith("cd" + Path.DirectorySeparatorChar))

                        return ChangeDirectory(State, Command.Substring(2).Trim(), ResponseCallback);


                    if (File.Exists(s))

                    {

                        await SendErrorMessage("Executing files not allowed.", string.Empty, ResponseCallback);

                        return false;

                    }


                    // TODO: Secure with provisioning on a command level.

                    break;

            }


            ProcessStartInfo StartInfo;


            switch (Environment.OSVersion.Platform)

            {

                case PlatformID.Win32S:

                case PlatformID.Win32Windows:

                case PlatformID.Win32NT:

                case PlatformID.WinCE:

                    StartInfo = new ProcessStartInfo()

                    {

                        FileName = "cmd.exe",

                        Arguments = "/S /C \" " + Command.Trim() + " \"",

                        WorkingDirectory = State.Folder

                    };

                    break;


                case PlatformID.Unix:

                case PlatformID.MacOSX:

                    StartInfo = new ProcessStartInfo()

                    {

                        FileName = "/bin/zsh",

                        Arguments = "-c \" " + Command.Trim() + " \"",

                        WorkingDirectory = State.Folder

                    };

                    break;


                default:

                    await SendErrorMessage("Not supported on this operating system.", string.Empty, ResponseCallback);

                    return false;

            }


            if (Shell)

            {

                StartInfo.UseShellExecute = true;

                StartInfo.WindowStyle = ProcessWindowStyle.Normal;

            }

            else

            {

                StartInfo.CreateNoWindow = true;

                StartInfo.ErrorDialog = false;

                StartInfo.RedirectStandardInput = false;

                StartInfo.RedirectStandardError = true;

                StartInfo.RedirectStandardOutput = true;

                StartInfo.UseShellExecute = false;

                StartInfo.WindowStyle = ProcessWindowStyle.Hidden;

            }


            Process P = new Process()

            {

                StartInfo = StartInfo

            };


            if (Shell)

            {

                P.Start();

                return true;

            }


            Thread T = new Thread((e) =>

            {

                try

                {

                    try

                    {

                        LinkedListNode<Process> ProcessNode = State.Processes.AddLast(P);


                        P.Start();


                        do

                        {

                            bool Output = false;


                            s = P.StandardOutput.ReadToEnd().Trim();


                            if (!string.IsNullOrEmpty(s))

                            {

                                StringBuilder Markdown = new StringBuilder();


                                Markdown.AppendLine("```");

                                Markdown.AppendLine(s.Trim());

                                Markdown.AppendLine("```");


                                ResponseCallback(Markdown.ToString(), string.Empty);

                                Output = true;

                            }


                            s = P.StandardError.ReadToEnd().Trim();

                            if (!string.IsNullOrEmpty(s))

                            {

                                StringBuilder Markdown = new StringBuilder();


                                Markdown.AppendLine("<font class=\"error\">");

                                Markdown.AppendLine();

                                Markdown.AppendLine("```");

                                Markdown.AppendLine(s.Trim());

                                Markdown.AppendLine("```");

                                Markdown.AppendLine();

                                Markdown.AppendLine("</font>");


                                ResponseCallback(Markdown.ToString(), string.Empty);

                                Output = true;

                            }


                            if (!Output)

                                ResponseCallback("The command executed with no response.", string.Empty);

                        }

                        while (!P.HasExited);


                        State.Processes.Remove(ProcessNode);

                    }

                    finally

                    {

                        P.Dispose();

                    }

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }

            })

            {

                IsBackground = true,

                Name = "CMD Thread",

                Priority = ThreadPriority.BelowNormal

            };


            T.Start();


            return true;

        }


        internal string DownloadableFile(string s, ChatState State, string To)

        {

            if (!File.Exists(s))

                return MarkdownDocument.Encode(s);


            string Token = Hashes.BinaryToString(Gateway.NextBytes(32));

            Admin.FileInfo FileInfo;


            using (FileStream fs = File.Open(s, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

            {

                State.Files[Token] = FileInfo = new Admin.FileInfo()

                {

                    Path = s,

                    FileName = Path.GetFileName(s),

                    ContentType = InternetContent.GetContentType(Path.GetExtension(s)),

                    ETag = this.packages.ComputeETag(fs)

                };

            }


            string Url = Gateway.GetUrl("/ChatFile/" + HttpUtility.UrlEncode(FileInfo.FileName) +

                "?jid=" + HttpUtility.UrlEncode(To) + "&t=" + Token);


            return "<a href=\"" + XML.HtmlAttributeEncode(Url) + "\">" + MarkdownDocument.Encode(FileInfo.FileName) + "</a>";

        }


        private static bool ChangeDirectory(ChatState State, string NewFolder, ResponseCallbackHandler ResponseCallback)

        {

            string s = Path.GetFullPath(Path.Combine(State.Folder, NewFolder)) + Path.DirectorySeparatorChar;

            int AppDataLen = Gateway.AppDataFolder.Length;


            if (s.Length < AppDataLen || string.Compare(Gateway.AppDataFolder, s.Substring(0, AppDataLen), true) != 0)

            {

                SendErrorMessage("Access to folders outside of the application data folder not permitted.", string.Empty, ResponseCallback);

                return false;

            }

            else if (!Directory.Exists(s))

            {

                SendErrorMessage("Folder does not exist", string.Empty, ResponseCallback);

                return false;

            }

            else

            {

                State.Folder = s;

                ResponseCallback("New folder is `" + s + "`", string.Empty);

                return true;

            }

        }


        private async Task ChatFileDownload(HttpRequest Request, HttpResponse Response)

        {

            if (!Request.Header.TryGetQueryParameter("jid", out string Jid) ||

                !Request.Header.TryGetQueryParameter("t", out string Token))

            {

                throw new BadRequestException("Bad request.");

            }


            if (this.chatSessions is null || !this.chatSessions.TryGetValue(HttpUtility.UrlDecode(Jid), out Variables Session))

                throw new NotFoundException("Session has expired.");


            if (!Session.TryGetVariable(" State ", out Variable v) ||

                !(v.ValueObject is ChatState State) ||

                !State.Files.TryGetValue(Token, out Admin.FileInfo Rec))

            {

                throw new NotFoundException("Token not recognized.");

            }


            if (Rec.FileName != HttpUtility.UrlDecode(Request.SubPath.Substring(1)))

                throw new BadRequestException("Bad request.");


            if (string.Compare(Path.GetExtension(Rec.FileName), ".xml", true) == 0)

            {

                XmlReaderSettings ReaderSettings = new XmlReaderSettings()

                {

                    Async = true,

                    CheckCharacters = false,

                    ConformanceLevel = ConformanceLevel.Document,

                    DtdProcessing = DtdProcessing.Ignore,

                    IgnoreComments = false,

                    IgnoreProcessingInstructions = false,

                    IgnoreWhitespace = true,

                    ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.None

                };

                XmlWriterSettings WriterSettings = new XmlWriterSettings()

                {

                    Async = true,

                    CheckCharacters = false,

                    CloseOutput = false,

                    ConformanceLevel = ConformanceLevel.Document,

                    Encoding = Encoding.UTF8,

                    Indent = true,

                    IndentChars = "\t",

                    NamespaceHandling = NamespaceHandling.OmitDuplicates,

                    NewLineChars = "\r\n",

                    NewLineHandling = NewLineHandling.Replace,

                    NewLineOnAttributes = false,

                    OmitXmlDeclaration = false,

                    WriteEndDocumentOnClose = true

                };


                using (FileStream fs = File.Open(Rec.Path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

                {

                    using (XmlReader r = XmlReader.Create(fs, ReaderSettings))

                    {

                        TemporaryFile TempFile = new TemporaryFile();

                        try

                        {

                            using (XmlWriter w = XmlWriter.Create(TempFile, WriterSettings))

                            {

                                while (await r.ReadAsync())

                                {

                                    switch (r.NodeType)

                                    {

                                        case XmlNodeType.XmlDeclaration:

                                            // Managed by XmlWriter

                                            break;


                                        case XmlNodeType.ProcessingInstruction:

                                            string Url = r.Value;

                                            string s;

                                            int i, j;


                                            if ((i = Url.IndexOf(s = Gateway.RootFolder, StringComparison.CurrentCultureIgnoreCase)) >= 0 ||

                                                (i = Url.IndexOf(s = Gateway.AppDataFolder, StringComparison.CurrentCultureIgnoreCase)) >= 0)

                                            {

                                                Url = Url.Remove(i, s.Length - 1);


                                                j = Url.IndexOf('"', i);

                                                if (j >= 0)

                                                    Url = Url.Remove(i, j - i).Insert(i, Url.Substring(i, j - i).Replace(Path.DirectorySeparatorChar, '/'));

                                            }


                                            await w.WriteProcessingInstructionAsync(r.Name, Url);

                                            break;


                                        case XmlNodeType.Attribute:

                                            await w.WriteAttributeStringAsync(r.Prefix, r.LocalName, r.NamespaceURI, r.Value);

                                            break;


                                        case XmlNodeType.CDATA:

                                            await w.WriteCDataAsync(r.Value);

                                            break;


                                        case XmlNodeType.Comment:

                                            await w.WriteCommentAsync(r.Value);

                                            break;


                                        case XmlNodeType.EntityReference:

                                            await w.WriteEntityRefAsync(r.Name);

                                            break;


                                        case XmlNodeType.Text:

                                        case XmlNodeType.SignificantWhitespace:

                                            await w.WriteStringAsync(r.Value);

                                            break;


                                        case XmlNodeType.Whitespace:

                                            // Ignore

                                            break;


                                        case XmlNodeType.Element:

                                            await w.WriteStartElementAsync(r.Prefix, r.LocalName, r.NamespaceURI);


                                            bool IsEmpty = r.IsEmptyElement;


                                            if (r.HasAttributes && r.MoveToFirstAttribute())

                                            {

                                                await w.WriteAttributeStringAsync(r.Prefix, r.LocalName, r.NamespaceURI, r.Value);


                                                while (r.MoveToNextAttribute())

                                                    await w.WriteAttributeStringAsync(r.Prefix, r.LocalName, r.NamespaceURI, r.Value);

                                            }


                                            if (IsEmpty)

                                                w.WriteEndElement();

                                            break;


                                        case XmlNodeType.EndElement:

                                            await w.WriteEndElementAsync();

                                            break;


                                        case XmlNodeType.Document:

                                        case XmlNodeType.DocumentFragment:

                                        case XmlNodeType.DocumentType:

                                        case XmlNodeType.EndEntity:

                                        case XmlNodeType.Entity:

                                        case XmlNodeType.Notation:

                                            break;

                                    }

                                }

                            }

                        }

                        catch (XmlException)

                        {

                            // Ignore

                        }

                        catch (Exception ex)

                        {

                            TempFile.Dispose();

                            ExceptionDispatchInfo.Capture(ex).Throw();

                        }


                        Response.OnResponseSent += (Sender, e) =>

                        {

                            TempFile.Dispose();

                            return Task.CompletedTask;

                        };


                        DateTime LastWriteTime = File.GetLastWriteTime(Rec.Path);

                        await HttpFolderResource.SendResponse(TempFile.FileName, Rec.ContentType, Rec.ETag, LastWriteTime, Response);

                        return;

                    }

                }

            }


            await HttpFolderResource.SendResponse(Rec.Path, Rec.ContentType, Rec.ETag, File.GetLastWriteTime(Rec.Path), Response);

        }


        private Task ChatSessions_Removed(object Sender, CacheItemEventArgs<string, Variables> e)

        {

            if (e.Value.TryGetVariable(" State ", out Variable v) &&

                v.ValueObject is ChatState State)

            {

                foreach (Process P in State.Processes)

                {

                    try

                    {

                        P.Kill();

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                    }

                }


                State.Processes.Clear();

            }


            return Task.CompletedTask;

        }


        public static bool VerifyRecaptcha(object Posted, string RemoteEndpoint)

        {

            if (!(Posted is Dictionary<string, string> Form))

                return false;


            if (!Form.TryGetValue("g-recaptcha-response", out string RecaptchaResponse))

                return false;


            return Feedback.SiteVerify(RecaptchaResponse, RemoteEndpoint).Result;

        }


        public static Task<bool> SendMailMessage(string To, string Subject, string Markdown)

        {

            return SendMailMessage(To, Subject, Markdown, new EmbeddedContent[0]);

        }


        public static Task<bool> SendMailMessage(string To, string Subject, string Markdown, params EmbeddedContent[] Attachments)

        {

            string From = null;


            if (RelayConfiguration.Instance.UseRelayServer)

                From = RelayConfiguration.Instance.Sender;


            if (string.IsNullOrEmpty(From))

                From = XmppConfiguration.Instance.BareJid;


            return SendMailMessage(From, To, Subject, Markdown, Attachments);

        }


        public static Task<bool> SendMailMessage(string From, string To, string Subject, string Markdown)

        {

            return SendMailMessage(From, To, Subject, Markdown, new EmbeddedContent[0]);

        }


        public static Task<bool> SendMailMessage(string From, string To, string Subject, string Markdown, params EmbeddedContent[] Attachments)

        {

            if (RelayConfiguration.Instance.UseRelayServer)

            {

                if (string.IsNullOrEmpty(From))

                    From = RelayConfiguration.Instance.Sender;


                return SendMailMessage(

                    RelayConfiguration.Instance.Host,

                    RelayConfiguration.Instance.Port,

                    RelayConfiguration.Instance.UserName,

                    RelayConfiguration.Instance.Password,

                    From,

                    To,

                    Subject,

                    Markdown,

                    Attachments);

            }

            else

                return instance?.xmppServer?.SendMailMessage(From, To, Subject, Markdown) ?? Task.FromResult(false);

        }


        public static Task<bool> SendMailMessage(string SmtpHost, int SmtpPort, string UserName, string Password,

            string From, string To, string Subject, string Markdown)

        {

            return SendMailMessage(SmtpHost, SmtpPort, UserName, Password, From, To, Subject, Markdown, new EmbeddedContent[0]);

        }


        public static async Task<bool> SendMailMessage(string SmtpHost, int SmtpPort, string UserName, string Password,

            string From, string To, string Subject, string Markdown, params EmbeddedContent[] Attachments)

        {

            string Styles = string.Empty;


            if (!(Attachments is null))

            {

                List<EmbeddedContent> Attachments2 = null;

                bool Changed = false;


                foreach (EmbeddedContent Attachment in Attachments)

                {

                    if (!(Attachment.Decoded is null) && Attachment.Decoded is CssDocument CssDocument)

                    {

                        Styles += CssDocument.Css;

                        Changed = true;

                        continue;

                    }

                    else if (Attachment.Decoded is null && !(Attachment.Raw is null) && Attachment.ContentType.Contains(CssCodec.ContentType))

                    {

                        object Decoded = InternetContent.DecodeAsync(Attachment.ContentType, Attachment.Raw, null);


                        if (Decoded is CssDocument CssDocument2)

                        {

                            Styles += CssDocument2.Css;

                            Changed = true;

                            continue;

                        }

                    }


                    if (Attachments2 is null)

                        Attachments2 = new List<EmbeddedContent>();


                    Attachments2.Add(Attachment);

                }


                if (Changed)

                    Attachments = Attachments2?.ToArray();

            }


            MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Markdown);

            StringBuilder sb = new StringBuilder();


            sb.AppendLine("<html>");

            sb.AppendLine("<head>");


            if (!string.IsNullOrEmpty(Styles))

            {

                sb.AppendLine("<style>");

                sb.AppendLine(Styles);

                sb.AppendLine("</style>");

            }


            sb.AppendLine("</head>");

            sb.AppendLine("<body>");

            sb.AppendLine(HtmlDocument.GetBody(await Doc.GenerateHTML()));

            sb.AppendLine("</body>");

            sb.AppendLine("</html>");


            string HTML = sb.ToString();

            string PlainText = await Doc.GeneratePlainText();

            EmbeddedContent[] Alternatives = 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)

                    }

                };


            KeyValuePair<byte[], string> P = await InternetContent.EncodeAsync(new ContentAlternatives(Alternatives), Encoding.UTF8);

            byte[] BodyBin = P.Key;

            string ContentType = P.Value;


            if (!(Attachments is null) && Attachments.Length > 0)

            {

                EmbeddedContent[] Mixed = new EmbeddedContent[Attachments.Length + 1];

                Mixed[0] = new EmbeddedContent()

                {

                    ContentType = ContentType,

                    Raw = BodyBin

                };

                Array.Copy(Attachments, 0, Mixed, 1, Attachments.Length);


                P = await InternetContent.EncodeAsync(new MixedContent(Mixed), Encoding.UTF8);

                BodyBin = P.Key;

                ContentType = P.Value;

            }


            KeyValuePair<string, string>[] Headers = new KeyValuePair<string, string>[]

            {

                new KeyValuePair<string, string>("MIME-VERSION", "1.0"),

                new KeyValuePair<string, string>("FROM", From),

                new KeyValuePair<string, string>("TO", To),

                new KeyValuePair<string, string>("SUBJECT", Subject),

                new KeyValuePair<string, string>("DATE", CommonTypes.EncodeRfc822(DateTime.Now)),

                new KeyValuePair<string, string>("IMPORTANCE", "normal"),

                new KeyValuePair<string, string>("X-PRIORITY", "3"),

                new KeyValuePair<string, string>("MESSAGE-ID", Guid.NewGuid().ToString()),

                new KeyValuePair<string, string>("CONTENT-TYPE", ContentType)

            };


            int i = To.IndexOf('@');

            if (i < 0)

                throw new ArgumentException("Invalid mail address: " + To, nameof(To));


            string Domain = To.Substring(i + 1).Trim();


            return await (instance?.smtpServer?.SendMessage(Domain, SmtpHost, SmtpPort, UserName, Password, From, To, Headers, BodyBin, DateTime.Now) ?? Task.FromResult(false));

        }


        private MethodInfo getCounter2 = null;

        private MethodInfo getCounter3 = null;

        private MethodInfo getCpuValue = null;

        private MethodInfo getFreeMemoryValue = null;

        private object cpuCounter = null;

        private object freeMemoryCounter = null;


        private async void SampleTimerEventHandler(object Sender)

        {

            try

            {

                if (this.getCounter2 is null)

                {

                    Type T = Types.GetType("Waher.IoTGateway.Svc.PerformanceCounters");

                    this.getCounter2 = T?.GetMethod("GetCounter", new Type[] { typeof(string), typeof(string) });

                    this.getCounter3 = T?.GetMethod("GetCounter", new Type[] { typeof(string), typeof(string), typeof(string) });


                    this.cpuCounter = this.getCounter3?.Invoke(null, new object[] { "Processor", "_Total", "% Processor Time" });

                    this.getCpuValue = this.cpuCounter?.GetType()?.GetMethod("NextValue", new Type[0]);


                    this.freeMemoryCounter = this.getCounter2?.Invoke(null, new object[] { "Memory", "Available MBytes" });

                    if (this.freeMemoryCounter is null)

                        this.freeMemoryCounter = this.getCounter2?.Invoke(null, new object[] { "Minne", "Tillgängliga megabyte" });


                    this.getFreeMemoryValue = this.freeMemoryCounter?.GetType()?.GetMethod("NextValue", new Type[0]);

                }


                if (this.getCpuValue?.Invoke(this.cpuCounter, Types.NoParameters) is float CPU)

                    await this.statistics.Sample("CPU", CPU);


                if (this.getFreeMemoryValue?.Invoke(this.freeMemoryCounter, Types.NoParameters) is float FreeMemory)

                    await this.statistics.Sample("FreeMemory", FreeMemory);

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        public Bucket CurrentCpuBucket

        {

            get

            {

                if (this.statistics.TryGetBucket("CPU", out Bucket Bucket))

                    return Bucket;

                else

                    return null;

            }

        }


        public Bucket CurrentFreeMemoryBucket

        {

            get

            {

                if (this.statistics.TryGetBucket("FreeMemory", out Bucket Bucket))

                    return Bucket;

                else

                    return null;

            }

        }


        private async Task Export_OnExportKeyFolderUpdated(object Sender, EventArgs e)

        {

            try

            {

                this.httpFileUploadSettings.BackupFolder = await Export.GetFullExportFolderAsync();

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        private async Task Export_OnExportFolderUpdated(object Sender, EventArgs e)

        {

            try

            {

                this.httpFileUploadSettings.KeyFolder = await Export.GetFullKeyExportFolderAsync();

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        private async Task JwtRequest(object Sender, IqEventArgs e)

        {

            try

            {

                int Seconds = XML.Attribute(e.Query, "seconds", 0);

                if (Seconds <= 0)

                {

                    await e.IqErrorBadRequest(e.To, "Number of seconds token is to be valid must be a positive integer.", "en");

                    return;

                }


                if (Seconds > 3600)

                    Seconds = 3600;


                int IssuedAt = (int)Math.Round(DateTime.UtcNow.Subtract(JSON.UnixEpoch).TotalSeconds);

                int Expires = IssuedAt + Seconds;


                string Token = this.jwtFactory.Create(

                    new KeyValuePair<string, object>(JwtClaims.JwtId, System.Convert.ToBase64String(Gateway.NextBytes(32))),

                    new KeyValuePair<string, object>(JwtClaims.Issuer, Gateway.Domain.Value),

                    new KeyValuePair<string, object>(JwtClaims.Subject, e.From.Address.Value),

                    new KeyValuePair<string, object>(JwtClaims.IssueTime, IssuedAt),

                    new KeyValuePair<string, object>(JwtClaims.ExpirationTime, Expires));


                StringBuilder Xml = new StringBuilder();


                Xml.Append("<token xmlns='");

                Xml.Append(NamespaceJwt);

                Xml.Append("'>");

                Xml.Append(XML.Encode(Token));

                Xml.Append("</token>");


                await e.IqResult(Xml.ToString(), e.To);


                LoginAuditor.Success("Successful generation of JWT token.", e.From.BareJid, e.From.Address, "HTTP");

            }

            catch (Exception ex)

            {

                await e.IqError(ex, e.To);

            }

        }


        internal static Task<IClientConnection> JwtAuthenticate(HttpRequest Request)

        {

            return JwtAuthenticate(Request, instance.jwtFactory, instance.xmppServer);

        }


        public static async Task<IClientConnection> JwtAuthenticate(HttpRequest Request,

            JwtFactory Factory, XmppServer Server)

        {

            string TokenStr = JwtAuthentication.GetAccessToken(Request);

            if (string.IsNullOrEmpty(TokenStr))

            {

                if (Request.Response?.TransferEncoding is HttpxResponse HttpxResponse)

                {

                    (bool Found, IRecipient Recipient) = await HttpxResponse.Server.TryGetRecipient(HttpxResponse.To, HttpxResponse.From);

                    if (Found && Recipient is IClientConnection ClientConnection)

                        return ClientConnection;

                }


                throw new UnauthorizedException("Unauthorized access prohibited.", new string[] { "Bearer realm=\"" + Gateway.Domain?.Value + "\"" });

            }


            JwtToken Token = new JwtToken(TokenStr);

            if (!Factory.IsValid(Token, out Reason Reason))

            {

                LoginAuditor.Fail("Invalid JWT token.", Token.Subject ?? string.Empty, Request.RemoteEndPoint, "HTTP",

                    new KeyValuePair<string, object>("Reason", Reason));


                throw new ForbiddenException("Invalid JWT token.");

            }


            if (!Server.TryGetClientConnection(Token.Subject, out IClientConnection Connection))

            {

                LoginAuditor.Fail("JWT token obsoleted, due to XMPP disconnect.", Token.Subject ?? string.Empty, Request.RemoteEndPoint, "HTTP");


                throw new ForbiddenException("JWT token obsoleted, due to XMPP disconnect.");

            }


            return Connection;

        }


        private Task ProxyResource_AddSsoInformationEncrypted(object Sender, ProxyRequestEventArgs e)

        {

            return this.ProxyResource_AddSsoInformation(Sender, e, true);

        }


        private Task ProxyResource_AddSsoInformationUnencrypted(object Sender, ProxyRequestEventArgs e)

        {

            return this.ProxyResource_AddSsoInformation(Sender, e, false);

        }


        private Task ProxyResource_AddSsoInformation(object _, ProxyRequestEventArgs e, bool Encrypted)

        {

            // For a reference of JWT claims, see:

            // https://www.iana.org/assignments/jwt/jwt.xhtml#claims


            Variables Variables = e.Request.Session;

            if (Variables is null || e.Message.Headers.Contains("Authorization"))

                return Task.CompletedTask;


            if (Variables.TryGetVariable("User", out Variable v) && v.ValueObject is IUserWithClaims User)

                return this.AddSsoInformation(User, e, Encrypted);

            else if (Variables.TryGetVariable("QuickLoginUser", out v) && v.ValueObject is IUserWithClaims User2)

                return this.AddSsoInformation(User2, e, Encrypted);

            else

                return Task.CompletedTask;

        }


        private async Task AddSsoInformation(IUserWithClaims User, ProxyRequestEventArgs e, bool Encrypted)

        {

            string EncryptedPrefix = Encrypted ? "e" : "u";


            if (!this.ssoTokens.TryGetValue(EncryptedPrefix + User.UserName, out string JwtToken))

            {

                JwtToken = await User.CreateToken(this.jwtFactory, Encrypted);

                if (string.IsNullOrEmpty(JwtToken))

                    return;


                this.ssoTokens[EncryptedPrefix + User.UserName] = JwtToken;

            }


            e.Message.Headers.Add("Authorization", "Bearer " + JwtToken);

        }


        public bool AuthenticateJwtToken(JwtToken Token, out Reason Reason)

        {

            return this.jwtFactory.IsValid(Token, out Reason);

        }


    }

}

Waher.Content.CSV
Helps with common CSV-related tasks. (CSV=Comma Separated Values)
Definition: CSV.cs:21

Waher.Content.CSV.Parse
static string[][] Parse(string Csv)
Parses a CSV string.
Definition: CSV.cs:29

Waher.Content.CommonTypes
Helps with parsing of commong data types.
Definition: CommonTypes.cs:13

Waher.Content.CommonTypes.Encode
static string Encode(bool x)
Encodes a Boolean for use in XML and other formats.
Definition: CommonTypes.cs:594

Waher.Content.CommonTypes.CRLF
static readonly char[] CRLF
Contains the CR LF character sequence.
Definition: CommonTypes.cs:17

Waher.Content.CommonTypes.EncodeRfc822
static string EncodeRfc822(DateTime Timestamp)
Encodes a date and time, according to RFC 822 §5.
Definition: CommonTypes.cs:667

Waher.Content.Emoji.EmojiInfo
Contains information about an emoji.
Definition: EmojiUtilities.cs:9142

Waher.Content.Emoji.EmojiUtilities
Static class that provide methods for managing emojis.
Definition: EmojiUtilities.cs:13

Waher.Content.Emoji.EmojiUtilities.TryGetEmoji
static bool TryGetEmoji(string ShortName, out EmojiInfo Emoji)
Tries to get information about an emoji, given its short name.
Definition: EmojiUtilities.cs:1326

Waher.Content.Html.Css.CssCodec
CSS encoder/decoder.
Definition: CssCodec.cs:13

Waher.Content.Html.Css.CssCodec.ContentType
const string ContentType
Content-Type for CSS files.
Definition: CssCodec.cs:24

Waher.Content.Html.Css.CssDocument
Encapsulates a CSS Document
Definition: CssDocument.cs:7

Waher.Content.Html.Css.CssDocument.Css
string Css
CSS Text
Definition: CssDocument.cs:22

Waher.Content.Html.HtmlDocument
HTML document.
Definition: HtmlDocument.cs:14

Waher.Content.Html.HtmlDocument.GetBody
static string GetBody(string Html)
Extracts the contents of the BODY element in a HTML string.
Definition: HtmlDocument.cs:2058

Waher.Content.Html.JavaScript.JavaScriptCodec
JavaScript encoder/decoder.
Definition: JavascriptCodec.cs:13

Waher.Content.Html.JavaScript.JavaScriptCodec.DefaultContentType
const string DefaultContentType
application/javascript
Definition: JavascriptCodec.cs:24

Waher.Content.InternetContent
Static class managing encoding and decoding of internet content.
Definition: InternetContent.cs:17

Waher.Content.InternetContent.EncodeAsync
static Task< KeyValuePair< byte[], string > > EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
Encodes an object.
Definition: InternetContent.cs:324

Waher.Content.InternetContent.DecodeAsync
static Task< object > DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair< string, string >[] Fields, Uri BaseUri)
Decodes an object.
Definition: InternetContent.cs:547

Waher.Content.InternetContent.GetContentType
static string GetContentType(string FileExtension)
Gets the content type of an item, given its file extension. It uses the TryGetContentType to see if a...
Definition: InternetContent.cs:652

Waher.Content.JSON
Helps with common JSON-related tasks.
Definition: JSON.cs:14

Waher.Content.JSON.UnixEpoch
static readonly DateTime UnixEpoch
Unix Date and Time epoch, starting at 1970-01-01T00:00:00Z
Definition: JSON.cs:18

Waher.Content.Markdown.Consolidation.Consolidator
Consolidates Markdown from multiple sources, sharing the same thread.
Definition: Consolidator.cs:18

Waher.Content.Markdown.Consolidation.Consolidator.Update
Task< bool > Update(string Source, MarkdownDocument Markdown, string Id)
Updates incoming markdown information.
Definition: Consolidator.cs:161

Waher.Content.Markdown.Consolidation.Consolidator.Add
Task< bool > Add(string Source, MarkdownDocument Markdown)
Adds incoming markdown information.
Definition: Consolidator.cs:114

Waher.Content.Markdown.MarkdownCodec
Markdown encoder.
Definition: MarkdownCodec.cs:13

Waher.Content.Markdown.MarkdownCodec.ContentType
const string ContentType
Markdown content type.
Definition: MarkdownCodec.cs:51

Waher.Content.Markdown.MarkdownDocument
Contains a markdown document. This markdown document class supports original markdown,...
Definition: MarkdownDocument.cs:50

Waher.Content.Markdown.MarkdownDocument.Encode
static string Encode(string s)
Encodes all special characters in a string so that it can be included in a markdown document without ...
Definition: MarkdownDocument.cs:5771

Waher.Content.Markdown.MarkdownDocument.GeneratePlainText
async Task< string > GeneratePlainText()
Generates Plain Text from the markdown text.
Definition: MarkdownDocument.cs:5478

Waher.Content.Markdown.MarkdownDocument.GenerateHTML
async Task< string > GenerateHTML()
Generates HTML from the markdown text.
Definition: MarkdownDocument.cs:5433

Waher.Content.Markdown.MarkdownDocument.CreateAsync
static Task< MarkdownDocument > CreateAsync(string MarkdownText, params Type[] TransparentExceptionTypes)
Contains a markdown document. This markdown document class supports original markdown,...
Definition: MarkdownDocument.cs:90

Waher.Content.Markdown.Model.MarkdownElement
Abstract base class for all markdown elements.
Definition: MarkdownElement.cs:28

Waher.Content.Multipart.ContentAlternatives
Represents alternative versions of the same content, encoded with multipart/alternative
Definition: ContentAlternatives.cs:8

Waher.Content.Multipart.EmbeddedContent
Represents content embedded in other content.
Definition: EmbeddedContent.cs:38

Waher.Content.Multipart.EmbeddedContent.ContentType
string ContentType
Content-Type of embedded object.
Definition: EmbeddedContent.cs:57

Waher.Content.Multipart.EmbeddedContent.Decoded
object Decoded
Decoded body of embedded object. ContentType defines how TransferDecoded is transformed into Decoded.
Definition: EmbeddedContent.cs:124

Waher.Content.Multipart.EmbeddedContent.Raw
byte[] Raw
Raw, untrasnformed body of embedded object.
Definition: EmbeddedContent.cs:104

Waher.Content.Multipart.MixedContent
Represents mixed content, encoded with multipart/mixed
Definition: MixedContent.cs:7

Waher.Content.Resources
Static class managing loading of resources stored as embedded resources or in content files.
Definition: Resources.cs:15

Waher.Content.Resources.LoadResource
static byte[] LoadResource(string ResourceName)
Loads a resource from an embedded resource.
Definition: Resources.cs:61

Waher.Content.SystemFiles.FileSystem
Static class helping modules to find files installed on the system.
Definition: FileSystem.cs:12

Waher.Content.SystemFiles.FileSystem.ExecutableExtension
static string ExecutableExtension
Extension used by executable files on the platform.
Definition: FileSystem.cs:229

Waher.Content.Text.PlainTextCodec
Plain text encoder/decoder.
Definition: PlainTextCodec.cs:13

Waher.Content.Text.PlainTextCodec.DefaultContentType
const string DefaultContentType
text/plain
Definition: PlainTextCodec.cs:24

Waher.Content.Xml.XML
Helps with common XML-related tasks.
Definition: XML.cs:19

Waher.Content.Xml.XML.Attribute
static string Attribute(XmlElement E, string Name)
Gets the value of an XML attribute.
Definition: XML.cs:914

Waher.Content.Xml.XML.Encode
static string Encode(string s)
Encodes a string for use in XML.
Definition: XML.cs:27

Waher.Content.Xml.XML.TryParse
static bool TryParse(string s, out DateTime Value)
Tries to decode a string encoded DateTime.
Definition: XML.cs:744

Waher.Content.Xml.XML.HtmlAttributeEncode
static string HtmlAttributeEncode(string s)
Differs from Encode(String), in that it does not encode the aposotrophe.
Definition: XML.cs:119

Waher.Content.Xsl.XSL
Static class managing loading of XSL resources stored as embedded resources or in content files.
Definition: XSL.cs:15

Waher.Content.Xsl.XSL.LoadSchema
static XmlSchema LoadSchema(string ResourceName)
Loads an XML schema from an embedded resource.
Definition: XSL.cs:23

Waher.Content.Xsl.XSL.Validate
static void Validate(string ObjectID, XmlDocument Xml, params XmlSchema[] Schemas)
Validates an XML document given a set of XML schemas.
Definition: XSL.cs:118

Waher.Events.Log
Static class managing the application event log. Applications and services log events on this static ...
Definition: Log.cs:13

Waher.Events.Log.CleanStackTrace
static string CleanStackTrace(string StackTrace)
Cleans a Stack Trace string, removing entries from the asynchronous execution model,...
Definition: Log.cs:184

Waher.Events.Log.Register
static void Register(IEventSink EventSink)
Registers an event sink with the event log. Call Unregister(IEventSink) to unregister it,...
Definition: Log.cs:29

Waher.Events.Log.Exception
static void Exception(Exception Exception, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, params KeyValuePair< string, object >[] Tags)
Logs an exception. Event type will be determined by the severity of the exception.
Definition: Log.cs:1647

Waher.Events.Log.Warning
static void Warning(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs a warning event.
Definition: Log.cs:566

Waher.Events.Log.Error
static void Error(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs an error event.
Definition: Log.cs:682

Waher.Events.Log.Informational
static void Informational(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs an informational event.
Definition: Log.cs:334

Waher.Events.Log.UnnestException
static Exception UnnestException(Exception Exception)
Unnests an exception, to extract the relevant inner exception.
Definition: Log.cs:818

Waher.Events.Log.Unregister
static bool Unregister(IEventSink EventSink)
Unregisters an event sink from the event log.
Definition: Log.cs:46

Waher.Events.Log.Notice
static void Notice(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs a notice event.
Definition: Log.cs:450

Waher.Events.LogObject.Dispose
virtual void Dispose()
IDisposable.Dispose()
Definition: LogObject.cs:1134

Waher.Events.Statistics.EventStatistics
Contains event statistics.
Definition: EventStatistics.cs:10

Waher.Events.Statistics.EventStatistics.PerEventId
Dictionary< string, Statistic > PerEventId
Number of events, per actor.
Definition: EventStatistics.cs:34

Waher.Events.Statistics.EventStatistics.PerFacility
Dictionary< string, Statistic > PerFacility
Number of events, per actor.
Definition: EventStatistics.cs:43

Waher.Events.Statistics.EventStatistics.PerType
Dictionary< string, Statistic > PerType
Number of events, per actor.
Definition: EventStatistics.cs:70

Waher.Events.Statistics.EventStatistics.PerActor
Dictionary< string, Statistic > PerActor
Number of events, per actor.
Definition: EventStatistics.cs:25

Waher.Events.Statistics.EventStatistics.CurrentStat
DateTime CurrentStat
Timestamp of current statistics.
Definition: EventStatistics.cs:97

Waher.Events.Statistics.EventStatistics.PerStackTrace
Dictionary< string, Statistic > PerStackTrace
Number of events, per stack trace (Only of type Critical, Alert and Emergency).
Definition: EventStatistics.cs:79

Waher.Events.Statistics.EventStatistics.LastStat
DateTime LastStat
Timestamp of last statistics. If DateTime.MinValue, no statistics has been retrieved since restart of...
Definition: EventStatistics.cs:88

Waher.Events.Statistics.EventStatistics.PerLevel
Dictionary< string, Statistic > PerLevel
Number of events, per actor.
Definition: EventStatistics.cs:61

Waher.Events.Statistics.EventStatistics.PerModule
Dictionary< string, Statistic > PerModule
Number of events, per actor.
Definition: EventStatistics.cs:52

Waher.Events.Statistics.EventStatisticsSink
Calculates statistics on incoming events.
Definition: EventStatisticsSink.cs:11

Waher.Events.Statistics.EventStatisticsSink.GetStatisticsSinceLast
EventStatistics GetStatisticsSinceLast()
Gets statistics of events logged since last call to GetStatisticsSinceLast.
Definition: EventStatisticsSink.cs:36

Waher.IoTGateway.Export
Static class managing data export.
Definition: Export.cs:19

Waher.IoTGateway.Export.GetFullExportFolderAsync
static async Task< string > GetFullExportFolderAsync()
Full path to export folder.
Definition: Export.cs:23

Waher.IoTGateway.Export.GetFullKeyExportFolderAsync
static async Task< string > GetFullKeyExportFolderAsync()
Full path to key folder.
Definition: Export.cs:36

Waher.IoTGateway.Export.FormatBytes
static string FormatBytes(double Bytes)
Formats a file size using appropriate unit.
Definition: Export.cs:126

Waher.IoTGateway.Gateway
Static class managing the runtime environment of the IoT Gateway.
Definition: Gateway.cs:126

Waher.IoTGateway.Gateway.Domain
static CaseInsensitiveString Domain
Domain name.
Definition: Gateway.cs:2354

Waher.IoTGateway.Gateway.InstanceName
static string InstanceName
Name of the current instance. Default instance=string.Empty
Definition: Gateway.cs:2364

Waher.IoTGateway.Gateway.Terminate
static Task Terminate()
Raises the OnTerminate event handler, letting the container executable know the application needs to ...
Definition: Gateway.cs:2455

Waher.IoTGateway.Gateway.Certificate
static X509Certificate2 Certificate
Domain certificate.
Definition: Gateway.cs:2349

Waher.IoTGateway.Gateway.GetMultiFormatChatMessageXml
static Task< string > GetMultiFormatChatMessageXml(string Markdown)
Gets XML for a multi-formatted chat message.
Definition: Gateway.cs:4065

Waher.IoTGateway.Gateway.DoBackup
static async Task DoBackup()
Performs a backup of the system.
Definition: Gateway.cs:3684

Waher.IoTGateway.Gateway.LoginAuditor
static LoginAuditor LoginAuditor
Current Login Auditor. Should be used by modules accepting user logins, to protect the system from un...
Definition: Gateway.cs:3033

Waher.IoTGateway.Gateway.ProcessNewServiceConfigurations
static Task< int > ProcessNewServiceConfigurations()
Processes new Service Configuration Files. This method should be called after installation of new ser...
Definition: Gateway.cs:5151

Waher.IoTGateway.Gateway.NextBytes
static byte[] NextBytes(int NrBytes)
Generates an array of random bytes.
Definition: Gateway.cs:3534

Waher.IoTGateway.Gateway.AppDataFolder
static string AppDataFolder
Application data folder.
Definition: Gateway.cs:2369

Waher.IoTGateway.Gateway.GetConfigPorts
static int[] GetConfigPorts(string Protocol)
Gets the port numbers defined for a given protocol in the configuration file.
Definition: Gateway.cs:2420

Waher.IoTGateway.Gateway.AlternativeDomains
static CaseInsensitiveString[] AlternativeDomains
Alternative domain names
Definition: Gateway.cs:2359

Waher.IoTGateway.Gateway.AvatarClient
static Networking.XMPP.Avatar.AvatarClient AvatarClient
XMPP Concentrator Server.
Definition: Gateway.cs:3219

Waher.IoTGateway.Gateway.SendNotification
static Task SendNotification(Graph Graph)
Sends a graph as a notification message to configured notification recipients.
Definition: Gateway.cs:3826

Waher.IoTGateway.Gateway.GetUrl
static string GetUrl(string LocalResource)
Gets a URL for a resource.
Definition: Gateway.cs:4167

Waher.IoTGateway.Gateway.MucClient
static MultiUserChatClient MucClient
XMPP Multi-User Chat Protocol (MUC) Client.
Definition: Gateway.cs:3267

Waher.IoTGateway.Gateway.GetCustomErrorHtml
static async Task< string > GetCustomErrorHtml(HttpRequest Request, string LocalFileName, string ContentType, byte[] Content)
Gets a custom error HTML document.
Definition: Gateway.cs:4731

Waher.IoTGateway.Gateway.ScheduleEvent
static DateTime ScheduleEvent(ScheduledEventCallback Callback, DateTime When, object State)
Schedules a one-time event.
Definition: Gateway.cs:3452

Waher.IoTGateway.Gateway.GetNotificationAddresses
static CaseInsensitiveString[] GetNotificationAddresses()
Returns configured notification addresses.
Definition: Gateway.cs:3922

Waher.IoTGateway.Gateway.XmppClient
static XmppClient XmppClient
XMPP Client connection of gateway.
Definition: Gateway.cs:3187

Waher.IoTGateway.Gateway.RootFolder
static string RootFolder
Web root folder.
Definition: Gateway.cs:2379

Waher.IoTGateway.Gateway.CancelScheduledEvent
static bool CancelScheduledEvent(DateTime When)
Cancels a scheduled event.
Definition: Gateway.cs:3474

Waher.IoTGateway.Gateway.SoftwareUpdateClient
static SoftwareUpdateClient SoftwareUpdateClient
XMPP Software Updates Client, if such a compoent is available on the XMPP broker.
Definition: Gateway.cs:3283

Waher.IoTGateway.Gateway.ProvisioningClient
static ProvisioningClient ProvisioningClient
XMPP Provisioning Client.
Definition: Gateway.cs:3203

Waher.IoTGateway.Gateway.Root
static HttpFolderResource Root
Root folder resource.
Definition: Gateway.cs:2384

Waher.IoTGateway.ScriptExtensions.Constants.Domain
Domain constant, contains the value of the gateway domain.
Definition: Domain.cs:13

Waher.IoTGateway.ScriptExtensions.Constants.Theme
Theme constant.
Definition: Theme.cs:19

Waher.IoTGateway.ScriptExtensions.Constants.Theme.CurrentTheme
static ThemeDefinition CurrentTheme
Current theme.
Definition: Theme.cs:89

Waher.IoTGateway.Setup.DomainConfiguration
Domain Configuration
Definition: DomainConfiguration.cs:33

Waher.IoTGateway.Setup.DomainConfiguration.Instance
static DomainConfiguration Instance
Current instance of configuration.
Definition: DomainConfiguration.cs:77

Waher.IoTGateway.Setup.DomainConfiguration.UseEncryption
bool UseEncryption
If the server uses server-side encryption.
Definition: DomainConfiguration.cs:135

Waher.IoTGateway.Setup.ThemeDefinition.LinkColorUnvisited
SKColor LinkColorUnvisited
Color of unvisited links.
Definition: ThemeDefinition.cs:293

Waher.IoTGateway.Setup.XmppConfiguration
XMPP Configuration
Definition: Registration.cs:7

Waher.IoTGateway.Setup.XmppConfiguration.Account
string Account
XMPP Account
Definition: XmppConfiguration.cs:157

Waher.IoTGateway.Setup.XmppConfiguration.BareJid
string BareJid
Bare JID
Definition: XmppConfiguration.cs:266

Waher.IoTGateway.Setup.XmppConfiguration.Instance
static XmppConfiguration Instance
Current instance of configuration.
Definition: XmppConfiguration.cs:100

Waher.IoTGateway.WebResources.HttpConfigurableFileResource
Represents a file-based resource that can have custom values depending on what domain the resource is...
Definition: HttpConfigurableFileResource.cs:13

Waher.Networking.CommunicationLayer.Sniffers
ISniffer[] Sniffers
Registered sniffers.
Definition: CommunicationLayer.cs:108

Waher.Networking.CommunicationLayer.Add
virtual void Add(ISniffer Sniffer)
ICommunicationLayer.Add
Definition: CommunicationLayer.cs:52

Waher.Networking.DNS.Communication.DnsMessage
Represents a DNS message
Definition: DnsMessage.cs:13

Waher.Networking.DNS.Communication.DnsMessage.Questions
Question[] Questions
Question section
Definition: DnsMessage.cs:122

Waher.Networking.DNS.Communication.DnsResponse
Stored DNS Query
Definition: DnsResponse.cs:16

Waher.Networking.DNS.Communication.DnsResponse.Raw
byte[] Raw
Raw DNS message
Definition: DnsResponse.cs:116

Waher.Networking.DNS.Communication.Question
Contains information about a DNS Question
Definition: Question.cs:12

Waher.Networking.DNS.Communication.Question.QNAME
string QNAME
Query Name
Definition: Question.cs:33

Waher.Networking.DNS.Communication.Question.QTYPE
QTYPE QTYPE
Query TYPE
Definition: Question.cs:38

Waher.Networking.DNS.Communication.Question.QCLASS
QCLASS QCLASS
Query CLASS
Definition: Question.cs:43

Waher.Networking.DNS.DnsResolver
DNS resolver, as defined in:
Definition: DnsResolver.cs:32

Waher.Networking.DNS.DnsResolver.Query
static Task< DnsResponse > Query(string Name, QTYPE TYPE, QCLASS CLASS)
Resolves a DNS name.
Definition: DnsResolver.cs:329

Waher.Networking.DNS.HTTPS.DnsOverHttpsResource
DNS over HTTPS resource.
Definition: DnsOverHttpsResource.cs:14

Waher.Networking.HTTP.BadRequestException
The request could not be understood by the server due to malformed syntax. The client SHOULD NOT repe...
Definition: BadRequestException.cs:9

Waher.Networking.HTTP.CommunicationStatistics
Contains communication statistics.
Definition: CommunicationStatistics.cs:11

Waher.Networking.HTTP.CommunicationStatistics.CallsPerFrom
Dictionary< string, Statistic > CallsPerFrom
Calls per From header value.
Definition: CommunicationStatistics.cs:44

Waher.Networking.HTTP.CommunicationStatistics.NrBytesTx
long NrBytesTx
Number of bytes transmitted.
Definition: CommunicationStatistics.cs:89

Waher.Networking.HTTP.CommunicationStatistics.NrCalls
long NrCalls
Number of method calls.
Definition: CommunicationStatistics.cs:98

Waher.Networking.HTTP.CommunicationStatistics.NrBytesRx
long NrBytesRx
Number of bytes received.
Definition: CommunicationStatistics.cs:80

Waher.Networking.HTTP.CommunicationStatistics.CallsPerResource
Dictionary< string, Statistic > CallsPerResource
Calls per resource.
Definition: CommunicationStatistics.cs:53

Waher.Networking.HTTP.CommunicationStatistics.CurrentStat
DateTime CurrentStat
Timestamp of current statistics.
Definition: CommunicationStatistics.cs:71

Waher.Networking.HTTP.CommunicationStatistics.CallsPerMethod
Dictionary< string, Statistic > CallsPerMethod
Calls per method.
Definition: CommunicationStatistics.cs:26

Waher.Networking.HTTP.CommunicationStatistics.LastStat
DateTime LastStat
Timestamp of last statistics. If DateTime.MinValue, no statistics has been retrieved since restart of...
Definition: CommunicationStatistics.cs:62

Waher.Networking.HTTP.CommunicationStatistics.CallsPerUserAgent
Dictionary< string, Statistic > CallsPerUserAgent
Calls per User Agent header value.
Definition: CommunicationStatistics.cs:35

Waher.Networking.HTTP.FileNotFoundEventArgs
Event arguments for file not found events.
Definition: FileNotFoundEventArgs.cs:9

Waher.Networking.HTTP.FileNotFoundEventArgs.Response
HttpResponse Response
Current response object.
Definition: FileNotFoundEventArgs.cs:48

Waher.Networking.HTTP.FileNotFoundEventArgs.Request
HttpRequest Request
Current request object.
Definition: FileNotFoundEventArgs.cs:43

Waher.Networking.HTTP.FileNotFoundEventArgs.Exception
NotFoundException Exception
Exception that will be returned to client. Change, if a custom exception is to be returned....
Definition: FileNotFoundEventArgs.cs:35

Waher.Networking.HTTP.ForbiddenException
The server understood the request, but is refusing to fulfill it. Authorization will not help and the...
Definition: ForbiddenException.cs:13

Waher.Networking.HTTP.HttpException.HeaderFields
KeyValuePair< string, string >[] HeaderFields
HTTP Header fields to include in the response.
Definition: HttpException.cs:210

Waher.Networking.HTTP.HttpException.GetContentObjectAsync
async Task< object > GetContentObjectAsync()
Any content object to return. The object will be encoded before being sent.
Definition: HttpException.cs:221

Waher.Networking.HTTP.HttpException.ContentType
string ContentType
The content type of Content, if provided.
Definition: HttpException.cs:250

Waher.Networking.HTTP.HttpException.StatusCode
int StatusCode
HTTP Status Code.
Definition: HttpException.cs:205

Waher.Networking.HTTP.HttpException.Content
byte[] Content
Any encoded content to return.
Definition: HttpException.cs:245

Waher.Networking.HTTP.HttpFolderResource
Publishes a folder with all its files and subfolders through HTTP GET, with optional support for PUT,...
Definition: HttpFolderResource.cs:41

Waher.Networking.HTTP.HttpFolderResource.SendResponse
static Task SendResponse(string FullPath, string ContentType, string ETag, DateTime LastModified, HttpResponse Response)
Sends a file-based response back to the client.
Definition: HttpFolderResource.cs:579

Waher.Networking.HTTP.HttpRequestHeader.TryGetQueryParameter
bool TryGetQueryParameter(string QueryParameter, out string Value)
Tries to get the value of an individual query parameter, if available.
Definition: HttpRequestHeader.cs:185

Waher.Networking.HTTP.HttpRequest
Represents an HTTP request.
Definition: HttpRequest.cs:18

Waher.Networking.HTTP.HttpRequest.Header
HttpRequestHeader Header
Request header.
Definition: HttpRequest.cs:134

Waher.Networking.HTTP.HttpRequest.RemoteEndPoint
string RemoteEndPoint
Remote end-point.
Definition: HttpRequest.cs:195

Waher.Networking.HTTP.HttpRequest.Session
Variables Session
Contains session states, if the resource requires sessions, or null otherwise.
Definition: HttpRequest.cs:164

Waher.Networking.HTTP.HttpRequest.SubPath
string SubPath
Sub-path. If a resource is found handling the request, this property contains the trailing sub-path o...
Definition: HttpRequest.cs:146

Waher.Networking.HTTP.HttpRequest.Response
HttpResponse Response
HTTP Response object, if one has been assigned to the request.
Definition: HttpRequest.cs:206

Waher.Networking.HTTP.HttpResource
Base class for all HTTP resources.
Definition: HttpResource.cs:23

Waher.Networking.HTTP.HttpResource.ComputeETag
string ComputeETag(Stream fs)
Computes an ETag value for a resource.
Definition: HttpResource.cs:193

Waher.Networking.HTTP.HttpResponse
Represets a response of an HTTP client request.
Definition: HttpResponse.cs:21

Waher.Networking.HTTP.HttpResponse.DisposeAsync
async Task DisposeAsync()
Closes the connection and disposes of all resources.
Definition: HttpResponse.cs:457

Waher.Networking.HTTP.HttpResponse.SendResponse
async Task SendResponse()
Sends the response back to the client. If the resource is synchronous, there's no need to call this m...
Definition: HttpResponse.cs:550

Waher.Networking.HTTP.HttpResponse.SetHeader
void SetHeader(string FieldName, string Value)
Sets a custom header field value.
Definition: HttpResponse.cs:248

Waher.Networking.HTTP.HttpResponse.TransferEncoding
TransferEncoding TransferEncoding
Transfer encoding in response.
Definition: HttpResponse.cs:544

Waher.Networking.HTTP.HttpResponse.Write
async Task Write(byte[] Data)
Returns binary data in the response.
Definition: HttpResponse.cs:1062

Waher.Networking.HTTP.HttpReverseProxyResource
An HTTP Reverse proxy resource. Incoming requests are reverted to a another web server for processing...
Definition: HttpReverseProxyResource.cs:23

Waher.Networking.HTTP.HttpServer
Implements an HTTP server.
Definition: HttpServer.cs:36

Waher.Networking.HTTP.HttpServer.OpenHttpPorts
int[] OpenHttpPorts
HTTP Ports successfully opened.
Definition: HttpServer.cs:693

Waher.Networking.HTTP.HttpServer.CreateVariables
static Variables CreateVariables()
Creates a new collection of variables, that contains access to the global set of variables.
Definition: HttpServer.cs:1604

Waher.Networking.HTTP.HttpServer.GetCommunicationStatisticsSinceLast
CommunicationStatistics GetCommunicationStatisticsSinceLast()
Gets communication statistics since last call.
Definition: HttpServer.cs:1755

Waher.Networking.HTTP.HttpServer.Register
HttpResource Register(HttpResource Resource)
Registers a resource with the server.
Definition: HttpServer.cs:1287

Waher.Networking.HTTP.HttpServer.DefaultHttpPort
const int DefaultHttpPort
Default HTTP Port (80).
Definition: HttpServer.cs:40

Waher.Networking.HTTP.HttpServer.OpenHttpsPorts
int[] OpenHttpsPorts
HTTPS Ports successfully opened.
Definition: HttpServer.cs:704

Waher.Networking.HTTP.HttpServer.Unregister
bool Unregister(HttpResource Resource)
Unregisters a resource from the server.
Definition: HttpServer.cs:1438

Waher.Networking.HTTP.HttpServer.DefaultHttpsPort
const int DefaultHttpsPort
Default HTTPS port (443).
Definition: HttpServer.cs:45

Waher.Networking.HTTP.NotFoundException
The server has not found anything matching the Request-URI. No indication is given of whether the con...
Definition: NotFoundException.cs:9

Waher.Networking.HTTP.ProxyRequestEventArgs
Event arguments for proxy request events.
Definition: ProxyRequestEventArgs.cs:10

Waher.Networking.HTTP.ProxyRequestEventArgs.Request
HttpRequest Request
Current request object.
Definition: ProxyRequestEventArgs.cs:36

Waher.Networking.HTTP.ProxyRequestEventArgs.Message
HttpRequestMessage Message
Message being forwarded.
Definition: ProxyRequestEventArgs.cs:31

Waher.Networking.HTTP.UnauthorizedException
Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or ...
Definition: UnauthorizedException.cs:9

Waher.Networking.SMTP.Server.SmtpServer
Implements a simple SMTP Server, as defined in:
Definition: SmtpServer.cs:44

Waher.Networking.SMTP.Server.SmtpServer.ExternalSniffers
CommunicationLayer ExternalSniffers
External Sniffers for SMTP communication.
Definition: SmtpServer.cs:224

Waher.Networking.SMTP.Server.SmtpServer.UpdateCertificate
void UpdateCertificate(X509Certificate ServerCertificate)
Updates the server certificate
Definition: SmtpServer.cs:300

Waher.Networking.SMTP.Server.SmtpServer.Dispose
void Dispose()
IDisposable.Dispose
Definition: SmtpServer.cs:325

Waher.Networking.Sniffers.XmlFileSniffer
Outputs sniffed data to an XML file.
Definition: XmlFileSniffer.cs:14

Waher.Networking.XMPP.Concentrator.ConcentratorServer
Implements an XMPP concentrator server interface.
Definition: ConcentratorServer.cs:41

Waher.Networking.XMPP.Concentrator.ConcentratorServer.Register
Task< bool > Register(IDataSource DataSource)
Registers a new data source with the concentrator.
Definition: ConcentratorServer.cs:551

Waher.Networking.XMPP.Server.BOSH.BoshWebClientResource
BOSH webclient interface
Definition: BoshWebClientResource.cs:20

Waher.Networking.XMPP.Server.ClientConnection
Abstract base class for XMPP client connections
Definition: ClientConnection.cs:19

Waher.Networking.XMPP.Server.HttpFileUpload.FileInfo
Information about a file upload.
Definition: FileInfo.cs:35

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadComponent
Implements HTTP File Upload support as an XMPP component: https://xmpp.org/extensions/xep-0363....
Definition: HttpFileUploadComponent.cs:20

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: HttpFileUploadComponent.cs:93

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadSettings
HTTP File Upload settings.
Definition: HttpFileUploadSettings.cs:9

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadSettings.PubSubStorageFolder
string PubSubStorageFolder
Folder where encrypted files reside.
Definition: HttpFileUploadSettings.cs:63

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadSettings.EncryptedStorageFolder
string EncryptedStorageFolder
Folder where encrypted files reside.
Definition: HttpFileUploadSettings.cs:53

Waher.Networking.XMPP.Server.HttpFileUpload.XmppFileUploadResource
HTTP Resource managing HTTP Uploads, and access to uploaded files.
Definition: XmppFileUploadResource.cs:18

Waher.Networking.XMPP.Server.IqEventArgs
Event arguments for IQ queries.
Definition: IqEventArgs.cs:12

Waher.Networking.XMPP.Server.IqEventArgs.Type
string Type
Type attribute in IQ stanza.
Definition: IqEventArgs.cs:83

Waher.Networking.XMPP.Server.IqEventArgs.From
XmppAddress From
From address attribute
Definition: IqEventArgs.cs:93

Waher.Networking.XMPP.Server.IqEventArgs.IqResult
Task IqResult(string Xml, string From)
Returns a response to the current request.
Definition: IqEventArgs.cs:113

Waher.Networking.XMPP.Server.IqEventArgs.Query
XmlElement Query
Query element, if found, null otherwise.
Definition: IqEventArgs.cs:70

Waher.Networking.XMPP.Server.IqEventArgs.To
XmppAddress To
To address attribute
Definition: IqEventArgs.cs:88

Waher.Networking.XMPP.Server.IqEventArgs.IqError
async Task IqError(string ErrorType, string Xml, XmppAddress From, string ErrorText, string Language)
Returns an error response to the current request.
Definition: IqEventArgs.cs:137

Waher.Networking.XMPP.Server.IqEventArgs.IqErrorBadRequest
Task IqErrorBadRequest(XmppAddress From, string ErrorText, string Language)
Returns a bad-request error.
Definition: IqEventArgs.cs:159

Waher.Networking.XMPP.Server.SOCKS5.Socks5Component
Implements SOCKS5 Byte streams support as an XMPP component: https://xmpp.org/extensions/xep-0065....
Definition: Socks5Component.cs:16

Waher.Networking.XMPP.Server.SOCKS5.Socks5Component.Dispose
override void Dispose()
IDisposable.Dispose
Definition: Socks5Component.cs:46

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics
Contains communication statistics.
Definition: CommunicationStatistics.cs:11

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.StanzasPerFromDomain
Dictionary< string, Statistic > StanzasPerFromDomain
Stanzas per domain of sender
Definition: CommunicationStatistics.cs:38

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.NrBytesTx
long NrBytesTx
Number of bytes transmitted.
Definition: CommunicationStatistics.cs:119

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.StanzasPerStanzaType
Dictionary< string, Statistic > StanzasPerStanzaType
Stanzas per stanza and type.
Definition: CommunicationStatistics.cs:29

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.LastStat
DateTime LastStat
Timestamp of last statistics. If DateTime.MinValue, no statistics has been retrieved since restart of...
Definition: CommunicationStatistics.cs:92

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.StanzasPerToDomain
Dictionary< string, Statistic > StanzasPerToDomain
Stanzas per domain of receiver
Definition: CommunicationStatistics.cs:47

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.StanzasPerToBareJid
Dictionary< string, Statistic > StanzasPerToBareJid
Stanzas per bare JID of receiver
Definition: CommunicationStatistics.cs:65

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.StanzasPerNamespace
Dictionary< string, Statistic > StanzasPerNamespace
Stanzas per namespace
Definition: CommunicationStatistics.cs:74

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.NrStanzas
long NrStanzas
Number of stanzas.
Definition: CommunicationStatistics.cs:128

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.NrBytesRx
long NrBytesRx
Number of bytes received.
Definition: CommunicationStatistics.cs:110

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.StanzasPerFqn
Dictionary< string, Statistic > StanzasPerFqn
Stanzas per fully qualified name (namespace::localName)
Definition: CommunicationStatistics.cs:83

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.CurrentStat
DateTime CurrentStat
Timestamp of current statistics.
Definition: CommunicationStatistics.cs:101

Waher.Networking.XMPP.Server.Statistics.CommunicationStatistics.StanzasPerFromBareJid
Dictionary< string, Statistic > StanzasPerFromBareJid
Stanzas per bare JID of sender
Definition: CommunicationStatistics.cs:56

Waher.Networking.XMPP.Server.Statistics.S2sEndpointStatistics
Mainstains information about connectivity from a specific s2s endpoint.
Definition: S2sEndpointStatistics.cs:9

Waher.Networking.XMPP.Server.WS.WebSocketClientResource
Web Socket client interface
Definition: WebSocketClientResource.cs:16

Waher.Networking.XMPP.Server.XmppAddress
Contains information about one XMPP address.
Definition: XmppAddress.cs:9

Waher.Networking.XMPP.Server.XmppAddress.Resource
CaseInsensitiveString Resource
Resource part.
Definition: XmppAddress.cs:71

Waher.Networking.XMPP.Server.XmppAddress.Domain
CaseInsensitiveString Domain
Domain
Definition: XmppAddress.cs:97

Waher.Networking.XMPP.Server.XmppAddress.Address
CaseInsensitiveString Address
XMPP Address
Definition: XmppAddress.cs:37

Waher.Networking.XMPP.Server.XmppAddress.BareJid
CaseInsensitiveString BareJid
Bare JID
Definition: XmppAddress.cs:45

Waher.Networking.XMPP.Server.XmppAddress.Empty
static readonly XmppAddress Empty
Empty address.
Definition: XmppAddress.cs:31

Waher.Networking.XMPP.Server.XmppAddress.Account
CaseInsensitiveString Account
Account
Definition: XmppAddress.cs:124

Waher.Networking.XMPP.Server.XmppServer
XMPP Server class
Definition: XmppServer.cs:64

Waher.Networking.XMPP.Server.XmppServer.ExtendedAddressingNamespace
const string ExtendedAddressingNamespace
http://jabber.org/protocol/address (XEP-0033)
Definition: XmppServer.cs:138

Waher.Networking.XMPP.Server.XmppServer.GetClientConnections
IClientConnection[] GetClientConnections()
Get active client connections
Definition: XmppServer.cs:789

Waher.Networking.XMPP.Server.XmppServer.UpdateCertificate
void UpdateCertificate(X509Certificate ServerCertificate)
Updates the server certificate
Definition: XmppServer.cs:906

Waher.Networking.XMPP.Server.XmppServer.S2sSniffers
CommunicationLayer S2sSniffers
Sniffers for XMPP S2S communication.
Definition: XmppServer.cs:650

Waher.Networking.XMPP.Server.XmppServer.GetServerConnectionStatistics
S2sEndpointStatistics[] GetServerConnectionStatistics()
Gets S2S connection statistics.
Definition: XmppServer.cs:845

Waher.Networking.XMPP.Server.XmppServer.TryGetClientConnection
bool TryGetClientConnection(string FullJID, out IClientConnection Connection)
Tries to get an active client connection.
Definition: XmppServer.cs:807

Waher.Networking.XMPP.Server.XmppServer.C2sSniffers
CommunicationLayer C2sSniffers
Sniffers for XMPP C2S communication.
Definition: XmppServer.cs:645

Waher.Networking.XMPP.Server.XmppServer.RegisterIqGetHandler
void RegisterIqGetHandler(string LocalName, string Namespace, EventHandlerAsync< IqEventArgs > Handler, bool PublishNamespaceAsFeature)
Registers an IQ-Get handler.
Definition: XmppServer.cs:1647

Waher.Networking.XMPP.Server.XmppServer.TryGetS2sEndpoint
bool TryGetS2sEndpoint(string RemoteDomain, out IS2SEndpoint Endpoint)
Tries to get a server-to-server connection state object.
Definition: XmppServer.cs:2259

Waher.Networking.XMPP.Server.XmppServer.Dispose
void Dispose()
IDisposable.Dispose
Definition: XmppServer.cs:947

Waher.Networking.XMPP.Server.XmppServer.Create
static Task< XmppServer > Create(CaseInsensitiveString Domain, CaseInsensitiveString[] AlternativeDomains, X509Certificate ServerCertificate, bool EncryptionRequired, IXmppServerPersistenceLayer PersistenceLayer)
Creates an instance of an XMPP server.
Definition: XmppServer.cs:316

Waher.Networking.XMPP.Server.XmppServer.GetCommunicationStatisticsSinceLast
Statistics.CommunicationStatistics GetCommunicationStatisticsSinceLast()
Gets communication statistics since last call.
Definition: XmppServer.cs:5198

Waher.Networking.XMPP.Server.XmppServer.DelayedDeliveryNamespace
const string DelayedDeliveryNamespace
urn:xmpp:delay (XEP-0203)
Definition: XmppServer.cs:188

Waher.Networking.XMPP.Server.XmppServer.SendMailMessage
async Task< bool > SendMailMessage(CaseInsensitiveString From, CaseInsensitiveString To, string Subject, string Markdown)
Sends a mail message
Definition: XmppServer.cs:6204

Waher.Networking.XMPP.Server.XmppServer.DeleteOldMailContent
async Task< int > DeleteOldMailContent(DateTime OlderThan)
Deletes old mail content.
Definition: XmppServer.cs:6187

Waher.Persistence.CaseInsensitiveString
Represents a case-insensitive string.
Definition: CaseInsensitiveString.cs:10

Waher.Persistence.CaseInsensitiveString.Value
string Value
String-representation of the case-insensitive string. (Representation is case sensitive....
Definition: CaseInsensitiveString.cs:27

Waher.Persistence.CaseInsensitiveString.Empty
static readonly CaseInsensitiveString Empty
Empty case-insensitive string
Definition: CaseInsensitiveString.cs:304

Waher.Persistence.CaseInsensitiveString.IsNullOrEmpty
static bool IsNullOrEmpty(CaseInsensitiveString value)
Indicates whether the specified string is null or an CaseInsensitiveString.Empty string.
Definition: CaseInsensitiveString.cs:1029

Waher.Persistence.CaseInsensitiveString.CopyTo
void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
Copies a specified number of characters from a specified position in this instance to a specified pos...
Definition: CaseInsensitiveString.cs:1228

Waher.Persistence.CaseInsensitiveString.Remove
CaseInsensitiveString Remove(int startIndex)
Returns a new string in which all the characters in the current instance, beginning at a specified po...
Definition: CaseInsensitiveString.cs:2186

Waher.Persistence.CaseInsensitiveString.Substring
CaseInsensitiveString Substring(int startIndex, int length)
Retrieves a substring from this instance. The substring starts at a specified character position and ...
Definition: CaseInsensitiveString.cs:2561

Waher.Persistence.Database
Static interface for database persistence. In order to work, a database provider has to be assigned t...
Definition: Database.cs:19

Waher.Persistence.Database.EndBulk
static Task EndBulk()
Ends bulk-processing of data. Must be called once for every call to StartBulk.
Definition: Database.cs:1494

Waher.Persistence.Database.InsertLazy
static async Task InsertLazy(object Object)
Inserts an object into the database, if unlocked. If locked, object will be inserted at next opportun...
Definition: Database.cs:156

Waher.Persistence.Database.StartBulk
static Task StartBulk()
Starts bulk-proccessing of data. Must be followed by a call to EndBulk.
Definition: Database.cs:1486

Waher.Persistence.Database.Update
static async Task Update(object Object)
Updates an object in the database.
Definition: Database.cs:626

Waher.Persistence.Database.Delete
static async Task Delete(object Object)
Deletes an object in the database.
Definition: Database.cs:717

Waher.Persistence.Database.Find
static Task< IEnumerable< object > > Find(string Collection, params string[] SortOrder)
Finds objects in a given collection.
Definition: Database.cs:247

Waher.Persistence.Database.Insert
static async Task Insert(object Object)
Inserts an object into the default collection of the database.
Definition: Database.cs:95

Waher.Persistence.Database.Clear
static async Task Clear(string CollectionName)
Clears a collection of all objects.
Definition: Database.cs:1206

Waher.Persistence.Filters.FilterAnd
This filter selects objects that conform to all child-filters provided.
Definition: FilterAnd.cs:10

Waher.Persistence.Filters.FilterFieldEqualTo
This filter selects objects that have a named field equal to a given value.
Definition: FilterFieldEqualTo.cs:7

Waher.Persistence.Filters.FilterFieldLesserOrEqualTo
This filter selects objects that have a named field lesser or equal to a given value.
Definition: FilterFieldLesserOrEqualTo.cs:9

Waher.Persistence.FullTextSearch.FullTextSearchModule
Full-text search module, controlling the life-cycle of the full-text-search engine.
Definition: FullTextSearchModule.cs:29

Waher.Persistence.FullTextSearch.FullTextSearchModule.Tokenize
static async Task< TokenCount[]> Tokenize(IEnumerable< object > Objects)
Tokenizes a set of objects using available tokenizers. Tokenizers are classes with a default contruct...
Definition: FullTextSearchModule.cs:1416

Waher.Persistence.FullTextSearch.Search
Static class for access to Full-Text-Search
Definition: Search.cs:68

Waher.Persistence.FullTextSearch.Search.RegisterStopWords
static void RegisterStopWords(params string[] StopWords)
Registers stop-words with the search-engine. Stop-words are ignored in searches.
Definition: Search.cs:197

Waher.Persistence.FullTextSearch.Tokenizers.TokenizationProcess
Contains information about a tokenization process.
Definition: TokenizationProcess.cs:10

Waher.Runtime.Cache.Cache
Implements an in-memory cache.
Definition: Cache.cs:15

Waher.Runtime.Cache.Cache.ContainsKey
bool ContainsKey(KeyType Key)
Checks if a key is available in the cache.
Definition: Cache.cs:296

Waher.Runtime.Cache.Cache.Dispose
void Dispose()
IDisposable.Dispose
Definition: Cache.cs:74

Waher.Runtime.Cache.Cache.TryGetValue
bool TryGetValue(KeyType Key, out ValueType Value)
Tries to get a value from the cache.
Definition: Cache.cs:203

Waher.Runtime.Cache.Cache.Add
void Add(KeyType Key, ValueType Value)
Adds an item to the cache.
Definition: Cache.cs:338

Waher.Runtime.Cache.CacheItemEventArgs
Event arguments for cache item removal events.
Definition: CacheItemEventArgs.cs:50

Waher.Runtime.Cache.CacheItemEventArgs.Value
ValueType Value
Value of item that was removed.
Definition: CacheItemEventArgs.cs:70

Waher.Runtime.Inventory.Types
Static class that dynamically manages types and interfaces available in the runtime environment.
Definition: Types.cs:14

Waher.Runtime.Inventory.Types.SetModuleParameter
static void SetModuleParameter(string Name, object Value)
Sets a module parameter. This parameter value will be accessible to modules when they are loaded.
Definition: Types.cs:560

Waher.Runtime.Inventory.Types.GetType
static Type GetType(string FullName)
Gets a type, given its full name.
Definition: Types.cs:41

Waher.Runtime.Inventory.Types.TryGetModuleParameter
static bool TryGetModuleParameter(string Name, out object Value)
Tries to get a module parameter value.
Definition: Types.cs:583

Waher.Runtime.Inventory.Types.Assemblies
static Assembly[] Assemblies
Assemblies in the inventory.
Definition: Types.cs:884

Waher.Runtime.Inventory.Types.NoParameters
static object[] NoParameters
Contains an empty array of parameter values.
Definition: Types.cs:548

Waher.Runtime.Inventory.Types.Instantiate
static object Instantiate(Type Type, params object[] Arguments)
Returns an instance of the type Type . If one needs to be created, it is. If the constructor requires...
Definition: Types.cs:1353

Waher.Runtime.Inventory.Types.GetTypesImplementingInterface
static Type[] GetTypesImplementingInterface(string InterfaceFullName)
Gets all types implementing a given interface.
Definition: Types.cs:84

Waher.Runtime.ServiceRegistration.ServiceRegistrationClient
XMPP-based Service Registration Client.
Definition: ServiceRegistrationClient.cs:18

Waher.Runtime.ServiceRegistration.ServiceRegistrationClient.CheckRegistration
async Task CheckRegistration(params Annotation[] Annotations)
Checks if the software needs to be registered.
Definition: ServiceRegistrationClient.cs:51

Waher.Runtime.Settings.RuntimeSettings
Static class managing persistent settings.
Definition: RuntimeSettings.cs:17

Waher.Runtime.Settings.RuntimeSettings.GetAsync
static async Task< string > GetAsync(string Key, string DefaultValue)
Gets a string-valued setting.
Definition: RuntimeSettings.cs:37

Waher.Runtime.Settings.RuntimeSettings.SetAsync
static async Task< bool > SetAsync(string Key, string Value)
Sets a string-valued setting.
Definition: RuntimeSettings.cs:70

Waher.Runtime.Temporary.TemporaryFile
Class managing the contents of a temporary file. When the class is disposed, the temporary file is de...
Definition: TemporaryFile.cs:11

Waher.Runtime.Temporary.TemporaryFile.Dispose
override void Dispose(bool disposing)
Disposes of the object, and deletes the temporary file.
Definition: TemporaryFile.cs:65

Waher.Runtime.Temporary.TemporaryFile.FileName
string FileName
File Name.
Definition: TemporaryFile.cs:51

Waher.Script.Abstraction.Elements.Element
Base class for all types of elements.
Definition: Element.cs:13

Waher.Script.Exceptions.ScriptReturnValueException
Script runtime exception.
Definition: ScriptReturnValueException.cs:10

Waher.Script.Exceptions.ScriptReturnValueException.ReturnValue
IElement ReturnValue
Return value.
Definition: ScriptReturnValueException.cs:26

Waher.Script.Expression
Class managing a script expression.
Definition: Expression.cs:39

Waher.Script.Expression.Root
ScriptNode Root
Root script node.
Definition: Expression.cs:4299

Waher.Script.Expression.EvaluateAsync
async Task< object > EvaluateAsync(Variables Variables)
Evaluates the expression, using the variables provided in the Variables  collection....
Definition: Expression.cs:4275

Waher.Script.Expression.ToString
static string ToString(double Value)
Converts a value to a string, that can be parsed as part of an expression.
Definition: Expression.cs:4496

Waher.Script.Graphs.Graph
Base class for graphs.
Definition: Graph.cs:79

Waher.Script.Objects.Matrices.ObjectMatrix
Object-valued matrix.
Definition: ObjectMatrix.cs:17

Waher.Script.Objects.Namespace
Namespace.
Definition: Namespace.cs:13

Waher.Script.Objects.ObjectValue
Object value.
Definition: ObjectValue.cs:12

Waher.Script.Operators.Matrices.ToMatrix
To-Matrix operator.
Definition: ToMatrix.cs:13

Waher.Script.Operators.Matrices.ToMatrix.ToMatrix
ToMatrix(ScriptNode Operand, bool NullCheck, int Start, int Length, Expression Expression)
To-Matrix operator.
Definition: ToMatrix.cs:22

Waher.Script.PreviewEventArgs
Event arguments for preview events.
Definition: PreviewEventArgs.cs:18

Waher.Script.PreviewEventArgs.Preview
IElement Preview
Preview of result.
Definition: PreviewEventArgs.cs:49

Waher.Script.Variable
Contains information about a variable.
Definition: Variable.cs:10

Waher.Script.Variables
Collection of variables.
Definition: Variables.cs:25

Waher.Script.Variables.Add
virtual Variable Add(string Name, object Value)
Adds a variable to the collection.
Definition: Variables.cs:122

Waher.Script.Variables.TryGetVariable
virtual bool TryGetVariable(string Name, out Variable Variable)
Tries to get a variable object, given its name.
Definition: Variables.cs:52

Waher.Security.EllipticCurves.Edwards448
Edwards448 Elliptic Curve, as defined in RFC7748 and RFC8032: https://tools.ietf.org/html/rfc7748 htt...
Definition: Edwards448.cs:17

Waher.Security.Hashes
Contains methods for simple hash calculations.
Definition: Hashes.cs:59

Waher.Security.Hashes.ComputeSHA256HashString
static string ComputeSHA256HashString(byte[] Data)
Computes the SHA-256 hash of a block of binary data.
Definition: Hashes.cs:328

Waher.Security.Hashes.BinaryToString
static string BinaryToString(byte[] Data)
Converts an array of bytes to a string with their hexadecimal representations (in lower case).
Definition: Hashes.cs:65

Waher.Security.JWT.JwtAuthentication
Use JWT tokens for authentication. The Bearer scheme defined in RFC 6750 is used: https://tools....
Definition: JwtAuthentication.cs:14

Waher.Security.JWT.JwtAuthentication.GetAccessToken
static string GetAccessToken(HttpRequest Request)
Gets the access token from an HTTP request.
Definition: JwtAuthentication.cs:112

Waher.Security.JWT.JwtClaims
Static class containing predefined JWT claim names.
Definition: JwtClaims.cs:10

Waher.Security.JWT.JwtClaims.Issuer
const string Issuer
Issuer of the JWT
Definition: JwtClaims.cs:14

Waher.Security.JWT.JwtClaims.IssueTime
const string IssueTime
Time at which the JWT was issued; can be used to determine age of the JWT
Definition: JwtClaims.cs:39

Waher.Security.JWT.JwtClaims.JwtId
const string JwtId
Unique identifier; can be used to prevent the JWT from being replayed (allows a token to be used only...
Definition: JwtClaims.cs:44

Waher.Security.JWT.JwtClaims.Subject
const string Subject
Subject of the JWT (the user)
Definition: JwtClaims.cs:19

Waher.Security.JWT.JwtClaims.ExpirationTime
const string ExpirationTime
Time after which the JWT expires
Definition: JwtClaims.cs:29

Waher.Security.JWT.JwtFactory
A factory that can create and validate JWT tokens.
Definition: JwtFactory.cs:53

Waher.Security.JWT.JwtFactory.IsValid
bool IsValid(JwtToken Token)
Checks if a token is valid and signed by the factory.
Definition: JwtFactory.cs:176

Waher.Security.JWT.JwtFactory.CreateHmacSha256
static JwtFactory CreateHmacSha256()
Creates a JWT factory that can create and validate JWT tokens using the HMAC-SHA256 algorithm.
Definition: JwtFactory.cs:92

Waher.Security.JWT.JwtFactory.Create
string Create(params KeyValuePair< string, object >[] Claims)
Creates a new JWT token.
Definition: JwtFactory.cs:248

Waher.Security.JWT.JwtFactory.Dispose
void Dispose()
IDisposable.Dispose
Definition: JwtFactory.cs:160

Waher.Security.JWT.JwtToken
Contains information about a Java Web Token (JWT). JWT is defined in RFC 7519: https://tools....
Definition: JwtToken.cs:21

Waher.Security.LoginMonitor.AnnotateEndpointEventArgs
Event arguments for endpoint annotation events.
Definition: AnnotateEndpointEventArgs.cs:11

Waher.Security.LoginMonitor.AnnotateEndpointEventArgs.AddTag
void AddTag(string Key, object Value)
Adds a tag to the list of tags.
Definition: AnnotateEndpointEventArgs.cs:43

Waher.Security.LoginMonitor.AnnotateEndpointEventArgs.RemoteEndpoint
string RemoteEndpoint
Remote endpoint.
Definition: AnnotateEndpointEventArgs.cs:27

Waher.Security.LoginMonitor.LoginAuditor
Class that monitors login events, and help applications determine malicious intent....
Definition: LoginAuditor.cs:26

Waher.Security.LoginMonitor.LoginAuditor.Success
static async void Success(string Message, string UserName, string RemoteEndpoint, string Protocol, params KeyValuePair< string, object >[] Tags)
Handles a successful login attempt.
Definition: LoginAuditor.cs:487

Waher.Security.LoginMonitor.LoginAuditor.Fail
static async void Fail(string Message, string UserName, string RemoteEndpoint, string Protocol, params KeyValuePair< string, object >[] Tags)
Handles a failed login attempt.
Definition: LoginAuditor.cs:452

Waher.Security.LoginMonitor.LoginAuditor.ProcessLoginFailure
async Task< bool > ProcessLoginFailure(string RemoteEndpoint, string Protocol, DateTime Timestamp, string Reason)
Processes a failed login attempt.
Definition: LoginAuditor.cs:242

Waher.Security.LoginMonitor.LoginAuditor.Annotate
static async Task< KeyValuePair< string, object >[]> Annotate(string RemoteEndpoint, params KeyValuePair< string, object >[] Tags)
Annotates a remote endpoint.
Definition: LoginAuditor.cs:401

Waher.Security.LoginMonitor.RemoteEndpoint
Login state information relating to a remote endpoint
Definition: RemoteEndpoint.cs:18

Waher.Security.SHA3.Keccak1600.ComputeVariable
byte[] ComputeVariable(byte[] N)
Computes the SPONGE function, as defined in section 4 of NIST FIPS 202.
Definition: Keccak1600.cs:412

Waher.Security.SHA3.SHAKE256
Implements the SHA3 SHAKE256 extendable-output functions, as defined in section 6....
Definition: SHAKE256.cs:13

Waher.Security.SPF.SpfExpression
Contains information about a SPF string.
Definition: SpfExpression.cs:11

Waher.Security.Users.User
Corresponds to a user in the system.
Definition: User.cs:21

Waher.Security.Users.User.UserName
string UserName
User Name
Definition: User.cs:53

Waher.Security.Users.User.HasPrivilege
bool HasPrivilege(string Privilege)
If the user has a given privilege.
Definition: User.cs:129

Waher.Security.Users.User.CreateToken
async Task< string > CreateToken(JwtFactory Factory, bool Encrypted)
Creates a JWT Token referencing the user object.
Definition: User.cs:261

Waher.Security.Users.Users
Maintains the collection of all users in the system.
Definition: Users.cs:24

Waher.Security.Users.Users.GetUser
static async Task< User > GetUser(string UserName, bool CreateIfNew)
Gets the User object corresponding to a User Name.
Definition: Users.cs:65

Waher.Service.IoTBroker.Admin.ChatState
State of a chat session
Definition: ChatState.cs:12

Waher.Service.IoTBroker.Admin.ChatState.Files
readonly Dictionary< string, FileInfo > Files
Currently accesible files
Definition: ChatState.cs:31

Waher.Service.IoTBroker.Admin.ChatState.Processes
readonly LinkedList< Process > Processes
Current processes related to session
Definition: ChatState.cs:36

Waher.Service.IoTBroker.Admin.ChatState.To
string To
Remote endpoint
Definition: ChatState.cs:16

Waher.Service.IoTBroker.Admin.ChatState.Folder
string Folder
Current folder
Definition: ChatState.cs:26

Waher.Service.IoTBroker.Admin.FileInfo
Information about a file accessible through admin command interface
Definition: FileInfo.cs:9

Waher.Service.IoTBroker.Admin.Muc.Enter
Asks the broker to enter a room.
Definition: Enter.cs:13

Waher.Service.IoTBroker.Admin.Muc.Enter.Execute
override async Task Execute(ChatState State, string[] Arguments, string OrgMessage, ResponseCallbackHandler ResponseCallback)
Executes the command.
Definition: Enter.cs:48

Waher.Service.IoTBroker.Admin.Muc.RoomInfo
Multi-User Chat Room information
Definition: RoomInfo.cs:7

Waher.Service.IoTBroker.Admin.Muc.RoomInfo.NickName
string NickName
Nick-name to use in room.
Definition: RoomInfo.cs:56

Waher.Service.IoTBroker.Admin.Muc.RoomInfo.RoomId
string RoomId
Room ID
Definition: RoomInfo.cs:46

Waher.Service.IoTBroker.Admin.Muc.RoomInfo.Permanent
bool Permanent
If room association should be persisted.
Definition: RoomInfo.cs:66

Waher.Service.IoTBroker.Admin.Muc.RoomInfo.Password
string Password
Password to use to enter room.
Definition: RoomInfo.cs:61

Waher.Service.IoTBroker.Admin.Muc.RoomInfo.Domain
string Domain
Domain
Definition: RoomInfo.cs:51

Waher.Service.IoTBroker.Admin.Muc.Rooms
Lists rooms currently entered by the neuron.
Definition: Rooms.cs:11

Waher.Service.IoTBroker.Admin.Muc.ScriptConsolidator
Consolidates responses from occupants in a MUC room.
Definition: ScriptConsolidator.cs:22

Waher.Service.IoTBroker.BrokerPackage
Identity of the IoT Broker package.
Definition: BrokerPackage.cs:7

Waher.Service.IoTBroker.BrokerPackage.Key
const string Key
Key for decrypting the contents of the package.
Definition: BrokerPackage.cs:16

Waher.Service.IoTBroker.BrokerPackage.FileName
const string FileName
IoTBroker.package
Definition: BrokerPackage.cs:11

Waher.Service.IoTBroker.DataStorage.Account
Contains information about a broker account.
Definition: Account.cs:28

Waher.Service.IoTBroker.DataStorage.ApiKey
Definition: ApiKey.cs:14

Waher.Service.IoTBroker.DataStorage.Avatar
Definition: Avatar.cs:12

Waher.Service.IoTBroker.DataStorage.IP4Localization
Definition: IP4Localization.cs:10

Waher.Service.IoTBroker.DataStorage.PersistenceLayer
Definition: PersistenceLayer.cs:30

Waher.Service.IoTBroker.DataStorage.PersistenceLayer.GetRosterItem
async Task< IRosterItem > GetRosterItem(CaseInsensitiveString UserName, CaseInsensitiveString Jid)
Gets a roster item for an account.
Definition: PersistenceLayer.cs:586

Waher.Service.IoTBroker.DataStorage.PersistenceLayer.DeleteOfflineMessages
async Task DeleteOfflineMessages(IEnumerable< IOfflineMessage > Messages)
Deletes offline messages.
Definition: PersistenceLayer.cs:1454

Waher.Service.IoTBroker.DataStorage.PersistenceLayer.GetRoster
async Task< IEnumerable< IRosterItem > > GetRoster(CaseInsensitiveString UserName)
Gets the roster of an account.
Definition: PersistenceLayer.cs:536

Waher.Service.IoTBroker.DataStorage.RosterItem
Definition: RosterItem.cs:12

Waher.Service.IoTBroker.EDaler.EDalerComponent
Manages eDaler on accounts connected to the broker.
Definition: EDalerComponent.cs:34

Waher.Service.IoTBroker.EDaler.EDalerComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: EDalerComponent.cs:77

Waher.Service.IoTBroker.Encodings.CodePages
Definition: CodePages.cs:7

Waher.Service.IoTBroker.Events.EventLogComponent
Event log component, as defined in XEP-0337. https://xmpp.org/extensions/xep-0337....
Definition: EventLogComponent.cs:22

Waher.Service.IoTBroker.Events.EventLogComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: EventLogComponent.cs:57

Waher.Service.IoTBroker.HttpX.HttpxServer
HTTPX server.
Definition: HttpxServer.cs:22

Waher.Service.IoTBroker.HttpX.HttpxServer.Dispose
void Dispose()
IDisposable.Dispose
Definition: HttpxServer.cs:49

Waher.Service.IoTBroker.Legal.LegalComponent
Provisioning and registry service component.
Definition: LegalComponent.cs:55

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceSmartContractsNeuroFoundationV1
const string NamespaceSmartContractsNeuroFoundationV1
urn:nf:iot:leg:sc:1.0
Definition: LegalComponent.cs:83

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceLegalIdentityIeeeV1
const string NamespaceLegalIdentityIeeeV1
urn:ieee:iot:leg:id:1.0
Definition: LegalComponent.cs:59

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceLegalIdentityNeuroFoundationV1
const string NamespaceLegalIdentityNeuroFoundationV1
urn:nf:iot:leg:id:1.0
Definition: LegalComponent.cs:64

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceE2ENeuroFoundationV1
const string NamespaceE2ENeuroFoundationV1
urn:nf:iot:e2e:1.0
Definition: LegalComponent.cs:102

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceSmartContractsIeeeV1
const string NamespaceSmartContractsIeeeV1
urn:ieee:iot:leg:sc:1.0
Definition: LegalComponent.cs:78

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceE2EIeeeV1
const string NamespaceE2EIeeeV1
urn:ieee:iot:e2e:1.0
Definition: LegalComponent.cs:97

Waher.Service.IoTBroker.Legal.LegalComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: LegalComponent.cs:294

Waher.Service.IoTBroker.Legal.MFA.MultiFactorAuthentication
Web resource that allows calling applications to enable Multi-Factor Authentication using legal ident...
Definition: MultiFactorAuthentication.cs:17

Waher.Service.IoTBroker.Legal.MFA.QuickLogin
Web resource that allows calling applications to enable Quick-Login using legal identities.
Definition: QuickLogin.cs:33

Waher.Service.IoTBroker.Marketplace.MarketplaceProcessor
Marketplace processor, brokering sales of items via tenders and offers defined in smart contracts.
Definition: MarketplaceProcessor.cs:34

Waher.Service.IoTBroker.MultiUserChat.MultiUserChatComponent
Multi-User-Chat (MUC) Component component, as defined in XEP-0045. https://xmpp.org/extensions/xep-00...
Definition: MultiUserChatComponent.cs:27

Waher.Service.IoTBroker.MultiUserChat.MultiUserChatComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: MultiUserChatComponent.cs:92

Waher.Service.IoTBroker.NeuroFeatures.Token
Neuro-Feature Token
Definition: Token.cs:60

Waher.Service.IoTBroker.NeuroFeatures.WebServices.AddNote
Adds an external note to a token.
Definition: AddNote.cs:20

Waher.Service.IoTBroker.Paiwise.PaiwiseProcessor
Paiwise processor, processing payment instructions defined in smart contracts.
Definition: PaiwiseProcessor.cs:35

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent
Provisioning and registry service component.
Definition: ProvisioningComponent.cs:52

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningOwnerIeeeV1
const string NamespaceProvisioningOwnerIeeeV1
urn:ieee:iot:prov:o:1.0
Definition: ProvisioningComponent.cs:76

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceSoftwareUpdatesNeuroFoundationV1
const string NamespaceSoftwareUpdatesNeuroFoundationV1
urn:nf:iot:swu:1.0
Definition: ProvisioningComponent.cs:106

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningTokenNeuroFoundationV1
const string NamespaceProvisioningTokenNeuroFoundationV1
urn:nf:iot:prov:t:1.0
Definition: ProvisioningComponent.cs:61

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceIoTDiscoveryNeuroFoundationV1
const string NamespaceIoTDiscoveryNeuroFoundationV1
urn:nf:iot:disco:1.0
Definition: ProvisioningComponent.cs:96

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningTokenIeeeV1
const string NamespaceProvisioningTokenIeeeV1
urn:ieee:iot:prov:t:1.0
Definition: ProvisioningComponent.cs:56

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningDeviceIeeeV1
const string NamespaceProvisioningDeviceIeeeV1
urn:ieee:iot:prov:d:1.0
Definition: ProvisioningComponent.cs:66

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceIoTDiscoveryIeeeV1
const string NamespaceIoTDiscoveryIeeeV1
urn:ieee:iot:disco:1.0
Definition: ProvisioningComponent.cs:91

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: ProvisioningComponent.cs:284

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceIoTDiscoveryXsfV0
const string NamespaceIoTDiscoveryXsfV0
urn:xmpp:iot:discovery
Definition: ProvisioningComponent.cs:86

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningOwnerNeuroFoundationV1
const string NamespaceProvisioningOwnerNeuroFoundationV1
urn:nf:iot:prov:o:1.0
Definition: ProvisioningComponent.cs:81

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceSoftwareUpdatesIeeeV1
const string NamespaceSoftwareUpdatesIeeeV1
urn:ieee:iot:swu:1.0
Definition: ProvisioningComponent.cs:101

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningDeviceNeuroFoundationV1
const string NamespaceProvisioningDeviceNeuroFoundationV1
urn:nf:iot:prov:d:1.0
Definition: ProvisioningComponent.cs:71

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package
Contains information about a software package.
Definition: Package.cs:18

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.PublicKey
byte[] PublicKey
Public key of issuer, used to create signature.
Definition: Package.cs:52

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Signature
byte[] Signature
Cryptographic signature of package, as calculated by the issuer of the package.
Definition: Package.cs:46

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Installed
DateTime Installed
When package was installed (if installed).
Definition: Package.cs:94

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.ContentOnly
bool ContentOnly
If package only contains content (i.e. no assemblies and executable files).
Definition: Package.cs:112

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.FileName
CaseInsensitiveString FileName
Filename of package.
Definition: Package.cs:40

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Published
DateTime Published
When package was published.
Definition: Package.cs:76

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Url
string Url
URL of package.
Definition: Package.cs:117

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.AesKey
byte[] AesKey
Symmetric cipher used to encrypt package file.
Definition: Package.cs:58

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Bytes
long Bytes
Number of bytes of package.
Definition: Package.cs:100

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Supersedes
DateTime Supersedes
Timestamp of superceded package.
Definition: Package.cs:82

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Created
DateTime Created
When package record was created
Definition: Package.cs:88

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.PackageUrlValidator
Definition: PackageUrlValidator.cs:10

Waher.Service.IoTBroker.PubSub.PubSubComponent
PubSub component, as defined in XEP-0060. https://xmpp.org/extensions/xep-0060.html
Definition: PubSubComponent.cs:33

Waher.Service.IoTBroker.PubSub.PubSubComponent.DeleteExpiredNodes
async Task<(int, int)> DeleteExpiredNodes()
Deletes expired nodes
Definition: PubSubComponent.cs:4564

Waher.Service.IoTBroker.PubSub.PubSubComponent.GetNodeAsync
async Task< PubSubNode > GetNodeAsync(CaseInsensitiveString Service, CaseInsensitiveString NodeName, NodeAccessModel? AutoCreateAccess, XmppAddress From, CaseInsensitiveString Domain)
Gets a pubsub node.
Definition: PubSubComponent.cs:502

Waher.Service.IoTBroker.PubSub.PubSubComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: PubSubComponent.cs:404

Waher.Service.IoTBroker.PubSub.PubSubComponent.Create
static async Task< PubSubComponent > Create(XmppServer Server, CaseInsensitiveString Subdomain, string Name)
Provisioning and registry service component.
Definition: PubSubComponent.cs:330

Waher.Service.IoTBroker.PubSub.PubSubNode
Defines a node on which items can be published.
Definition: PubSubNode.cs:19

Waher.Service.IoTBroker.PubSub.PubSubNode.Name
CaseInsensitiveString Name
Name of node.
Definition: PubSubNode.cs:113

Waher.Service.IoTBroker.PubSub.PubSubNode.PublishOnWeb
bool PublishOnWeb
If the items published to the node should be available on the web or not.
Definition: PubSubNode.cs:654

Waher.Service.IoTBroker.Sampling.Bucket
Statistical bucket
Definition: Bucket.cs:15

Waher.Service.IoTBroker.Sampling.Buckets
A collection of buckets
Definition: Buckets.cs:13

Waher.Service.IoTBroker.Sampling.Buckets.TryGetBucket
bool TryGetBucket(string Id, out Bucket Bucket)
Tries to get a bucket, given its ID.
Definition: Buckets.cs:187

Waher.Service.IoTBroker.Sampling.Buckets.Sample
async Task Sample(string Counter, double Value)
Samples a value
Definition: Buckets.cs:130

Waher.Service.IoTBroker.ServiceRegistrations.ServiceRegistrationComponent
Definition: ServiceRegistrationComponent.cs:14

Waher.Service.IoTBroker.ServiceRegistrations.ServiceRegistrationComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: ServiceRegistrationComponent.cs:27

Waher.Service.IoTBroker.Setup.RelayConfiguration
Provides the user configuration options regarding use of SMTP Relay server to send mail.
Definition: RelayConfiguration.cs:25

Waher.Service.IoTBroker.Setup.RelayConfiguration.Instance
static RelayConfiguration Instance
Current instance of configuration.
Definition: RelayConfiguration.cs:114

Waher.Service.IoTBroker.Setup.RelayConfiguration.ConfigureSystem
override Task ConfigureSystem()
Is called during startup to configure the system.
Definition: RelayConfiguration.cs:139

Waher.Service.IoTBroker.Sources.Connections.ConnectionsSource
Definition: ConnectionsSource.cs:16

Waher.Service.IoTBroker.Sources.GatewayConfig.FileFolder
Defines a file folder.
Definition: FileFolder.cs:14

Waher.Service.IoTBroker.Sources.GatewayConfig.GatewayConfigSource
Data source mirroring the Gateway.config file.
Definition: GatewayConfigSource.cs:28

Waher.Service.IoTBroker.Sources.GatewayConfig.Port
References a port number.
Definition: Port.cs:14

Waher.Service.IoTBroker.Sources.GatewayConfig.Ports
Root node of port numbers to use.
Definition: Ports.cs:11

Waher.Service.IoTBroker.Sources.GatewayConfig.ProxyResource
Defines a proxy resource to act as a reverse proxy.
Definition: ProxyResource.cs:16

Waher.Service.IoTBroker.Sources.GatewayConfig.ProxyResource.Encrypted
bool Encrypted
If forwarded requests are encrypted (HTTPS) or not (HTTP).
Definition: ProxyResource.cs:100

Waher.Service.IoTBroker.Sources.PersistedData.Commands.EventStatistic
Definition: EventStatistic.cs:11

Waher.Service.IoTBroker.Sources.PersistedData.EventLog
Definition: EventLog.cs:16

Waher.Service.IoTBroker.Sources.PersistedData.PersistedDataSource
Definition: PersistedDataSource.cs:12

Waher.Service.IoTBroker.Sources.ProgramData.ProgramDataSource
Data source mirroring the ProgramData folder for the broker.
Definition: ProgramDataSource.cs:20

Waher.Service.IoTBroker.Sources.Protocols.Commands.HttpStatistic
Definition: HttpStatistic.cs:11

Waher.Service.IoTBroker.Sources.Protocols.Commands.XmppStatistic
Definition: XmppStatistic.cs:11

Waher.Service.IoTBroker.Sources.Protocols.HttpProtocol
Definition: HttpProtocol.cs:18

Waher.Service.IoTBroker.Sources.Protocols.ProtocolsSource
Definition: ProtocolsSource.cs:12

Waher.Service.IoTBroker.Sources.Protocols.XmppProtocol
Definition: XmppProtocol.cs:13

Waher.Service.IoTBroker.StateMachines.StateMachineProcessor
State-Machine processor
Definition: StateMachineProcessor.cs:40

Waher.Service.IoTBroker.Synchronization.ClockSynchronization
Service helping services synchronize their clocks over the Internet.
Definition: ClockSynchronization.cs:14

Waher.Service.IoTBroker.Synchronization.ComponentSynchronization
Component that synchronizes content in the federated network, by sending synchronization messages and...
Definition: ComponentSynchronization.cs:15

Waher.Service.IoTBroker.Synchronization.DateTimeHF
Date and Time value based on the intenal high-frequency timer.
Definition: DateTimeHF.cs:10

Waher.Service.IoTBroker.Synchronization.DateTimeHF.Month
int Month
Month
Definition: DateTimeHF.cs:74

Waher.Service.IoTBroker.Synchronization.DateTimeHF.Hour
int Hour
Hour
Definition: DateTimeHF.cs:84

Waher.Service.IoTBroker.Synchronization.DateTimeHF.Second
int Second
Second
Definition: DateTimeHF.cs:94

Waher.Service.IoTBroker.Synchronization.DateTimeHF.Year
int Year
Year
Definition: DateTimeHF.cs:69

Waher.Service.IoTBroker.Synchronization.DateTimeHF.Minute
int Minute
Minute
Definition: DateTimeHF.cs:89

Waher.Service.IoTBroker.Synchronization.DateTimeHF.Day
int Day
Day
Definition: DateTimeHF.cs:79

Waher.Service.IoTBroker.WebServices.CreateAccount
Definition: CreateAccount.cs:11

Waher.Service.IoTBroker.WebServices.CreateApiKey
Definition: CreateApiKey.cs:17

Waher.Service.IoTBroker.WebServices.DeleteAccount
Definition: DeleteAccount.cs:9

Waher.Service.IoTBroker.WebServices.DeletePackage
Definition: DeletePackage.cs:12

Waher.Service.IoTBroker.WebServices.DeletePubSubNode
Definition: DeletePubSubNode.cs:11

Waher.Service.IoTBroker.WebServices.Feedback
Definition: Feedback.cs:14

Waher.Service.IoTBroker.WebServices.InstallPackage
Definition: InstallPackage.cs:14

Waher.Service.IoTBroker.WebServices.LegalIdentityStateChanged
Definition: LegalIdentityStateChanged.cs:15

Waher.Service.IoTBroker.WebServices.LoadMoreItems
Definition: LoadMoreItems.cs:13

Waher.Service.IoTBroker.WebServices.PublisherAvatar
Definition: PublisherAvatar.cs:14

Waher.Service.IoTBroker.WebServices.QR
Definition: QR.cs:16

Waher.Service.IoTBroker.WebServices.RequestAccount
Definition: RequestAccount.cs:13

Waher.Service.IoTBroker.WebServices.RequestApiKey
Definition: RequestApiKey.cs:13

Waher.Service.IoTBroker.WebServices.SearchEvents
Definition: SearchEvents.cs:16

Waher.Service.IoTBroker.WebServices.SendOperatorMessage
Definition: SendOperatorMessage.cs:17

Waher.Service.IoTBroker.WebServices.SetContractState
Definition: SetContractState.cs:20

Waher.Service.IoTBroker.WebServices.UninstallPackage
Definition: UninstallPackage.cs:13

Waher.Service.IoTBroker.WebServices.UpdateAccount
Definition: UpdateAccount.cs:12

Waher.Service.IoTBroker.WebServices.UpdateApiKey
Definition: UpdateApiKey.cs:12

Waher.Service.IoTBroker.WebServices.UpdatePubSubNode
Definition: UpdatePubSubNode.cs:12

Waher.Service.IoTBroker.WebServices.UploadPackage
Definition: UploadPackage.cs:14

Waher.Service.IoTBroker.WebServices.UploadSignature
Definition: UploadSignature.cs:18

Waher.Service.IoTBroker.WebServices.ValidateContract
Definition: ValidateContract.cs:15

Waher.Service.IoTBroker.WebServices.ValidateLegalId
Definition: ValidateLegalId.cs:12

Waher.Service.IoTBroker.WebServices.WebHostMetaDataJson
Web Host Meta Data in JSON format, as defined in XEP-0156 and RFC 6415: https://xmpp....
Definition: WebHostMetaDataJson.cs:16

Waher.Service.IoTBroker.WebServices.WebHostMetaDataXml
Web Host Meta Data in XML format, as defined in XEP-0156 and RFC 6415: https://xmpp....
Definition: WebHostMetaDataXml.cs:16

Waher.Service.IoTBroker.WebServices.WebNode
Definition: WebNode.cs:21

Waher.Service.IoTBroker.WebServices.WhatsMyEndpointResource
Provides IP information about the caller.
Definition: WhatsMyEndpointResource.cs:12

Waher.Service.IoTBroker.WebServices.XmppOverHttp
Allows senders to send XMPP stanzas over HTTP POST.
Definition: XmppOverHttp.cs:20

Waher.Service.IoTBroker.XmppServerModule
Service Module hosting the XMPP broker and its components.
Definition: XmppServerModule.cs:109

Waher.Service.IoTBroker.XmppServerModule.SendMailMessage
static Task< bool > SendMailMessage(string To, string Subject, string Markdown)
Sends a mail message
Definition: XmppServerModule.cs:4680

Waher.Service.IoTBroker.XmppServerModule.NamespaceSynchronizationNeuroFoundationV1
const string NamespaceSynchronizationNeuroFoundationV1
urn:nf:iot:synchronization:1.0
Definition: XmppServerModule.cs:118

Waher.Service.IoTBroker.XmppServerModule.NamespaceSynchronizationIeeeV1
const string NamespaceSynchronizationIeeeV1
urn:ieee:iot:synchronization:1.0
Definition: XmppServerModule.cs:113

Waher.Service.IoTBroker.XmppServerModule.NamespaceDnsOverXmpp
const string NamespaceDnsOverXmpp
urn:xmpp:dox:0
Definition: XmppServerModule.cs:123

Waher.Service.IoTBroker.XmppServerModule.Stop
async Task Stop()
Stops the module.
Definition: XmppServerModule.cs:1407

Waher.Service.IoTBroker.XmppServerModule.Calibrate
static void Calibrate()
Calibrates the internal clock with the high frequency timer.
Definition: XmppServerModule.cs:1757

Waher.Service.IoTBroker.XmppServerModule.Start
async Task Start()
Starts the module.
Definition: XmppServerModule.cs:278

Waher.Service.IoTBroker.XmppServerModule.SendMailMessage
static Task< bool > SendMailMessage(string To, string Subject, string Markdown, params EmbeddedContent[] Attachments)
Sends a mail message
Definition: XmppServerModule.cs:4692

Waher.Service.IoTBroker.XmppServerModule.AppendRemoteEndpointToTable
static async Task AppendRemoteEndpointToTable(StringBuilder Markdown, string RemoteEndpoint)
Appends annotated information about a remote endpoint to a Markdown table.
Definition: XmppServerModule.cs:1263

Waher.Service.IoTBroker.XmppServerModule.SendMailMessage
static async Task< bool > SendMailMessage(string SmtpHost, int SmtpPort, string UserName, string Password, string From, string To, string Subject, string Markdown, params EmbeddedContent[] Attachments)
Sends a mail message
Definition: XmppServerModule.cs:4778

Waher.Service.IoTBroker.XmppServerModule.NamespaceJwt
const string NamespaceJwt
urn:xmpp:jwt:0
Definition: XmppServerModule.cs:128

Waher.Service.IoTBroker.XmppServerModule.NamespaceSynchronization
static string NamespaceSynchronization(NamespaceSet Version)
Returns the namespace for IoT Clock Synchronization.
Definition: XmppServerModule.cs:136

Waher.Service.IoTBroker.XmppServerModule.GetVersion
static NamespaceSet GetVersion(string Namespace)
Gets the namespace set version corresponding to a given a namespace.
Definition: XmppServerModule.cs:152

Waher.Service.IoTBroker.XmppServerModule.AuthenticateJwtToken
bool AuthenticateJwtToken(JwtToken Token, out Reason Reason)
Validates a JWT token against the JWT factory defined for the XMPP Server.
Definition: XmppServerModule.cs:5121

Waher.Service.IoTBroker.XmppServerModule.SendMailMessage
static Task< bool > SendMailMessage(string SmtpHost, int SmtpPort, string UserName, string Password, string From, string To, string Subject, string Markdown)
Sends a mail message
Definition: XmppServerModule.cs:4759

Waher.Service.IoTBroker.XmppServerModule.FindIpAddress
static Task< IP4Localization > FindIpAddress(string RemoteEndpoint)
Finds locale information about an IP Address.
Definition: XmppServerModule.cs:1210

Waher.Service.IoTBroker.XmppServerModule.Now
static DateTimeHF Now
Current high-resolution date and time
Definition: XmppServerModule.cs:1790

Waher.Service.IoTBroker.XmppServerModule.SendMailMessage
static Task< bool > SendMailMessage(string From, string To, string Subject, string Markdown)
Sends a mail message
Definition: XmppServerModule.cs:4712

Waher.Service.IoTBroker.XmppServerModule.VerifyRecaptcha
static bool VerifyRecaptcha(object Posted, string RemoteEndpoint)
Method that can be used by web pages to verify Recaptcha responses.
Definition: XmppServerModule.cs:4663

Waher.Service.IoTBroker.XmppServerModule.SendMailMessage
static Task< bool > SendMailMessage(string From, string To, string Subject, string Markdown, params EmbeddedContent[] Attachments)
Sends a mail message
Definition: XmppServerModule.cs:4725

Waher.Service.IoTBroker.XmppServerModule.FindIpAddress
static async Task< IP4Localization > FindIpAddress(IPAddress Addr)
Finds locale information about an IP Address.
Definition: XmppServerModule.cs:1227

Waher.Content.Markdown.Consolidation.IConsolidator
Interface for consolidators.
Definition: IConsolidator.cs:11

Waher.Events.IObservableLayer.Information
Task Information(string Comment)
Called to inform the viewer of something.

Waher.Events.IObservableLayer.Warning
Task Warning(string Warning)
Called to inform the viewer of a warning state.

Waher.Networking.ICommunicationLayer
Interface for observable classes implementing communication protocols.
Definition: ICommunicationLayer.cs:13

Waher.Networking.XMPP.Server.IAccount
Interface for XMPP user accounts.
Definition: IAccount.cs:9

Waher.Networking.XMPP.Server.IClientConnection
Interface for client connections.
Definition: IClientConnection.cs:13

Waher.Networking.XMPP.Server.IRecipient
Interface for recipients of stanzas.
Definition: IRecipient.cs:9

Waher.Networking.XMPP.Server.IS2SEndpoint
Interface for XMPP S2S endpoints
Definition: IS2sEndpoint.cs:10

Waher.Networking.XMPP.Server.IXmppServerPersistenceLayer
Interface for XMPP Server persistence layers. The persistence layer should implement caching.
Definition: IXmppServerPersistenceLayer.cs:35

Waher.Runtime.Inventory.IModule
Interface for late-bound modules loaded at runtime.
Definition: IModule.cs:9

Waher.Script.Abstraction.Elements.IElement
Basic interface for all types of elements.
Definition: IElement.cs:20

Waher.Script.Abstraction.Elements.IElement.AssociatedObjectValue
object AssociatedObjectValue
Associated object value.
Definition: IElement.cs:33

Waher.Script.Operators.Matrices.IToMatrix
Interface for objects that can be converted into matrices.
Definition: IToMatrix.cs:9

Waher.Security.IUser
Basic interface for a user.
Definition: IUser.cs:7

Waher.Security.JWT.IUserWithClaims
A User that can participate in distributed operations, where the user is identified using a JWT token...
Definition: IUserWithClaims.cs:10

Waher.Service.IoTBroker.Admin.IAdminCommand
Basic interface for administration commands
Definition: IAdminCommand.cs:17

Waher.Service.IoTBroker.Admin.IAdminCommand.AppliesTo
bool AppliesTo(string CommandLine, string[] Arguments, out object Details)
If the command is applicable to the given command line.

Waher.Things.INode
Interface for nodes that are published through the concentrator interface.
Definition: INode.cs:49

EDaler
Definition: AccountEvent.cs:11

NeuroFeatures
Definition: CreationAttributesEventArgs.cs:5

Waher.Content.Emoji
Definition: LocalEmojiFiles.cs:13

Waher.Content.Html.Css
Definition: CssCodec.cs:8

Waher.Content.Html.JavaScript
Definition: JavascriptCodec.cs:8

Waher.Content.Html
Definition: CDATA.cs:7

Waher.Content.Markdown.Consolidation
Definition: ConsolidatedTable.cs:11

Waher.Content.Markdown.Model
Definition: Atom.cs:6

Waher.Content.Markdown
Definition: ConsolidatedTable.cs:11

Waher.Content.Multipart
Definition: AlternativeCodec.cs:8

Waher.Content.SystemFiles
Definition: FileSystem.cs:7

Waher.Content.Text
Definition: CsvCodec.cs:9

Waher.Content.Xml
Definition: XmlCodec.cs:11

Waher.Content.Xsl
Definition: Transform.cs:13

Waher.Content
Definition: Array.cs:6

Waher.Events.Statistics
Definition: EventStatistics.cs:5

Waher.Events
Definition: ConsoleEventSink.cs:8

Waher.IoTGateway.ScriptExtensions.Constants
Definition: Domain.cs:8

Waher.IoTGateway.Setup
Definition: AlternativeField.cs:4

Waher.IoTGateway.WebResources
Definition: DeleteExport.cs:10

Waher.IoTGateway
Definition: App.xaml.cs:23

Waher.Networking.DNS.Communication
Definition: DnsClient.cs:16

Waher.Networking.DNS.HTTPS
Definition: DnsOverHttpsResource.cs:9

Waher.Networking.DNS
Definition: DnsClient.cs:16

Waher.Networking.HTTP
Definition: Page.cs:6

Waher.Networking.HTTP.HostDomainOptions
HostDomainOptions
Options on how to handle domain names provided in the Host header.
Definition: HttpFolderResource.cs:18

Waher.Networking.SMTP.Server
Definition: ClientConnectionEventArgs.cs:4

Waher.Networking.Sniffers
Definition: ConsoleErrorSniffer.cs:4

Waher.Networking.Sniffers.BinaryPresentationMethod
BinaryPresentationMethod
How binary data is to be presented.
Definition: ConsoleOutSniffer.cs:12

Waher.Networking.XMPP.Concentrator
Definition: ConcentratorClient.cs:20

Waher.Networking.XMPP.P2P.SOCKS5.Command
Command
SOCKS5 command.
Definition: Command.cs:7

Waher.Networking.XMPP.Server.BOSH
Definition: BoshSession.cs:19

Waher.Networking.XMPP.Server.HttpFileUpload
Definition: FileInfo.cs:4

Waher.Networking.XMPP.Server.SOCKS5
Definition: Socks5Component.cs:10

Waher.Networking.XMPP.Server.Statistics
Definition: CommunicationStatistics.cs:6

Waher.Networking.XMPP.Server.WS
Definition: WebSocketClientResource.cs:11

Waher.Networking.XMPP.Server
Definition: AccountRecipient.cs:5

Waher.Networking
Definition: Page.cs:6

Waher.Persistence.Filters
Definition: Filter.cs:2

Waher.Persistence.FullTextSearch.Tokenizers
Definition: CaseInsensitiveStringCollectionTokenizer.cs:8

Waher.Persistence.FullTextSearch
Definition: CollectionInformation.cs:5

Waher.Persistence
Definition: Bookmark.cs:4

Waher.Runtime.Cache
Definition: Cache.cs:8

Waher.Runtime.Inventory
Definition: TypesLoader.cs:9

Waher.Runtime.ServiceRegistration
Definition: Annotation.cs:6

Waher.Runtime.Settings
Definition: EnvironmentSettings.cs:7

Waher.Runtime.Temporary
Definition: TemporaryFile.cs:6

Waher.Script.Abstraction.Elements
Definition: AbelianGroupElement.cs:5

Waher.Script.Exceptions
Definition: ScriptAbortedException.cs:4

Waher.Script.Graphs
Definition: CanvasGraph.cs:11

Waher.Script.Objects.Matrices
Definition: BooleanMatrices.cs:6

Waher.Script.Objects
Definition: BooleanValue.cs:7

Waher.Script.Operators.Matrices
Definition: ColumnVector.cs:10

Waher.Script
Definition: Duration.cs:8

Waher.Security.DTLS.ContentType
ContentType
DTLS Record content type.
Definition: Enumerations.cs:11

Waher.Security.EllipticCurves
Definition: Curve25519.cs:7

Waher.Security.JWT
Definition: ExternalUser.cs:5

Waher.Security.JWT.Reason
Reason
Reason a token is not valid.
Definition: JwtFactory.cs:12

Waher.Security.LoginMonitor
Definition: AnnotateEndpointEventArgs.cs:6

Waher.Security.SHA3
Definition: Keccak1600.cs:6

Waher.Security.SPF
Definition: A.cs:8

Waher.Security.Users
Definition: LoginResult.cs:4

Waher.Security
Definition: AcmeAccount.cs:8

Waher.Service.IoTBroker.Admin.Muc
Definition: Enter.cs:8

Waher.Service.IoTBroker.Admin
Definition: CreateAccount.cs:10

Waher.Service.IoTBroker.Admin.ResponseCallbackHandler
delegate Task< string > ResponseCallbackHandler(string Markdown, string MessageId)
Delegate for response callback handler methods.

Waher.Service.IoTBroker.DataStorage
Definition: Account.cs:15

Waher.Service.IoTBroker.EDaler
Definition: AccountEvent.cs:9

Waher.Service.IoTBroker.Encodings
Definition: CodePages.cs:5

Waher.Service.IoTBroker.Events
Definition: EventLogComponent.cs:16

Waher.Service.IoTBroker.HttpX
Definition: Chunk.cs:2

Waher.Service.IoTBroker.Legal.MFA
Definition: LegalIdentityInfo.cs:4

Waher.Service.IoTBroker.Legal
Definition: Attachment.cs:6

Waher.Service.IoTBroker.Marketplace
Definition: AuctionItem.cs:7

Waher.Service.IoTBroker.MultiUserChat
Definition: Admin.cs:5

Waher.Service.IoTBroker.NeuroFeatures.WebServices
Definition: AddNote.cs:15

Waher.Service.IoTBroker.Paiwise
Definition: PaiwiseProcessor.cs:30

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates
Definition: Package.cs:9

Waher.Service.IoTBroker.Provisioning
Definition: ProvisioningComponent.cs:26

Waher.Service.IoTBroker.PubSub
Definition: DefaultFeatures.cs:4

Waher.Service.IoTBroker.Sampling
Definition: Bucket.cs:10

Waher.Service.IoTBroker.ServiceRegistrations
Definition: Annotation.cs:5

Waher.Service.IoTBroker.Setup
Definition: DnsConfiguration.cs:19

Waher.Service.IoTBroker.Sources.Connections
Definition: ClientConnection.cs:12

Waher.Service.IoTBroker.Sources.GatewayConfig
Definition: ConfigurationNode.cs:9

Waher.Service.IoTBroker.Sources.PersistedData
Definition: EventStatistic.cs:5

Waher.Service.IoTBroker.Sources.ProgramData
Definition: CreateFolderCommand.cs:10

Waher.Service.IoTBroker.Sources.Protocols
Definition: HttpStatistic.cs:5

Waher.Service.IoTBroker.StateMachines
Definition: CurrentState.cs:11

Waher.Service.IoTBroker.Synchronization
Definition: Calibration.cs:4

Waher.Service.IoTBroker.WebServices
Definition: AuthenticateJwt.cs:13

Waher.Service.IoTBroker
Definition: CreateAccount.cs:10

Waher.Service.IoTBroker.NamespaceSet
NamespaceSet
Namespace versions
Definition: NamespaceSet.cs:7

Waher.Things
Definition: AnalogInput.cs:15

Waher.Content.Duration
Represents a duration value, as defined by the xsd:duration data type: http://www....
Definition: Duration.cs:13