db/d47/_xmpp_server_module_8cs_source.html

using SkiaSharp;

using System;

using System.Collections;

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.Cssx;

using Waher.IoTGateway.ScriptExtensions.Constants;

using Waher.IoTGateway.Setup;

using Waher.IoTGateway.Tokenizers;

using Waher.IoTGateway.WebResources;

using Waher.Networking;

using Waher.Networking.DNS;

using Waher.Networking.DNS.Communication;

using Waher.Networking.DNS.HTTPS;

using Waher.Networking.FTP.Server;

using Waher.Networking.HTTP;

using Waher.Networking.SMTP.Server;

using Waher.Networking.Sniffers;

using Waher.Networking.XMPP.Concentrator;

using Waher.Networking.XMPP.Contracts;

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.Files;

using Waher.Persistence.Filters;

using Waher.Persistence.FullTextSearch;

using Waher.Persistence.FullTextSearch.Tokenizers;

using Waher.Persistence.Serialization;

using Waher.Runtime.Cache;

using Waher.Runtime.Inventory;

using Waher.Runtime.IO;

using Waher.Runtime.Queue;

using Waher.Runtime.ServiceRegistration;

using Waher.Runtime.Settings;

using Waher.Runtime.Statistics;

using Waher.Runtime.Temporary;

using Waher.Runtime.Threading;

using Waher.Script;

using Waher.Script.Abstraction.Elements;

using Waher.Script.Exceptions;

using Waher.Script.Graphs;

using Waher.Script.Model;

using Waher.Script.Objects;

using Waher.Script.Objects.Matrices;

using Waher.Script.Operators.Matrices;

using Waher.Script.Persistence.SQL.Sources;

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.DataStorage.Tokenizers;

using Waher.Service.IoTBroker.EDaler;

using Waher.Service.IoTBroker.Encodings;

using Waher.Service.IoTBroker.Events;

using Waher.Service.IoTBroker.GeoSpatial;

using Waher.Service.IoTBroker.HttpX;

using Waher.Service.IoTBroker.Legal;

using Waher.Service.IoTBroker.Legal.Attachments;

using Waher.Service.IoTBroker.Legal.Contracts;

using Waher.Service.IoTBroker.Legal.Contracts.Tokenizers;

using Waher.Service.IoTBroker.Legal.Identity.Tokenizers;

using Waher.Service.IoTBroker.Legal.MFA;

using Waher.Service.IoTBroker.Marketplace;

using Waher.Service.IoTBroker.MultiUserChat;

using Waher.Service.IoTBroker.NeuroFeatures.Tokenizers;

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.ProgramData;

using Waher.Service.IoTBroker.Sources.Reports.Events;

using Waher.Service.IoTBroker.Sources.Reports.Events.Commands;

using Waher.Service.IoTBroker.Sources.Reports.Performance;

using Waher.Service.IoTBroker.Sources.Reports.Protocols;

using Waher.Service.IoTBroker.Sources.Reports.Protocols.Commands;

using Waher.Service.IoTBroker.StateMachines;

using Waher.Service.IoTBroker.StateMachines.Model.Actions.EventLog;

using Waher.Service.IoTBroker.Synchronization;

using Waher.Service.IoTBroker.WebServices;

using Waher.Things.Authorities;

using Waher.Things.Http;

using Waher.Things.Semantic;


namespace Waher.Service.IoTBroker

{

    [Singleton]

    [ModuleDependency(typeof(SemanticModule))]

    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 const int DB_Generation = 1;


        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-DB5.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();    // TODO: Allow custom algorithm.

        private static IPersistentDictionary salts = null;

        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 HttpAuthenticationScheme[] defaultAuthenticationSchemesAdmin;

        private HttpAuthenticationScheme[] defaultAuthenticationSchemesXmpp;

        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 FtpServer ftpServer = 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 GeoSpatialComponent geoComponent = 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 HttpFolderResource httpInternalTransferUploadResource;

        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 RemoteLogin remoteLogin = null;

        private WhatsMyEndpointResource whatsMyEndpointResource = null;

        private AddNote addNote = null;

        private PublicTokenView publicTokenView = null;

        private PublicTokenHistoryView publicTokenHistoryView = null;

        private PublicNodes publicNodes = null;

        private Vault vault = null;

        private KillMachine killMachine = null;

        private HttpResource chatFile = null;

        private XmppOverHttp xmppOverHttp = null;

        private HttpReverseProxyResource httpProxy = null;

        private Buckets performanceStatistics = null;

        private Timer sampleTimer = null;


        private static string appData = string.Empty;

        private static string appDataDrive = null;

        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 string s))

                {

                    appData = s;


                    if (!string.IsNullOrEmpty(appData))

                        appDataDrive = Path.GetPathRoot(appData);

                }


                if (Expression.TryGetConstant("OsTime", null, out IElement OsTime) &&

                    OsTime.AssociatedObjectValue is TimeSpan TimeSinceOsStart)

                {

                    double LastOsStartTime = await RuntimeSettings.GetAsync("OS.StartTime", 0.0);

                    double CurrentOsStartTime = TimeSinceOsStart.TotalSeconds;


                    if (CurrentOsStartTime < LastOsStartTime)

                    {

                        string Unit = "seconds";

                        double d = CurrentOsStartTime;

                        byte NrDec = 0;


                        if (d >= 60)

                        {

                            d /= 60;

                            Unit = "minutes";

                            NrDec = 1;


                            if (d >= 60)

                            {

                                d /= 60;

                                Unit = "hours";


                                if (d >= 24)

                                {

                                    d /= 24;

                                    Unit = "days";


                                    if (d >= 7)

                                    {

                                        d /= 7;

                                        Unit = "weeks";

                                    }

                                }

                            }

                        }


                        Log.Alert("Operating System restarted " +

                            CommonTypes.Encode(d, NrDec) + " " + Unit + " ago.");

                    }


                    await RuntimeSettings.SetAsync("OS.StartTime", CurrentOsStartTime);

                }


                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.performanceStatistics = new Buckets(TP, new Duration(false, 0, 0, 0, 0, 1, 0), false, true, true);


                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();

                Gateway.OAuthEnvironment.Register(this.persistenceLayer);

                Gateway.OAuthEnvironment.Lock();


                salts = await Database.GetDictionary("Salts");


                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 = XML.LoadFromFile(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 = XML.LoadFromFile(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 = XML.LoadFromFile(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());


                #region Upgrading internal database


                long DbGen = await RuntimeSettings.GetAsync("DB.Generation.Broker", 0);


                while (DbGen < DB_Generation)

                {

                    DbGen++;


                    Log.Notice("Upgrading to DB Generation " + DbGen.ToString() + ".");


                    switch (DbGen)

                    {

                        case 1: // Encrypting sensitive fields.

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

                            {

                                try

                                {

                                    MethodInfo MI = TypeSource.FindMethod.MakeGenericMethod(T);

                                    object[] FindParameters = new object[] { 0, int.MaxValue, new FilterAnd(), Array.Empty<string>() };


                                    object Obj = MI.Invoke(null, FindParameters);

                                    Obj = await ScriptNode.WaitPossibleTask(Obj);


                                    if (Obj is IEnumerable Objects)

                                    {

                                        await Database.StartBulk();

                                        try

                                        {

                                            foreach (object Object in Objects)

                                                await Database.Update(Object);

                                        }

                                        finally

                                        {

                                            await Database.EndBulk();

                                        }

                                    }

                                }

                                catch (Exception ex)

                                {

                                    Log.Exception(ex, T.FullName);

                                }

                            }

                            break;

                    }


                    await RuntimeSettings.SetAsync("DB.Generation.Broker", DbGen);

                }


                #endregion


                #region SMTP


                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";


                if (!(RelayConfiguration.Instance is null))

                    await RelayConfiguration.Instance.ConfigureSystem();


                #endregion


                #region FTP


                Dictionary<int, KeyValuePair<ClientCertificates, bool>> PortSpecificMTlsSettings = new Dictionary<int, KeyValuePair<ClientCertificates, bool>>();

                int[] FtpPorts = Gateway.GetConfigPorts("FTP");

                int[] FtpsPorts = Gateway.GetConfigPorts("FTPS");

                int[] FtpDataPorts = Gateway.GetConfigPorts("FTP.PassiveData");


                foreach (int Port in FtpPorts.Join(FtpsPorts).Join(FtpDataPorts))

                {

                    Gateway.HttpServer.GetMTlsSettings(Port, out ClientCertificates ClientCertificate, out bool TrustClientCertificates);

                    PortSpecificMTlsSettings[Port] = new KeyValuePair<ClientCertificates, bool>(ClientCertificate, TrustClientCertificates);

                }


                this.ftpServer = new FtpServer(Gateway.Domain, FtpPorts, FtpsPorts,

                    FtpDataPorts, Gateway.Certificate, !(Gateway.Certificate is null),

                    ClientCertificates.NotUsed, false, PortSpecificMTlsSettings, true,

                    this.persistenceLayer);


                Types.SetModuleParameter("FTP_SERVER", this.ftpServer);


                this.ftpServer.ExternalSniffers.Add(new XmlFileSniffer(appData + "FTP" + Path.DirectorySeparatorChar +

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

                    7, BinaryPresentationMethod.ByteCount));


                #endregion


                this.httpServer = Types.TryGetModuleParameter<HttpServer>("HTTP");


                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);


                this.xmppServer.GetParentConnection += (sender, e) =>

                {

                    e.Client = Gateway.XmppClient;

                    return Task.CompletedTask;

                };


                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;


                Gateway.ConcentratorServer.SensorServer.AssignAuthority += this.SensorServer_AssignAuthority;

                Gateway.XmppClient.RegisterMessageHandler("Delivered", ContractsClient.NamespaceOnboarding, TransferIdDelivered, true);


                ContractsClient.GetLocalSchema += this.ContractsClient_GetLocalSchema;

                ContractsClient.ValidateLocalSignature += this.ContractsClient_ValidateLocalSignature;

                ContractsClient.GetLocalPublicKey += this.ContractsClient_GetLocalPublicKey;


                #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.persistenceLayer.Server = this.xmppServer;


                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.geoComponent = new GeoSpatialComponent(this.xmppServer, "geo", "Geo-Spatial information");

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

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

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

                this.legalComponent.EDaler = this.eDalerComponent;


                await this.geoComponent.Load();


                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[1..]] = true;

                        }


                        this.vulnerableResources = VulnerableResources;


                        Gateway.Root.FileNotFound += this.CheckForHoneyPotResources;

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                    }

                }


                WebServices.Agent.Account.DomainInfo TempResource = new WebServices.Agent.Account.DomainInfo();

                this.defaultAuthenticationSchemesAdmin = TempResource.CreateAuthenticationSchemes(Users.Source);

                this.defaultAuthenticationSchemesXmpp = TempResource.AuthenticationSchemes;


                if (!(this.httpServer is null))

                {

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

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

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

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


                    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, false, 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.remoteLogin = new RemoteLogin());

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

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

                    this.httpServer.Register(this.publicTokenView = new PublicTokenView());

                    this.httpServer.Register(this.publicTokenHistoryView = new PublicTokenHistoryView());

                    this.httpServer.Register(this.publicNodes = new PublicNodes());

                    this.httpServer.Register(this.vault = new Vault());

                    this.httpServer.Register(this.killMachine = new KillMachine());

                    this.httpServer.Register(this.httpProxy = new HttpReverseProxyResource("/HttpProxy",

                        TimeSpan.FromSeconds(30), false,

                        HttpModule.GetAuthenticationSchemes(), null));

                    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",

                            InternalTransferFolder = Path.Combine(appData, "InternalTransfer"),

                            InternalTransferRoot = Root + "/InternalTransfer",

                            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.httpInternalTransferUploadResource = new HttpFolderResource("/InternalTransfer", this.httpFileUploadSettings.InternalTransferFolder, false, false, false, false, new InternalTransferAccess());

                        this.httpServer.Register(this.httpFileUploadResource);

                        this.httpServer.Register(this.httpEncryptedFileUploadResource);

                        this.httpServer.Register(this.httpPubSubFileUploadResource);

                        this.httpServer.Register(this.httpInternalTransferUploadResource);


                        Export.OnExportFolderUpdated += this.Export_OnExportFolderUpdated;

                        Export.OnExportKeyFolderUpdated += this.Export_OnExportKeyFolderUpdated;

                    }


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


                    foreach (HttpReverseProxyResource ProxyResource in ReverseProxies)

                    {

                        if (ProxyResource.UserSessions)

                        {

                            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;

                        }

                    }

                }


                await this.DeleteOldItems();


                Gateway.OnNewCertificate += this.Gateway_OnNewCertificate;

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


                if (Types.TryGetModuleParameter("Concentrator", out this.concentratorServer))

                {

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

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

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

                }


                await ProtocolsRoot.RegisterReports();

                await PerformanceRoot.RegisterReports();

                await EventsRoot.RegisterReports();


                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.HasDomain)

                {

                    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 (Gateway.HasDomain && 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();


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

                        if (!Response.HasError && Response.Decoded 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;


                await CheckFullTestSearchIndices();


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

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        public HttpAuthenticationScheme[] DefaultAuthenticationSchemesAdmin => this.defaultAuthenticationSchemesAdmin;


        public HttpAuthenticationScheme[] DefaultAuthenticationSchemesXmpp => this.defaultAuthenticationSchemesXmpp;


        public static ISerializerContext FullSerialization => Ledger.Provider as Persistence.NeuroLedger.NeuroLedgerProvider;


        public static ISerializerContext NormalizedSerialization => Database.Provider as FilesProvider;


        private static async Task CheckFullTestSearchIndices()

        {

            bool ReindexIdentities = await Search.SetFullTextSearchIndexCollection(

                "FTS_Identities", "LegalIdentities");


            if (await Search.AddFullTextSearch("LegalIdentities",

                new PropertyDefinition(typeof(PropertiesTokenizer).FullName, "Properties")))

            {

                ReindexIdentities = true;

            }


            bool ReindexContracts = await Search.SetFullTextSearchIndexCollection(

                "FTS_Contracts", "Contracts");


            if (await Search.AddFullTextSearch("Contracts",

                new PropertyDefinition(typeof(RolesTokenizer).FullName, "Roles"),

                new PropertyDefinition(typeof(ParametersTokenizer).FullName, "Parameters"),

                new PropertyDefinition(typeof(HumanReadableTextsTokenizer).FullName, "ForHumans")))

            {

                ReindexContracts = true;

            }


            bool ReindexTokens = await Search.SetFullTextSearchIndexCollection(

                "FTS_Tokens", "NeuroFeatureTokens");


            if (await Search.AddFullTextSearch("NeuroFeatureTokens",

                new PropertyDefinition(typeof(NeuroFeatureTokenizer).FullName, "FriendlyName"),

                new PropertyDefinition(typeof(NeuroFeatureTokenizer).FullName, "Category"),

                new PropertyDefinition(typeof(MarkdownTokenizer).FullName, "Description")))

            {

                ReindexTokens = true;

            }


            bool ReindexAccounts = await Search.SetFullTextSearchIndexCollection(

                "FTS_Accounts", "BrokerAccounts");


            if (await Search.AddFullTextSearch("BrokerAccounts",

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "UserName"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "EMail"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "PhoneNr"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "FirstName"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "MiddleNames"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "LastNames"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "PersonalNumber"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "Country"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "OrgNumber"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "OrgName"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "OrgRole"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "OrgDepartment"),

                new PropertyDefinition(typeof(AccountTokenizer).FullName, "OrgCountry")))

            {

                ReindexAccounts = true;

            }


            if (ReindexIdentities)

                await ReindexFullTextSearchIndex("FTS_Identities", "LegalIdentities");


            if (ReindexContracts)

                await ReindexFullTextSearchIndex("FTS_Contracts", "Contracts");


            if (ReindexTokens)

                await ReindexFullTextSearchIndex("FTS_Tokens", "NeuroFeatureTokens");


            if (ReindexAccounts)

                await ReindexFullTextSearchIndex("FTS_Accounts", "BrokerAccounts");

        }


        private static async Task ReindexFullTextSearchIndex(string IndexName, string CollectionName)

        {

            long NrObjects = await Search.ReindexCollection(IndexName);


            Log.Notice("Full Text Search Index regenerated.", IndexName,

                new KeyValuePair<string, object>("Collection", CollectionName),

                new KeyValuePair<string, object>("Index", IndexName),

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

        }


        private async Task SensorServer_AssignAuthority(object Sender, Networking.XMPP.Events.AuthorityEventArgs e)

        {

            if (await IsAdmin(e.BareJid))

                e.Authority = new MaximumAuthority(e.BareJid);

            else if (!string.IsNullOrEmpty(Gateway.ProvisioningClient?.OwnerJid) &&

                Gateway.ProvisioningClient.OwnerJid == e.BareJid)

            {

                e.Authority = new MaximumAuthority(e.BareJid);

            }

            else

                e.Authority = new NoAuthority(e.BareJid);

        }


        private Task Gateway_OnTerminate(object Sender, EventArgs e)

        {

            System.Timers.Timer CheckTimer = new System.Timers.Timer(80000);

            CheckTimer.Elapsed += this.CheckRunningTasks;


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

            CloseTimer.Elapsed += this.CloseProcess;


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

            CloseTimer.Elapsed += this.KillProcess;


            return Task.CompletedTask;

        }


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

        {

            if (AsyncProcessors.HasActiveProcessors)

            {

                IAsyncProcessor[] Processors = AsyncProcessors.GetActiveProcessors();

                StringBuilder sb = new StringBuilder();


                sb.AppendLine("Active asynchronous processors stopping the service shutdown:");


                foreach (IAsyncProcessor AsyncProcessor in Processors)

                {

                    sb.AppendLine();

                    sb.Append("* ");

                    sb.Append(AsyncProcessor.Name);

                }


                Log.Alert(sb.ToString());


                AsyncProcessors.CloseAllProcessorsForTermination();

            }

        }


        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 CheckForHoneyPotResources(object Sender, FileNotFoundEventArgs e)

        {

            NotFoundException ex = e.Exception;

            if (ex is null)

                return; // Already processed.


            try

            {

                string s = e.Request.SubPath;

                if (s.StartsWith("/"))

                    s = s[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

                    {

                        ContentResponse P = await InternetContent.EncodeAsync(ContentObject, Encoding.UTF8);

                        if (P.HasError)

                        {

                            Log.Exception(P.Error);

                            return;

                        }


                        Content = P.Encoded;

                        ContentType = P.ContentType;

                    }

                }


                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(true, Encoding.UTF8.GetBytes(Html));

                    await e.Response.SendResponse();

                }

                else

                    await e.Response.SendResponse(ex);


                await e.Response.DisposeAsync();

            }

            catch (Exception ex2)

            {

                Log.Exception(ex2);

            }

        }


        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 &&

                    !this.xmppServer.IsServerDomain(Gateway.XmppClient.Domain, true))

                {

                    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);

            this.ftpServer?.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.GetLastWriteTimeUtc(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 >= 8 &&

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

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

                                            CommonTypes.TryParse(Record[6], out double Latitude) &&

                                            CommonTypes.TryParse(Record[7], out double Longitude))

                                        {

                                            Count++;


                                            IP4Localization Rec = new IP4Localization()

                                            {

                                                RangeStart = IpRangeFrom,

                                                RangeEnd = IpRangeTo,

                                                CountryCode = Record[2],

                                                Country = Record[3],

                                                Region = Record[4],

                                                City = Record[5],

                                                Latitude = Latitude,

                                                Longitude = Longitude

                                            };


                                            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.CreateSessionVariables();


                                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("Latitude", Location.Latitude);

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

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

            }

        }


        public static Task<IP4Localization> FindIpAddress(string RemoteEndPoint)

        {

            RemoteEndPoint = RemoteEndPoint.RemovePortNumber();


            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_NewDay(object P)

        {

            try

            {

                if (!(this.httpServer is null))

                {

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


                    HttpStatistic HttpStatistic = new 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.Insert(HttpStatistic);

                }


                if (!(this.xmppServer is null))

                {

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


                    XmppStatistic XmppStatistic = new 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.Insert(XmppStatistic);

                }


                if (!(this.eventStatistics is null))

                {

                    EventStatistics Stat = this.eventStatistics.GetStatisticsSinceLast();


                    EventStatistic EventStatistic = new Sources.Reports.Events.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.Insert(EventStatistic);

                }


                await this.DeleteOldItems();

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

            finally

            {

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

            }

        }


        private async Task DeleteOldItems()

        {

            try

            {

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

                int Nr, Nr2;


                if (!(this.persistenceLayer is null))

                {

                    try

                    {

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

                        if (Nr > 0)

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

                    }

                    catch (Exception ex)

                    {

                        Log.Error("Unable to delete old offline messages.\r\n\r\n" + ex.Message,

                            string.Empty, string.Empty, string.Empty, EventLevel.Medium,

                            string.Empty, string.Empty, ex.StackTrace);

                    }

                }


                if (!(this.xmppServer is null))

                {

                    try

                    {

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

                        if (Nr > 0)

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

                    }

                    catch (Exception ex)

                    {

                        Log.Error("Unable to delete old e-mail messages.\r\n\r\n" + ex.Message,

                            string.Empty, string.Empty, string.Empty, EventLevel.Medium,

                            string.Empty, string.Empty, ex.StackTrace);

                    }

                }


                if (!(this.pubSubComponent is null))

                {

                    try

                    {

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

                        if (Nr > 0)

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

                    }

                    catch (Exception ex)

                    {

                        Log.Error("Unable to delete expired pubsub nodes.\r\n\r\n" + ex.Message,

                            string.Empty, string.Empty, string.Empty, EventLevel.Medium,

                            string.Empty, string.Empty, ex.StackTrace);

                    }

                }


                try

                {

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

                    if (NrTokens > 0)

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

                }

                catch (Exception ex)

                {

                    Log.Error("Unable to delete expired tokens.\r\n\r\n" + ex.Message,

                        string.Empty, string.Empty, string.Empty, EventLevel.Medium,

                        string.Empty, string.Empty, ex.StackTrace);

                }


                try

                {

                    (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.Error("Unable to delete expired state machines.\r\n\r\n" + ex.Message,

                        string.Empty, string.Empty, string.Empty, EventLevel.Medium,

                        string.Empty, string.Empty, ex.StackTrace);

                }


                try

                {

                    int NrAttachments = await AttachmentCache.DeleteOldAttachments();

                    if (NrAttachments > 0)

                        Log.Informational(NrAttachments.ToString() + " cached attachments deleted.");

                }

                catch (Exception ex)

                {

                    Log.Error("Unable to delete old cached attachments.\r\n\r\n" + ex.Message,

                        string.Empty, string.Empty, string.Empty, EventLevel.Medium,

                        string.Empty, string.Empty, ex.StackTrace);

                }


                try

                {

                    int Count = await (this.legalComponent?.DeleteOldPreviewApplications(14) ?? Task.FromResult(0));    // TODO: Make configurable.


                    if (Count > 0)

                        Log.Informational(Count.ToString() + " old preview files deleted.");

                }

                catch (Exception ex)

                {

                    Log.Error("Unable to delete old preview files.\r\n\r\n" + ex.Message,

                        string.Empty, string.Empty, string.Empty, EventLevel.Medium,

                        string.Empty, string.Empty, ex.StackTrace);

                }


                Gateway.DeleteOldFiles(this.httpFileUploadSettings.InternalTransferFolder, 7);

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


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

        {

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


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

            {

                Result.Add(new Sources.Reports.Events.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);

                await this.eventStatistics.DisposeAsync();

                this.eventStatistics = null;

            }


            instance = null;


            if (!(this.vulnerableResources is null))

            {

                this.vulnerableResources = null;


                if (!(Gateway.Root is null))

                    Gateway.Root.FileNotFound -= this.CheckForHoneyPotResources;

            }


            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.remoteLogin);

                this.httpServer.Unregister(this.whatsMyEndpointResource);

                this.httpServer.Unregister(this.addNote);

                this.httpServer.Unregister(this.publicTokenView);

                this.httpServer.Unregister(this.publicTokenHistoryView);

                this.httpServer.Unregister(this.publicNodes);

                this.httpServer.Unregister(this.vault);

                this.httpServer.Unregister(this.killMachine);

                this.httpServer.Unregister(this.httpProxy);

                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.httpInternalTransferUploadResource is null))

                    this.httpServer.Unregister(this.httpInternalTransferUploadResource);


                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.remoteLogin = null;

                this.whatsMyEndpointResource = null;

                this.addNote = null;

                this.publicTokenView = null;

                this.publicTokenHistoryView = null;

                this.publicNodes = null;

                this.vault = null;

                this.killMachine = null;

                this.httpProxy = null;

                this.chatFile = null;

                this.xmppOverHttp = null;

                this.httpFileUploadResource = null;

                this.httpEncryptedFileUploadResource = null;

                this.httpPubSubFileUploadResource = null;

                this.httpInternalTransferUploadResource = 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.geoComponent?.Dispose();

            this.geoComponent = 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.ftpServer?.Dispose();

            this.ftpServer = null;


            this.chatSessions?.Dispose();

            this.chatSessions = null;


            this.consolidators?.Dispose();

            this.consolidators = null;


            this.ssoTokens?.Dispose();

            this.ssoTokens = null;


            salts?.Dispose();

            salts = null;


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

        }


        public static XmppServerModule Instance => instance;

        public static SmtpServer MailServer => instance?.smtpServer;

        public static FtpServer FileServer => instance?.ftpServer;

        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 GeoSpatialComponent Geo => instance?.geoComponent;

        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 XmppServer Server

        {

            get

            {

                if (!(instance is null))

                    return instance.xmppServer;


                if (Types.TryGetModuleParameter("XMPP_SERVER", out XmppServer Server) &&

                    !Server.Disposed)

                {

                    return Server;

                }


                return null;

            }

        }


        public static string PackagesFolder

        {

            get => Gateway.SoftwareUpdateClient?.PackageFolder ?? Path.Combine(Gateway.AppDataFolder, "Packages");

        }


        public static string DownloadsFolder

        {

            get => Path.Combine(Gateway.RootFolder, "Downloads");

        }


        public static string InternalTransfersFolder

        {

            get => instance?.httpFileUploadSettings.InternalTransferFolder;

        }


        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.TryQuery(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;

            }


            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)

                {

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

                    await this.serviceRegistrationClient.CheckRegistration();


                    if (Gateway.HasDomain)

                    {

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

                        if (!Gateway.IsDomain(VCardDomain, true))

                        {

                            // 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 ||

                    !CheckPackageSize(LocalPackage.FileName, RemotePackage.Bytes))

                {

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

                    TemporaryProgressStream Destination = new TemporaryProgressStream();

                    DateTime Last = DateTime.UtcNow;

                    long BytesDownloaded = 0;


                    Destination.OnWrite += async (Sender, e) =>

                    {

                        DateTime TP = DateTime.UtcNow;


                        BytesDownloaded = e.Total;


                        if (TP.Second != Last.Second)

                        {

                            Last = TP;

                            await ResponseCallback("Downloading `" + RemotePackage.FileName + "`: " + BytesDownloaded.ToString() + " bytes downloaded.", MessageId);

                        }

                    };


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


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


                    return true;

                }

            }

            catch (Exception ex)

            {

                await ReturnError(ex, ResponseCallback);

            }


            return false;

        }


        private static bool CheckPackageSize(string FileName, long ExpectedSize)

        {

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


            if (!File.Exists(FullPath))

                return false;


            System.IO.FileInfo Info = new System.IO.FileInfo(FullPath);


            return Info.Length == ExpectedSize;

        }


        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 ?? Array.Empty<byte>())),

                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);

            }


            string SignatureFile = Path.Combine(Gateway.SoftwareUpdateClient.PackageFolder,

                Path.ChangeExtension(Package.FileName, "signature"));


            StringBuilder sb = new StringBuilder();


            sb.AppendLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");

            sb.AppendLine("<Signatures xmlns=\"http://waher.se/Schema/Signatures.xsd\">");

            sb.Append("\t<Signature fileName=\"");

            sb.Append(XML.Encode(Package.FileName));

            sb.Append("\">");

            sb.Append(System.Convert.ToBase64String(Package.Signature));

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

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


            File.WriteAllText(SignatureFile, sb.ToString(), Encoding.UTF8);


            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());

        }


        public 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)

                    return false;

                else

                    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;


                Buffer.BlockCopy(Digest, 0, AesKey, 0, 32);

                Buffer.BlockCopy(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)

        {

            uint c = 65536;

            if (Bytes < c)

                c = (uint)Bytes;


            byte[] Buffer = new byte[c];


            while (Bytes > 0)

            {

                Input.ReadAll(Buffer, 0, (int)c);

                Bytes -= c;

                if (c > Bytes)

                    c = (uint)Bytes;

            }

        }


        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.CreateSessionVariables())

            {

                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[..^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('"');


                if (Types.TryGetModuleParameter("SERVICE_NAME", out string ServiceName) &&

                    !string.IsNullOrEmpty(ServiceName))

                {

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

                    sb.Append(ServiceName);

                    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[..^3] + "dll";


            StringBuilder sb = new StringBuilder();


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

            sb.Append(s);

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

            sb.Append(Gateway.AppDataFolder[..^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.CreateSessionVariables())

            {

                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)

        {

            return e.Value.DisposeAsync();

        }


        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)

        {

            try

            {

                if (string.IsNullOrEmpty(s))

                {

                    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;


                        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;


                    Channel?.Warning(Msg);


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

                    return;

                }


                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.CreateSessionVariables();

                    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)

                {

                    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;

                            //ScriptReturnValueException.Reuse(ex);

                        }

                        catch (ScriptBreakLoopException ex)

                        {

                            Result = ex.LoopValue ?? ObjectValue.Null;

                            //ScriptBreakLoopException.Reuse(ex);

                        }

                        catch (ScriptContinueLoopException ex)

                        {

                            Result = ex.LoopValue ?? ObjectValue.Null;

                            //ScriptContinueLoopException.Reuse(ex);

                        }

                        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)

            {

                await ReturnError(ex, ResponseCallback);

            }

        }


        private static async Task ReturnError(Exception ex, ResponseCallbackHandler ResponseCallback)

        {

            try

            {

                ex = Log.UnnestException(ex);

                StringBuilder 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.ToExpressionString(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.ToExpressionString(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 = CssxToCss.ColorToCss(Theme.CurrentTheme.LinkColorUnvisited);


            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[..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[..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[i..];

                        break;

                    }


                    s = s[..^3] + "dll";

                    if (File.Exists(s))

                    {

                        Command = "dotnet \"" + s + "\"" + Command[i..];

                        break;

                    }


                    await SendErrorMessage("File not found: `" + s[..^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[s.Length..].Trim(), ResponseCallback);


                case "dir":

                case "ls":

                    try

                    {

                        string Pattern = Command[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[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;

            }


            Log.Notice("Starting process.",

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

                new KeyValuePair<string, object>("Arguments", StartInfo.Arguments),

                new KeyValuePair<string, object>("WorkingDirectory", StartInfo.WorkingDirectory),

                new KeyValuePair<string, object>("UseShellExecute", StartInfo.UseShellExecute),

                new KeyValuePair<string, object>("WindowStyle", StartInfo.WindowStyle),

                new KeyValuePair<string, object>("CreateNoWindow", StartInfo.CreateNoWindow),

                new KeyValuePair<string, object>("ErrorDialog", StartInfo.ErrorDialog),

                new KeyValuePair<string, object>("RedirectStandardInput", StartInfo.RedirectStandardInput),

                new KeyValuePair<string, object>("RedirectStandardError", StartInfo.RedirectStandardError),

                new KeyValuePair<string, object>("RedirectStandardOutput", StartInfo.RedirectStandardOutput));


            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[..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[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[i..j].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.GetLastWriteTimeUtc(Rec.Path);

                await HttpFolderResource.SendResponse(TempFile.FileName, Rec.ContentType,

                    Rec.ETag, LastWriteTime, false, Response);

                return;

            }


            await HttpFolderResource.SendResponse(Rec.Path, Rec.ContentType, Rec.ETag,

                File.GetLastWriteTimeUtc(Rec.Path), false, 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, Array.Empty<EmbeddedContent>());

        }


        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, Array.Empty<EmbeddedContent>());

        }


        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, Array.Empty<EmbeddedContent>());

        }


        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.DefaultContentType))

                    {

                        ContentResponse Decoded = await InternetContent.DecodeAsync(Attachment.ContentType, Attachment.Raw, null);


                        if (!Decoded.HasError && Decoded.Decoded is CssDocument CssDocument2)

                        {

                            Styles += CssDocument2.Css;

                            Changed = true;

                            continue;

                        }

                    }


                    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)

                    }

                };


            ContentResponse P = await InternetContent.EncodeAsync(new ContentAlternatives(Alternatives), Encoding.UTF8);

            P.AssertOk();


            byte[] BodyBin = P.Encoded;

            string ContentType = P.ContentType;


            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);

                P.AssertOk();


                BodyBin = P.Encoded;

                ContentType = P.ContentType;

            }


            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[(i + 1)..].Trim();


            return await (instance?.smtpServer?.SendMessage(Domain, SmtpHost, SmtpPort, UserName, Password, From, To, Headers, BodyBin, DateTime.Now) ?? Task.FromResult(false));

        }


        private static readonly PerformanceAlertMonitor cpuMonitor = new PerformanceAlertMonitor(75, 10 * 60, 90, 30 * 60,

            "CPU usage is above 75% for 10 minutes.",

            "CPU usage is below 75% for 10 minutes.",

            "CPU usage is above 90% for 30 minutes.",

            "CPU usage is below 90% for 30 minutes.");

        private static readonly PerformanceAlertMonitor freeMemoryMonitor = new PerformanceAlertMonitor(1000, 30, 200, 30,

            "Free Memory available is below 1000 MB for 30 seconds.",

            "Free Memory available is above 1000 MB for 30 seconds.",

            "Free Memory available is below 200 MB for 30 seconds.",

            "Free Memory available is above 200 MB for 30 seconds.");

        private static readonly PerformanceAlertMonitor freeHDMonitor = new PerformanceAlertMonitor(10, 30, 2, 30,

            "Free Hard Disk available is below 10 GB for 30 seconds.",

            "Free Hard Disk available is above 10 GB for 30 seconds.",

            "Free Hard Disk available is below 2 GB for 30 seconds.",

            "Free Hard Disk available is above 2 GB for 30 seconds.");

        private static readonly PerformanceAlertMonitor allocatedMemoryMonitor = new PerformanceAlertMonitor(1500, 30, 1900, 30,

            "Allocated Memory is above 1500 MB for 30 seconds.",

            "Allocated Memory is below 1500 MB for 30 seconds.",

            "Allocated Memory is above 1900 MB for 30 seconds.",

            "Allocated Memory is below 1900 MB for 30 seconds.");

        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", Array.Empty<Type>());


                    this.freeMemoryCounter = this.getCounter2?.Invoke(null, new object[] { "Memory", "Available MBytes" });

                    this.freeMemoryCounter ??= this.getCounter2?.Invoke(null, new object[] { "Minne", "Tillgängliga megabyte" });


                    this.getFreeMemoryValue = this.freeMemoryCounter?.GetType()?.GetMethod("NextValue", Array.Empty<Type>());

                }


                if (this.getCpuValue?.Invoke(this.cpuCounter, Types.NoParameters) is float CPU)

                {

                    await this.performanceStatistics.Sample("CPU", CPU);

                    cpuMonitor.Sample(CPU);

                }


                if (this.getFreeMemoryValue?.Invoke(this.freeMemoryCounter, Types.NoParameters) is float FreeMemory)

                {

                    await this.performanceStatistics.Sample("FreeMemory", FreeMemory);

                    freeMemoryMonitor.Sample(FreeMemory);

                }


                double AllocatedMemory = GC.GetTotalMemory(true) / 1048576.0;

                await this.performanceStatistics.Sample("AllocMemory", AllocatedMemory);

                allocatedMemoryMonitor.Sample(AllocatedMemory);


                if (!string.IsNullOrEmpty(appDataDrive))

                {

                    DriveInfo Drive = new DriveInfo(appDataDrive);

                    double FreeHD = Drive.AvailableFreeSpace / 1073741824.0;

                    await this.performanceStatistics.Sample("FreeHD", FreeHD);

                    freeHDMonitor.Sample(FreeHD);

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        public Bucket CurrentCpuBucket

        {

            get

            {

                if (this.performanceStatistics.TryGetBucket("CPU", out Bucket Bucket))

                    return Bucket;

                else

                    return null;

            }

        }


        public Bucket CurrentFreeMemoryBucket

        {

            get

            {

                if (this.performanceStatistics.TryGetBucket("FreeMemory", out Bucket Bucket))

                    return Bucket;

                else

                    return null;

            }

        }


        public Bucket CurrentFreeHDBucket

        {

            get

            {

                if (this.performanceStatistics.TryGetBucket("FreeHD", out Bucket Bucket))

                    return Bucket;

                else

                    return null;

            }

        }


        public Bucket CurrentAllocatedMemoryBucket

        {

            get

            {

                if (this.performanceStatistics.TryGetBucket("AllocMemory", 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;


                if (!this.xmppServer.IsServerDomain(e.From.Domain, true))

                {

                    await e.IqErrorForbidden(e.To, "Account must be on broker.", "en");

                    return;

                }


                int IssuedAt = (int)Math.Round(DateTime.UtcNow.Subtract(JSON.UnixEpoch).TotalSeconds);

                int Expires = IssuedAt + Seconds;


                string Token = Gateway.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 string CreateJwtToken(params KeyValuePair<string, object>[] Claims)

        {

            return this.CreateJwtToken((IEnumerable<KeyValuePair<string, object>>)Claims);

        }


        internal string CreateJwtToken(IEnumerable<KeyValuePair<string, object>> Claims)

        {

            return Gateway.JwtFactory.Create(Claims);

        }


        internal bool ValidateJwtToken(string Token)

        {

            return this.ValidateJwtToken(Token, false);

        }


        internal bool ValidateJwtToken(string Token, bool CheckIssuer)

        {

            return this.ValidateJwtToken(Token, CheckIssuer, out _);

        }


        internal bool ValidateJwtToken(string Token, bool CheckIssuer, out JwtToken ParsedToken)

        {

            if (!JwtToken.TryParse(Token, out ParsedToken))

                return false;


            return this.ValidateJwtToken(ParsedToken, CheckIssuer);

        }


        internal bool ValidateJwtToken(JwtToken Token)

        {

            return this.ValidateJwtToken(Token, false);

        }


        internal bool ValidateJwtToken(JwtToken Token, bool CheckIssuer)

        {

            if (CheckIssuer && !this.xmppServer.IsServerDomain(Token.Issuer, true))

                return false;


            return Gateway.JwtFactory.IsValid(Token);

        }


        internal static Task<IClientConnection> JwtAuthenticate(HttpRequest Request)

        {

            return JwtAuthenticate(Request, Gateway.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)

                {

                    IRecipient Recipient = await HttpxResponse.Server.TryGetRecipient(HttpxResponse.To, HttpxResponse.From);

                    if (Recipient is IClientConnection ClientConnection)

                        return ClientConnection;

                }


                throw new UnauthorizedException("Unauthorized access prohibited.", new string[] { "Bearer realm=\"" + Gateway.Domain?.Value + "\"" });

            }


            if (!JwtToken.TryParse(TokenStr, out JwtToken Token, out string ErrorReason))

                throw new UnauthorizedException(ErrorReason, new string[] { "Bearer realm=\"" + Gateway.Domain?.Value + "\"" });


            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(Request, "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(Request, "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(QuickLogin.UserVariableName, 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(Gateway.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 Gateway.JwtFactory.IsValid(Token, out Reason);

        }


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

        {

            string OnboardingNeuron = await LegalComponent.GetOnboardingNeuronDomainName();


            if (e.From != OnboardingNeuron)

                return;


            string Code = XML.Attribute(e.Content, "code");

            bool Deleted = XML.Attribute(e.Content, "deleted", false);


            if (!Deleted)

                return;


            await WebServices.Agent.Account.Transfer.TransferCodeDelivered(Code);

        }


        private async Task ContractsClient_GetLocalSchema(object Sender, Networking.XMPP.Contracts.EventArguments.SchemaReferenceEventArgs e)

        {

            ValidationSchema Schema;


            if (e.SchemaDigest is null)

            {

                Schema = await Database.FindFirstIgnoreRest<ValidationSchema>(

                    new FilterFieldEqualTo("Namespace", e.Namespace),

                    "-Created");

            }

            else

            {

                Schema = await Database.FindFirstIgnoreRest<ValidationSchema>(

                    new FilterAnd(

                        new FilterFieldEqualTo("Namespace", e.Namespace),

                        new FilterFieldEqualTo("HashBase64", System.Convert.ToBase64String(e.SchemaDigest.Digest))));

            }


            e.XmlSchema = Schema?.XmlSchema;

        }


        private async Task ContractsClient_ValidateLocalSignature(object Sender, Networking.XMPP.Contracts.EventArguments.ValidateSignatureEventArgs e)

        {

            XmppAddress LegalId = new XmppAddress(e.LegalId);


            if (this.legalComponent.IsComponentDomain(LegalId.Domain, true))

            {

                Legal.Identity.LegalIdentity Identity = await LegalComponent.GetLocalLegalIdentity(e.LegalId);

                if (!(Identity is null))

                {

                    e.Valid = Identity.ValidateSignature(e.Data, e.Signature);


                    if (e.Valid.Value)

                    {

                        StringBuilder Xml = new StringBuilder();

                        Identity.Serialize(Xml, true, true, true, true, true, true, true, null, this.legalComponent);


                        e.Identity = LegalIdentity.Parse(Xml.ToString());

                    }

                }

            }

        }


        private Task ContractsClient_GetLocalPublicKey(object Sender, Networking.XMPP.Contracts.EventArguments.PublicKeyEventArgs e)

        {

            if (this.legalComponent.IsComponentDomain(e.Address, true))

            {

                Tuple<Networking.XMPP.IE2eEndpoint, DateTime?, DateTime?> P =

                    LegalComponent.GetPublicKey(e.Timestamp);


                if (!(P.Item1 is null) && P.Item2.HasValue)

                    e.ReturnKey(P.Item1, P.Item2.Value, P.Item3);

            }


            return Task.CompletedTask;

        }


        #region Encrypted files


        public static Task<byte[]> LoadEncryptedFile(string FileName, byte[] Salt)

        {

            return LoadEncryptedFile(FileName, Salt, null);

        }


        public static async Task<byte[]> LoadEncryptedFile(string FileName, byte[] Salt, long? Size)

        {

            using FileStream File = System.IO.File.OpenRead(FileName);

            Aes Aes = Aes.Create();


            Aes.BlockSize = 128;

            Aes.KeySize = 256;

            Aes.Mode = CipherMode.CBC;

            Aes.Padding = PaddingMode.Zeros;


            byte[] Key = new byte[32];

            byte[] IV = new byte[16];


            Buffer.BlockCopy(Salt, 0, Key, 0, 32);

            Buffer.BlockCopy(Salt, 32, IV, 0, 16);


            using ICryptoTransform Decryptor = Aes.CreateDecryptor(Key, IV);

            using CryptoStream DecryptedFile = new CryptoStream(File, Decryptor, CryptoStreamMode.Read);


            if (Size.HasValue)

            {

                long c = Size.Value;

                if (c > int.MaxValue)

                    throw new IOException("File too large.");


                int c0 = (int)c;

                byte[] Bin = await DecryptedFile.ReadAllAsync(c0);


                return Bin;

            }

            else

            {

                using MemoryStream ms = new MemoryStream();

                await DecryptedFile.CopyToAsync(ms);

                return ms.ToArray();

            }

        }


        public static Task SaveEncryptedFile(string FileName, byte[] Salt, byte[] Data)

        {

            using MemoryStream ms = new MemoryStream(Data);

            return SaveEncryptedFile(FileName, Salt, ms);

        }


        public static async Task SaveEncryptedFile(string FileName, byte[] Salt, Stream Data)

        {

            using FileStream File = System.IO.File.Create(FileName);

            Aes Aes = Aes.Create();


            Aes.BlockSize = 128;

            Aes.KeySize = 256;

            Aes.Mode = CipherMode.CBC;

            Aes.Padding = PaddingMode.Zeros;


            byte[] Key = new byte[32];

            byte[] IV = new byte[16];


            Buffer.BlockCopy(Salt, 0, Key, 0, 32);

            Buffer.BlockCopy(Salt, 32, IV, 0, 16);


            using ICryptoTransform Encryptor = Aes.CreateEncryptor(Key, IV);

            using CryptoStream EncryptedFile = new CryptoStream(File, Encryptor, CryptoStreamMode.Write);


            Data.Position = 0;

            await Data.CopyToAsync(EncryptedFile);

            EncryptedFile.FlushFinalBlock();

        }


        public static async Task<Stream> EncodeBlob(Stream Data)

        {

            long Len = Data.Length;


            TemporaryStream Blob = new TemporaryStream();


            do

            {

                byte b = (byte)(Len & 127);

                Len >>= 7;


                if (Len > 0)

                    b |= 0x80;


                Blob.WriteByte(b);

            }

            while (Len > 0);


            Data.Position = 0;


            await Data.CopyToAsync(Blob);


            Blob.Position = 0;


            return Blob;

        }


        public static async Task<Stream> DecodeBlob(Stream Data)

        {

            int b;

            long Len = 0;

            int Offset = 0;


            do

            {

                b = Data.ReadByte();

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

                Offset += 7;

            }

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


            TemporaryStream Blob = new TemporaryStream();

            byte[] Buf = new byte[65536];

            int i, c;


            while (Len > 0)

            {

                c = (int)Math.Min(65536, Len);

                i = await Data.ReadAsync(Buf, 0, c);

                if (i <= 0)

                {

                    await Blob.DisposeAsync();

                    return null;

                }


                await Blob.WriteAsync(Buf, 0, i);

                Len -= i;

            }


            Blob.Position = 0;

            return Blob;

        }


        internal static async Task<byte[]> CreateSalt(string Key, byte[] AdditionalData)

        {

            using Runtime.Threading.Semaphore Lock = await Semaphores.BeginWrite("Salt:" + Key);


            salts ??= await Database.GetDictionary("Salts");    // For unit tests.


            int c = AdditionalData?.Length ?? 0;

            byte[] Salt = Gateway.NextBytes(48);


            byte[] Data = new byte[48 + c];


            Buffer.BlockCopy(Salt, 0, Data, 0, 48);

            if (c > 0)

                Buffer.BlockCopy(AdditionalData, 0, Data, 48, c);


            if (await salts.ContainsKeyAsync(Key))

                await salts.RemoveAsync(Key);


            await salts.AddAsync(Key, Data);


            return Salt;

        }


        internal static async Task<KeyValuePair<byte[], byte[]>> GetSaltWithAdditionalData(string Key)

        {

            salts ??= await Database.GetDictionary("Salts");    // For unit tests.


            KeyValuePair<bool, object> P = await salts.TryGetValueAsync(Key);

            int c;


            if (!P.Key || !(P.Value is byte[] Data) || (c = Data.Length - 48) < 0)

                return new KeyValuePair<byte[], byte[]>(null, null);


            byte[] Salt = new byte[48];

            byte[] AdditionalData = new byte[c];


            Buffer.BlockCopy(Data, 0, Salt, 0, 48);

            if (c > 0)

                Buffer.BlockCopy(Data, 48, AdditionalData, 0, c);


            return new KeyValuePair<byte[], byte[]>(Salt, AdditionalData);

        }


        internal static async Task<bool> RemoveSalt(string Key)

        {

            salts ??= await Database.GetDictionary("Salts");    // For unit tests.


            return await salts.RemoveAsync(Key);

        }


        #endregion

    }

}

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:15

Waher.Content.CommonTypes.Encode
static string Encode(bool x)
Encodes a Boolean for use in XML and other formats.
Definition: CommonTypes.cs:596

Waher.Content.CommonTypes.CRLF
static readonly char[] CRLF
Contains the CR LF character sequence.
Definition: CommonTypes.cs:19

Waher.Content.CommonTypes.TryParse
static bool TryParse(string s, out double Value)
Tries to decode a string encoded double.
Definition: CommonTypes.cs:48

Waher.Content.CommonTypes.EncodeRfc822
static string EncodeRfc822(DateTime Timestamp)
Encodes a date and time, according to RFC 822 §5.
Definition: CommonTypes.cs:669

Waher.Content.ContentResponse
Contains information about a response to a content request.
Definition: ContentResponse.cs:11

Waher.Content.ContentResponse.Encoded
byte[] Encoded
Encoded object.
Definition: ContentResponse.cs:67

Waher.Content.ContentResponse.ContentType
string ContentType
Internet Content-Type of encoded object.
Definition: ContentResponse.cs:48

Waher.Content.ContentResponse.HasError
bool HasError
If an error occurred.
Definition: ContentResponse.cs:72

Waher.Content.ContentResponse.Decoded
object Decoded
Decoded object.
Definition: ContentResponse.cs:54

Waher.Content.ContentResponse.Error
Exception Error
Error response.
Definition: ContentResponse.cs:77

Waher.Content.ContentResponse.AssertOk
void AssertOk()
Asserts response is OK.
Definition: ContentResponse.cs:102

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:14

Waher.Content.Html.Css.CssCodec.DefaultContentType
const string DefaultContentType
Content-Type for CSS files.
Definition: CssCodec.cs:25

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:15

Waher.Content.Html.HtmlDocument.GetBody
static string GetBody(string Html)
Extracts the contents of the BODY element in a HTML string.
Definition: HtmlDocument.cs:2059

Waher.Content.Html.JavaScript.JavaScriptCodec
JavaScript encoder/decoder.
Definition: JavascriptCodec.cs:14

Waher.Content.Html.JavaScript.JavaScriptCodec.DefaultContentType
const string DefaultContentType
application/javascript
Definition: JavascriptCodec.cs:25

Waher.Content.InternetContent
Static class managing encoding and decoding of internet content.
Definition: InternetContent.cs:19

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:768

Waher.Content.InternetContent.EncodeAsync
static Task< ContentResponse > EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
Encodes an object.
Definition: InternetContent.cs:361

Waher.Content.InternetContent.DecodeAsync
static Task< ContentResponse > DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair< string, string >[] Fields, Uri BaseUri)
Decodes an object.
Definition: InternetContent.cs:599

Waher.Content.JSON
Helps with common JSON-related tasks.
Definition: JSON.cs:16

Waher.Content.JSON.UnixEpoch
static readonly DateTime UnixEpoch
Unix Date and Time epoch, starting at 1970-01-01T00:00:00Z
Definition: JSON.cs:20

Waher.Content.Markdown.Consolidation.Consolidator
Consolidates Markdown from multiple sources, sharing the same thread.
Definition: Consolidator.cs:20

Waher.Content.Markdown.Consolidation.Consolidator.Update
Task< bool > Update(string Source, MarkdownDocument Markdown, string Id)
Updates incoming markdown information.
Definition: Consolidator.cs:163

Waher.Content.Markdown.Consolidation.Consolidator.Add
Task< bool > Add(string Source, MarkdownDocument Markdown)
Adds incoming markdown information.
Definition: Consolidator.cs:116

Waher.Content.Markdown.MarkdownCodec
Markdown encoder.
Definition: MarkdownCodec.cs:15

Waher.Content.Markdown.MarkdownCodec.ContentType
const string ContentType
Markdown content type.
Definition: MarkdownCodec.cs:53

Waher.Content.Markdown.MarkdownDocument
Contains a markdown document. This markdown document class supports original markdown,...
Definition: MarkdownDocument.cs:52

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:5926

Waher.Content.Markdown.MarkdownDocument.GeneratePlainText
async Task< string > GeneratePlainText()
Generates Plain Text from the markdown text.
Definition: MarkdownDocument.cs:5633

Waher.Content.Markdown.MarkdownDocument.GenerateHTML
async Task< string > GenerateHTML()
Generates HTML from the markdown text.
Definition: MarkdownDocument.cs:5588

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:92

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.MixedContent
Represents mixed content, encoded with multipart/mixed
Definition: MixedContent.cs:7

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:231

Waher.Content.Text.PlainTextCodec
Plain text encoder/decoder.
Definition: PlainTextCodec.cs:14

Waher.Content.Text.PlainTextCodec.DefaultContentType
const string DefaultContentType
text/plain
Definition: PlainTextCodec.cs:25

Waher.Content.Xml.XML
Helps with common XML-related tasks.
Definition: XML.cs:21

Waher.Content.Xml.XML.Attribute
static string Attribute(XmlElement E, string Name)
Gets the value of an XML attribute.
Definition: XML.cs:1062

Waher.Content.Xml.XML.LoadFromFile
static XmlDocument LoadFromFile(string FileName)
Loads an XML document from a file.
Definition: XML.cs:1808

Waher.Content.Xml.XML.Encode
static string Encode(string s)
Encodes a string for use in XML.
Definition: XML.cs:29

Waher.Content.Xml.XML.TryParse
static bool TryParse(string s, out DateTime Value)
Tries to decode a string encoded DateTime.
Definition: XML.cs:892

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:121

Waher.Content.Xsl.XSL
Static class managing loading of XSL resources stored as embedded resources or in content files.
Definition: XSL.cs:16

Waher.Content.Xsl.XSL.LoadSchema
static XmlSchema LoadSchema(string ResourceName)
Loads an XML schema from an embedded resource.
Definition: XSL.cs:24

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:134

Waher.Events.Log
Static class managing the application event log. Applications and services log events on this static ...
Definition: Log.cs:14

Waher.Events.Log.CleanStackTrace
static string CleanStackTrace(string StackTrace)
Cleans a Stack Trace string, removing entries from the asynchronous execution model,...
Definition: Log.cs:194

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:30

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:1657

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:576

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:692

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:344

Waher.Events.Log.UnnestException
static Exception UnnestException(Exception Exception)
Unnests an exception, to extract the relevant inner exception.
Definition: Log.cs:828

Waher.Events.Log.Unregister
static bool Unregister(IEventSink EventSink)
Unregisters an event sink from the event log.
Definition: Log.cs:47

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:460

Waher.Events.Log.Alert
static void Alert(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs an alert event.
Definition: Log.cs:1237

Waher.Events.LogObject.DisposeAsync
virtual Task DisposeAsync()
IDisposableAsync.DisposeAsync()
Definition: LogObject.cs:1144

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.Cssx.CssxToCss
Converts CSSX-files to CSS, by evaluating emebedded script and replacing it with results.
Definition: CssxToCss.cs:21

Waher.IoTGateway.Cssx.CssxToCss.ColorToCss
static string ColorToCss(SKColor Color)
Converts a color to its CSS representation.
Definition: CssxToCss.cs:194

Waher.IoTGateway.Export
Static class managing data export.
Definition: Export.cs:18

Waher.IoTGateway.Export.GetFullExportFolderAsync
static async Task< string > GetFullExportFolderAsync()
Full path to export folder.
Definition: Export.cs:22

Waher.IoTGateway.Export.GetFullKeyExportFolderAsync
static async Task< string > GetFullKeyExportFolderAsync()
Full path to key folder.
Definition: Export.cs:35

Waher.IoTGateway.Export.FormatBytes
static string FormatBytes(double Bytes)
Formats a file size using appropriate unit.
Definition: Export.cs:125

Waher.IoTGateway.Gateway
Static class managing the runtime environment of the IoT Gateway.
Definition: Gateway.cs:147

Waher.IoTGateway.Gateway.Domain
static CaseInsensitiveString Domain
Domain name.
Definition: Gateway.cs:3087

Waher.IoTGateway.Gateway.HttpServer
static HttpServer HttpServer
HTTP Server
Definition: Gateway.cs:4118

Waher.IoTGateway.Gateway.InstanceName
static string InstanceName
Name of the current instance. Default instance=string.Empty
Definition: Gateway.cs:3127

Waher.IoTGateway.Gateway.OAuthEnvironment
static OAuth2Environment OAuthEnvironment
OAUTH2 environment reference.
Definition: Gateway.cs:4113

Waher.IoTGateway.Gateway.Terminate
static Task Terminate()
Raises the OnTerminate event handler, letting the container executable know the application needs to ...
Definition: Gateway.cs:3233

Waher.IoTGateway.Gateway.IsDomain
static bool IsDomain(string DomainOrHost, bool IncludeAlternativeDomains)
If a domain or host name represents the gateway.
Definition: Gateway.cs:5174

Waher.IoTGateway.Gateway.AvatarClient
static AvatarClient AvatarClient
XMPP Concentrator Server.
Definition: Gateway.cs:4058

Waher.IoTGateway.Gateway.Certificate
static X509Certificate2 Certificate
Domain certificate.
Definition: Gateway.cs:3082

Waher.IoTGateway.Gateway.DeleteOldFiles
static void DeleteOldFiles(string Path, long KeepDays)
Deletes old files in a folder.
Definition: Gateway.cs:4549

Waher.IoTGateway.Gateway.GetMultiFormatChatMessageXml
static Task< string > GetMultiFormatChatMessageXml(string Markdown)
Gets XML for a multi-formatted chat message.
Definition: Gateway.cs:4959

Waher.IoTGateway.Gateway.DoBackup
static async Task DoBackup()
Performs a backup of the system.
Definition: Gateway.cs:4504

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:3860

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:6085

Waher.IoTGateway.Gateway.NextBytes
static byte[] NextBytes(int NrBytes)
Generates an array of random bytes.
Definition: Gateway.cs:4335

Waher.IoTGateway.Gateway.AppDataFolder
static string AppDataFolder
Application data folder.
Definition: Gateway.cs:3132

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:3198

Waher.IoTGateway.Gateway.AlternativeDomains
static CaseInsensitiveString[] AlternativeDomains
Alternative domain names
Definition: Gateway.cs:3122

Waher.IoTGateway.Gateway.SendNotification
static Task SendNotification(Graph Graph)
Sends a graph as a notification message to configured notification recipients.
Definition: Gateway.cs:4677

Waher.IoTGateway.Gateway.GetUrl
static string GetUrl(string LocalResource)
Gets a URL for a resource.
Definition: Gateway.cs:5079

Waher.IoTGateway.Gateway.MucClient
static MultiUserChatClient MucClient
XMPP Multi-User Chat Protocol (MUC) Client.
Definition: Gateway.cs:4088

Waher.IoTGateway.Gateway.JwtFactory
static JwtFactory JwtFactory
JWT Factory, used to create and validate JWT tokens.
Definition: Gateway.cs:3186

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:5656

Waher.IoTGateway.Gateway.ScheduleEvent
static DateTime ScheduleEvent(Action< object > Callback, DateTime When, object State)
Schedules a one-time event.
Definition: Gateway.cs:4253

Waher.IoTGateway.Gateway.GetNotificationAddresses
static CaseInsensitiveString[] GetNotificationAddresses()
Returns configured notification addresses.
Definition: Gateway.cs:4807

Waher.IoTGateway.Gateway.XmppClient
static XmppClient XmppClient
XMPP Client connection of gateway.
Definition: Gateway.cs:4038

Waher.IoTGateway.Gateway.RootFolder
static string RootFolder
Web root folder.
Definition: Gateway.cs:3142

Waher.IoTGateway.Gateway.HasDomain
static bool HasDomain
If a domain name is configured.
Definition: Gateway.cs:3093

Waher.IoTGateway.Gateway.CancelScheduledEvent
static bool CancelScheduledEvent(DateTime When)
Cancels a scheduled event.
Definition: Gateway.cs:4275

Waher.IoTGateway.Gateway.SoftwareUpdateClient
static SoftwareUpdateClient SoftwareUpdateClient
XMPP Software Updates Client, if such a compoent is available on the XMPP broker.
Definition: Gateway.cs:4098

Waher.IoTGateway.Gateway.ProvisioningClient
static ProvisioningClient ProvisioningClient
XMPP Provisioning Client.
Definition: Gateway.cs:4048

Waher.IoTGateway.Gateway.Root
static HttpFolderResource Root
Root folder resource.
Definition: Gateway.cs:3152

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:20

Waher.IoTGateway.ScriptExtensions.Constants.Theme.CurrentTheme
static ThemeDefinition CurrentTheme
Current theme.
Definition: Theme.cs:90

Waher.IoTGateway.Setup.DomainConfiguration
Domain Configuration
Definition: DomainConfiguration.cs:32

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:159

Waher.IoTGateway.Setup.XmppConfiguration.BareJid
string BareJid
Bare JID
Definition: XmppConfiguration.cs:283

Waher.IoTGateway.Setup.XmppConfiguration.Instance
static XmppConfiguration Instance
Current instance of configuration.
Definition: XmppConfiguration.cs:102

Waher.IoTGateway.Tokenizers.MarkdownTokenizer
Tokenizes contents defined in a Markdown document.
Definition: MarkdownTokenizer.cs:20

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:144

Waher.Networking.CommunicationLayer.Add
virtual void Add(ISniffer Sniffer)
ICommunicationLayer.Add
Definition: CommunicationLayer.cs:56

Waher.Networking.DNS.Communication.DnsMessage
Represents a DNS message
Definition: DnsMessage.cs:11

Waher.Networking.DNS.Communication.DnsMessage.Questions
Question[] Questions
Question section
Definition: DnsMessage.cs:120

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:9

Waher.Networking.DNS.Communication.Question.QNAME
string QNAME
Query Name
Definition: Question.cs:30

Waher.Networking.DNS.Communication.Question.QTYPE
QTYPE QTYPE
Query TYPE
Definition: Question.cs:35

Waher.Networking.DNS.Communication.Question.QCLASS
QCLASS QCLASS
Query CLASS
Definition: Question.cs:40

Waher.Networking.DNS.DnsResolver
DNS resolver, as defined in:
Definition: DnsResolver.cs:32

Waher.Networking.DNS.DnsResolver.TryQuery
static Task< DnsResponse > TryQuery(string Name, QTYPE TYPE, QCLASS CLASS)
Tries to query a DNS name.
Definition: DnsResolver.cs:424

Waher.Networking.DNS.HTTPS.DnsOverHttpsResource
DNS over HTTPS resource.
Definition: DnsOverHttpsResource.cs:14

Waher.Networking.FTP.Server.FtpServer
Implements a simple FTP Server, as defined in:
Definition: FtpServer.cs:38

Waher.Networking.FTP.Server.FtpServer.ExternalSniffers
CommunicationLayer ExternalSniffers
External Sniffers for FTP communication.
Definition: FtpServer.cs:419

Waher.Networking.FTP.Server.FtpServer.Dispose
void Dispose()
IDisposable.Dispose
Definition: FtpServer.cs:594

Waher.Networking.FTP.Server.FtpServer.UpdateCertificate
void UpdateCertificate(X509Certificate ServerCertificate)
Updates the server certificate
Definition: FtpServer.cs:514

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.HttpAuthenticationScheme
Base class for all HTTP authentication schemes, as defined in RFC-7235: https://datatracker....
Definition: HttpAuthenticationScheme.cs:12

Waher.Networking.HTTP.HttpException.HeaderFields
KeyValuePair< string, string >[] HeaderFields
HTTP Header fields to include in the response.
Definition: HttpException.cs:284

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:295

Waher.Networking.HTTP.HttpException.ContentType
string ContentType
The content type of Content, if provided.
Definition: HttpException.cs:329

Waher.Networking.HTTP.HttpException.StatusCode
int StatusCode
HTTP Status Code.
Definition: HttpException.cs:279

Waher.Networking.HTTP.HttpException.Content
byte[] Content
Any encoded content to return.
Definition: HttpException.cs:324

Waher.Networking.HTTP.HttpFolderResource
Publishes a folder with all its files and subfolders through HTTP GET, with optional support for PUT,...
Definition: HttpFolderResource.cs:44

Waher.Networking.HTTP.HttpFolderResource.SendResponse
static Task SendResponse(string FullPath, string ContentType, string ETag, DateTime LastModified, bool LastModifiedUpdated, HttpResponse Response)
Sends a file-based response back to the client.
Definition: HttpFolderResource.cs:610

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:222

Waher.Networking.HTTP.HttpRequest
Represents an HTTP request.
Definition: HttpRequest.cs:22

Waher.Networking.HTTP.HttpRequest.Header
HttpRequestHeader Header
Request header.
Definition: HttpRequest.cs:182

Waher.Networking.HTTP.HttpRequest.RemoteEndPoint
string RemoteEndPoint
Remote end-point.
Definition: HttpRequest.cs:243

Waher.Networking.HTTP.HttpRequest.Session
SessionVariables Session
Contains session states, if the resource requires sessions, or null otherwise.
Definition: HttpRequest.cs:212

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:194

Waher.Networking.HTTP.HttpRequest.Response
HttpResponse Response
HTTP Response object, if one has been assigned to the request.
Definition: HttpRequest.cs:254

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:258

Waher.Networking.HTTP.HttpResponse
Represets a response of an HTTP client request.
Definition: HttpResponse.cs:23

Waher.Networking.HTTP.HttpResponse.DisposeAsync
async Task DisposeAsync()
Closes the connection and disposes of all resources.
Definition: HttpResponse.cs:468

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:597

Waher.Networking.HTTP.HttpResponse.Write
Task Write(byte[] Data)
Returns binary data in the response.
Definition: HttpResponse.cs:1369

Waher.Networking.HTTP.HttpResponse.SetHeader
void SetHeader(string FieldName, string Value)
Sets a custom header field value.
Definition: HttpResponse.cs:259

Waher.Networking.HTTP.HttpResponse.TransferEncoding
TransferEncoding TransferEncoding
Transfer encoding in response.
Definition: HttpResponse.cs:573

Waher.Networking.HTTP.HttpReverseProxyResource
An HTTP Reverse proxy resource. Incoming requests are reverted to a another web server for processing...
Definition: HttpReverseProxyResource.cs:26

Waher.Networking.HTTP.HttpServer
Implements an HTTP server.
Definition: HttpServer.cs:41

Waher.Networking.HTTP.HttpServer.OpenHttpPorts
int[] OpenHttpPorts
HTTP Ports successfully opened.
Definition: HttpServer.cs:768

Waher.Networking.HTTP.HttpServer.GetCommunicationStatisticsSinceLast
CommunicationStatistics GetCommunicationStatisticsSinceLast()
Gets communication statistics since last call.
Definition: HttpServer.cs:2263

Waher.Networking.HTTP.HttpServer.CreateSessionVariables
static SessionVariables CreateSessionVariables()
Creates a new collection of variables, that contains access to the global set of variables.
Definition: HttpServer.cs:2130

Waher.Networking.HTTP.HttpServer.Register
HttpResource Register(HttpResource Resource)
Registers a resource with the server.
Definition: HttpServer.cs:1568

Waher.Networking.HTTP.HttpServer.DefaultHttpPort
const int DefaultHttpPort
Default HTTP Port (80).
Definition: HttpServer.cs:45

Waher.Networking.HTTP.HttpServer.GetMTlsSettings
void GetMTlsSettings(int Port, out ClientCertificates ClientCertificates, out bool TrustClientCertificates)
Gets mTLS settings for a given port number.
Definition: HttpServer.cs:979

Waher.Networking.HTTP.HttpServer.OpenHttpsPorts
int[] OpenHttpsPorts
HTTPS Ports successfully opened.
Definition: HttpServer.cs:773

Waher.Networking.HTTP.HttpServer.Unregister
bool Unregister(HttpResource Resource)
Unregisters a resource from the server.
Definition: HttpServer.cs:1743

Waher.Networking.HTTP.HttpServer.DefaultHttpsPort
const int DefaultHttpsPort
Default HTTPS port (443).
Definition: HttpServer.cs:50

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:10

Waher.Networking.SMTP.Server.SmtpServer
Implements a simple SMTP Server, as defined in:
Definition: SmtpServer.cs:45

Waher.Networking.SMTP.Server.SmtpServer.ExternalSniffers
CommunicationLayer ExternalSniffers
External Sniffers for SMTP communication.
Definition: SmtpServer.cs:225

Waher.Networking.SMTP.Server.SmtpServer.UpdateCertificate
void UpdateCertificate(X509Certificate ServerCertificate)
Updates the server certificate
Definition: SmtpServer.cs:305

Waher.Networking.SMTP.Server.SmtpServer.Dispose
void Dispose()
IDisposable.Dispose
Definition: SmtpServer.cs:323

Waher.Networking.Sniffers.XmlFileSniffer
Outputs sniffed data to an XML file.
Definition: XmlFileSniffer.cs:15

Waher.Networking.XMPP.Concentrator.ConcentratorServer
Implements an XMPP concentrator server interface.
Definition: ConcentratorServer.cs:42

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.Contracts.Attachment
Contains a reference to an attachment assigned to a legal object.
Definition: Attachment.cs:10

Waher.Networking.XMPP.Contracts.Attachment.ContentType
string ContentType
Internet Content Type of binary attachment.
Definition: Attachment.cs:48

Waher.Networking.XMPP.Contracts.ContractsClient
Adds support for legal identities, smart contracts and signatures to an XMPP client.
Definition: ContractsClient.cs:51

Waher.Networking.XMPP.Contracts.ContractsClient.NamespaceOnboarding
const string NamespaceOnboarding
http://waher.se/schema/Onboarding/v1.xsd
Definition: ContractsClient.cs:134

Waher.Networking.XMPP.Contracts.LegalIdentity
Legal identity
Definition: LegalIdentity.cs:48

Waher.Networking.XMPP.Contracts.LegalIdentity.Parse
static LegalIdentity Parse(string Xml)
Parses an identity from its XML representation
Definition: LegalIdentity.cs:227

Waher.Networking.XMPP.Contracts.Signature
Abstract base class of signatures
Definition: Signature.cs:10

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.Component.IsComponentDomain
bool IsComponentDomain(CaseInsensitiveString Domain, bool IncludeAlternativeDomains)
Checks if a domain is the component domain, or optionally, an alternative component domain.
Definition: Component.cs:124

Waher.Networking.XMPP.Server.HttpFileUpload.FileInfo
Information about a file upload.
Definition: FileInfo.cs:40

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadComponent
Implements HTTP File Upload support as an XMPP component: https://xmpp.org/extensions/xep-0363....
Definition: HttpFileUploadComponent.cs:22

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: HttpFileUploadComponent.cs:101

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadSettings
HTTP File Upload settings.
Definition: HttpFileUploadSettings.cs:9

Waher.Networking.XMPP.Server.HttpFileUpload.HttpFileUploadSettings.InternalTransferFolder
string InternalTransferFolder
Folder where files for internal transfer are stored.
Definition: HttpFileUploadSettings.cs:73

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.InternalTransferAccess
Access scheme used for internal transfer of files between client and server.
Definition: InternalTransferAccess.cs:13

Waher.Networking.XMPP.Server.HttpFileUpload.XmppFileUploadResource
HTTP Resource managing HTTP Uploads, and access to uploaded files.
Definition: XmppFileUploadResource.cs:19

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:139

Waher.Networking.XMPP.Server.IqEventArgs.IqErrorBadRequest
Task IqErrorBadRequest(XmppAddress From, string ErrorText, string Language)
Returns a bad-request error.
Definition: IqEventArgs.cs:164

Waher.Networking.XMPP.Server.IqEventArgs.IqErrorForbidden
Task IqErrorForbidden(XmppAddress From, string ErrorText, string Language)
Returns a forbidden error.
Definition: IqEventArgs.cs:234

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:18

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:69

Waher.Networking.XMPP.Server.XmppServer.ExtendedAddressingNamespace
const string ExtendedAddressingNamespace
http://jabber.org/protocol/address (XEP-0033)
Definition: XmppServer.cs:143

Waher.Networking.XMPP.Server.XmppServer.GetClientConnections
IClientConnection[] GetClientConnections()
Get active client connections
Definition: XmppServer.cs:826

Waher.Networking.XMPP.Server.XmppServer.UpdateCertificate
void UpdateCertificate(X509Certificate ServerCertificate)
Updates the server certificate
Definition: XmppServer.cs:946

Waher.Networking.XMPP.Server.XmppServer.S2sSniffers
CommunicationLayer S2sSniffers
Sniffers for XMPP S2S communication.
Definition: XmppServer.cs:657

Waher.Networking.XMPP.Server.XmppServer.GetServerConnectionStatistics
S2sEndpointStatistics[] GetServerConnectionStatistics()
Gets S2S connection statistics.
Definition: XmppServer.cs:882

Waher.Networking.XMPP.Server.XmppServer.TryGetClientConnection
bool TryGetClientConnection(string FullJID, out IClientConnection Connection)
Tries to get an active client connection.
Definition: XmppServer.cs:844

Waher.Networking.XMPP.Server.XmppServer.C2sSniffers
CommunicationLayer C2sSniffers
Sniffers for XMPP C2S communication.
Definition: XmppServer.cs:652

Waher.Networking.XMPP.Server.XmppServer.IsServerDomain
bool IsServerDomain(CaseInsensitiveString Domain, bool IncludeAlternativeDomains)
Checks if a domain is the server domain, or optionally, an alternative domain.
Definition: XmppServer.cs:898

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:1691

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:2468

Waher.Networking.XMPP.Server.XmppServer.Dispose
void Dispose()
IDisposable.Dispose
Definition: XmppServer.cs:987

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:323

Waher.Networking.XMPP.Server.XmppServer.GetCommunicationStatisticsSinceLast
Statistics.CommunicationStatistics GetCommunicationStatisticsSinceLast()
Gets communication statistics since last call.
Definition: XmppServer.cs:5649

Waher.Networking.XMPP.Server.XmppServer.DelayedDeliveryNamespace
const string DelayedDeliveryNamespace
urn:xmpp:delay (XEP-0203)
Definition: XmppServer.cs:193

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:6654

Waher.Networking.XMPP.Server.XmppServer.DeleteOldMailContent
async Task< int > DeleteOldMailContent(DateTime OlderThan)
Deletes old mail content.
Definition: XmppServer.cs:6642

Waher.Persistence.CaseInsensitiveString
Represents a case-insensitive string.
Definition: CaseInsensitiveString.cs:11

Waher.Persistence.CaseInsensitiveString.Value
string Value
String-representation of the case-insensitive string. (Representation is case sensitive....
Definition: CaseInsensitiveString.cs:29

Waher.Persistence.CaseInsensitiveString.Empty
static readonly CaseInsensitiveString Empty
Empty case-insensitive string
Definition: CaseInsensitiveString.cs:320

Waher.Persistence.CaseInsensitiveString.IsNullOrEmpty
static bool IsNullOrEmpty(CaseInsensitiveString value)
Indicates whether the specified string is null or an CaseInsensitiveString.Empty string.
Definition: CaseInsensitiveString.cs:1045

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:1244

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:2202

Waher.Persistence.Database
Static interface for database persistence. In order to work, a database provider has to be assigned t...
Definition: Database.cs:21

Waher.Persistence.Database.GetDictionary
static Task< IPersistentDictionary > GetDictionary(string Collection)
Gets a persistent dictionary containing objects in a collection.
Definition: Database.cs:2307

Waher.Persistence.Database.EndBulk
static Task EndBulk()
Ends bulk-processing of data. Must be called once for every call to StartBulk.
Definition: Database.cs:2259

Waher.Persistence.Database.StartBulk
static Task StartBulk()
Starts bulk-proccessing of data. Must be followed by a call to EndBulk.
Definition: Database.cs:2251

Waher.Persistence.Database.Update
static async Task Update(object Object)
Updates an object in the database.
Definition: Database.cs:1211

Waher.Persistence.Database.Delete
static async Task Delete(object Object)
Deletes an object in the database.
Definition: Database.cs:1291

Waher.Persistence.Database.Find
static Task< IEnumerable< object > > Find(string Collection, params string[] SortOrder)
Finds objects in a given collection.
Definition: Database.cs:238

Waher.Persistence.Database.Insert
static async Task Insert(object Object)
Inserts an object into the default collection of the database.
Definition: Database.cs:97

Waher.Persistence.Database.Clear
static async Task Clear(string CollectionName)
Clears a collection of all objects.
Definition: Database.cs:1965

Waher.Persistence.Files.FilesProvider
Persists objects into binary files.
Definition: FilesProvider.cs:61

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:30

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:1431

Waher.Persistence.FullTextSearch.PropertyDefinition
Defines an indexable property.
Definition: PropertyDefinition.cs:33

Waher.Persistence.FullTextSearch.Search
Static class for access to Full-Text-Search
Definition: Search.cs:67

Waher.Persistence.FullTextSearch.Search.AddFullTextSearch
static Task< bool > AddFullTextSearch(string CollectionName, params PropertyDefinition[] Properties)
Adds properties for full-text-search indexation.
Definition: Search.cs:225

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:169

Waher.Persistence.FullTextSearch.Search.SetFullTextSearchIndexCollection
static Task< bool > SetFullTextSearchIndexCollection(string IndexCollection, string CollectionName)
Defines the Full-text-search index collection name, for objects in a given collection.
Definition: Search.cs:214

Waher.Persistence.FullTextSearch.Search.ReindexCollection
static Task< long > ReindexCollection(string IndexCollectionName)
Reindexes the full-text-search index for a database collection.
Definition: Search.cs:285

Waher.Persistence.FullTextSearch.Tokenizers.TokenizationProcess
Contains information about a tokenization process.
Definition: TokenizationProcess.cs:11

Waher.Persistence.Serialization.FullSerialization
Provides a Serializer context for full serialization.
Definition: FullSerialization.cs:10

Waher.Runtime.Cache.Cache
Implements an in-memory cache.
Definition: Cache.cs:17

Waher.Runtime.Cache.Cache.ContainsKey
bool ContainsKey(KeyType Key)
Checks if a key is available in the cache.
Definition: Cache.cs:404

Waher.Runtime.Cache.Cache.Dispose
void Dispose()
IDisposable.Dispose
Definition: Cache.cs:99

Waher.Runtime.Cache.Cache.TryGetValue
bool TryGetValue(KeyType Key, out ValueType Value)
Tries to get a value from the cache.
Definition: Cache.cs:311

Waher.Runtime.Cache.Cache.Add
void Add(KeyType Key, ValueType Value)
Adds an item to the cache.
Definition: Cache.cs:446

Waher.Runtime.Cache.CacheItemEventArgs
Event arguments for cache item removal events.
Definition: CacheItemEventArgs.cs:42

Waher.Runtime.Cache.CacheItemEventArgs.Value
ValueType Value
Value of item that was removed.
Definition: CacheItemEventArgs.cs:62

Waher.Runtime.IO.Files
Contains static methods
Definition: Files.cs:14

Waher.Runtime.IO.Resources
Static class managing loading of resources stored as embedded resources or in content files.
Definition: Resources.cs:13

Waher.Runtime.IO.Resources.LoadResource
static byte[] LoadResource(string ResourceName)
Loads a resource from an embedded resource.
Definition: Resources.cs:20

Waher.Runtime.Inventory.Types
Static class that dynamically manages types and interfaces available in the runtime environment.
Definition: Types.cs:15

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:584

Waher.Runtime.Inventory.Types.GetType
static Type GetType(string FullName)
Gets a type, given its full name.
Definition: Types.cs:42

Waher.Runtime.Inventory.Types.TryGetModuleParameter
static bool TryGetModuleParameter(string Name, out object Value)
Tries to get a module parameter value.
Definition: Types.cs:607

Waher.Runtime.Inventory.Types.Assemblies
static Assembly[] Assemblies
Assemblies in the inventory.
Definition: Types.cs:948

Waher.Runtime.Inventory.Types.NoParameters
static object[] NoParameters
Contains an empty array of parameter values.
Definition: Types.cs:572

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:1454

Waher.Runtime.Inventory.Types.GetTypesImplementingInterface
static Type[] GetTypesImplementingInterface(string InterfaceFullName)
Gets all types implementing a given interface.
Definition: Types.cs:85

Waher.Runtime.Queue.AsyncProcessor
Processes work tasks, in an asynchronous manner.
Definition: AsyncProcessor.cs:14

Waher.Runtime.Queue.AsyncProcessor.Name
string Name
Name of processor.
Definition: AsyncProcessor.cs:193

Waher.Runtime.Queue.AsyncProcessors
Maintains a record of active processors.
Definition: AsyncProcessors.cs:10

Waher.Runtime.Queue.AsyncProcessors.GetActiveProcessors
static IAsyncProcessor[] GetActiveProcessors()
Gets an array of all active processors.
Definition: AsyncProcessors.cs:46

Waher.Runtime.Queue.AsyncProcessors.CloseAllProcessorsForTermination
static Task CloseAllProcessorsForTermination()
Closes all active processors for new items.
Definition: AsyncProcessors.cs:73

Waher.Runtime.Queue.AsyncProcessors.HasActiveProcessors
static bool HasActiveProcessors
If there are active processors.
Definition: AsyncProcessors.cs:60

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.Statistics.Bucket
Statistical bucket
Definition: Bucket.cs:21

Waher.Runtime.Statistics.Buckets
A collection of buckets
Definition: Buckets.cs:14

Waher.Runtime.Statistics.Buckets.TryGetBucket
bool TryGetBucket(string Id, out Bucket Bucket)
Tries to get a bucket, given its ID.
Definition: Buckets.cs:284

Waher.Runtime.Statistics.Buckets.Sample
async Task< SampleStatistic > Sample(string Counter, double Value)
Samples a value
Definition: Buckets.cs:199

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:12

Waher.Runtime.Temporary.TemporaryFile.Dispose
override void Dispose(bool disposing)
Disposes of the object, and deletes the temporary file.
Definition: TemporaryFile.cs:66

Waher.Runtime.Temporary.TemporaryFile.FileName
string FileName
File Name.
Definition: TemporaryFile.cs:52

Waher.Runtime.Temporary.TemporaryProgressStream
Class managing the contents of a temporary stream. When the class is disposed, any temporary file is ...
Definition: TemporaryProgressStream.cs:12

Waher.Runtime.Temporary.TemporaryStream
Manages a temporary stream. Contents is kept in-memory, if below a memory threshold,...
Definition: TemporaryStream.cs:14

Waher.Runtime.Temporary.TemporaryStream.WriteByte
override void WriteByte(byte value)
Writes a byte to the current position in the stream and advances the position within the stream by on...
Definition: TemporaryStream.cs:311

Waher.Runtime.Temporary.TemporaryStream.WriteAsync
override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
Asynchronously writes a sequence of bytes to the current stream, advances the current position within...
Definition: TemporaryStream.cs:298

Waher.Runtime.Threading.Semaphore
Represents a named semaphore, i.e. an object, identified by a name, that allows single concurrent wri...
Definition: Semaphore.cs:19

Waher.Runtime.Threading.Semaphores
Static class of application-wide semaphores that can be used to order access to editable objects.
Definition: Semaphores.cs:17

Waher.Runtime.Threading.Semaphores.BeginWrite
static async Task< Semaphore > BeginWrite(string Key)
Waits until the semaphore identified by Key  is ready for writing. Each call to BeginWrite must be fo...
Definition: Semaphores.cs:91

Waher.Script.Abstraction.Elements.Element
Base class for all types of elements.
Definition: Element.cs:14

Waher.Script.Exceptions.ScriptBreakLoopException
Exception used to break a loop.
Definition: ScriptBreakLoopException.cs:9

Waher.Script.Exceptions.ScriptContinueLoopException
Exception used to continue a loop.
Definition: ScriptContinueLoopException.cs:9

Waher.Script.Exceptions.ScriptReturnValueException
Script runtime exception.
Definition: ScriptReturnValueException.cs:9

Waher.Script.Exceptions.ScriptReturnValueException.ReturnValue
IElement ReturnValue
Return value.
Definition: ScriptReturnValueException.cs:27

Waher.Script.Expression
Class managing a script expression.
Definition: Expression.cs:41

Waher.Script.Expression.Root
ScriptNode Root
Root script node.
Definition: Expression.cs:4496

Waher.Script.Expression.EvaluateAsync
async Task< object > EvaluateAsync(Variables Variables)
Evaluates the expression, using the variables provided in the Variables  collection....
Definition: Expression.cs:4461

Waher.Script.Expression.TryGetConstant
static bool TryGetConstant(string Name, Variables Variables, out IElement ValueElement)
Tries to get a constant value, given its name.
Definition: Expression.cs:3382

Waher.Script.Expression.ToExpressionString
static string ToExpressionString(object Value)
Converts an object to a string, that can be parsed as part of an expression.
Definition: Expression.cs:5052

Waher.Script.Graphs.Graph
Base class for graphs.
Definition: Graph.cs:88

Waher.Script.Model.ScriptNode
Base class for all nodes in a parsed script tree.
Definition: ScriptNode.cs:69

Waher.Script.Model.ScriptNode.WaitPossibleTask
static async Task< object > WaitPossibleTask(object Result)
Waits for any asynchronous process to terminate.
Definition: ScriptNode.cs:441

Waher.Script.Model.ScriptNode.EvaluateAsync
virtual Task< IElement > EvaluateAsync(Variables Variables)
Evaluates the node, using the variables provided in the Variables  collection. This method should be ...
Definition: ScriptNode.cs:158

Waher.Script.Objects.Matrices.ObjectMatrix
Object-valued matrix.
Definition: ObjectMatrix.cs:18

Waher.Script.Objects.Namespace
Namespace.
Definition: Namespace.cs:13

Waher.Script.Objects.ObjectValue
Object value.
Definition: ObjectValue.cs:14

Waher.Script.Objects.ObjectValue.Null
static readonly ObjectValue Null
Null value.
Definition: ObjectValue.cs:88

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.Persistence.SQL.Record
Represents one record.
Definition: Record.cs:9

Waher.Script.Persistence.SQL.Sources.TypeSource
Data Source defined by a type definition
Definition: TypeSource.cs:22

Waher.Script.Persistence.SQL.Sources.TypeSource.FindMethod
static MethodInfo FindMethod
Generic object database Find method: Database.Find<T>(int, int, Filter, string[])
Definition: TypeSource.cs:102

Waher.Script.PreviewEventArgs
Event arguments for preview events.
Definition: PreviewEventArgs.cs:10

Waher.Script.PreviewEventArgs.Preview
IElement Preview
Preview of result.
Definition: PreviewEventArgs.cs:41

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:126

Waher.Script.Variables.TryGetVariable
virtual bool TryGetVariable(string Name, out Variable Variable)
Tries to get a variable object, given its name.
Definition: Variables.cs:56

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:57

Waher.Security.Hashes.ComputeSHA256HashString
static string ComputeSHA256HashString(byte[] Data)
Computes the SHA-256 hash of a block of binary data.
Definition: Hashes.cs:449

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:63

Waher.Security.JWT.JwtAuthentication
Use JWT tokens for authentication. The Bearer scheme defined in RFC 6750 is used: https://tools....
Definition: JwtAuthentication.cs:17

Waher.Security.JWT.JwtAuthentication.GetAccessToken
static string GetAccessToken(HttpRequest Request)
Gets the access token from an HTTP request.
Definition: JwtAuthentication.cs:247

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:66

Waher.Security.JWT.JwtFactory.IsValid
bool IsValid(JwtToken Token)
Checks if a token is valid and signed by the factory.
Definition: JwtFactory.cs:279

Waher.Security.JWT.JwtFactory.Create
string Create(params KeyValuePair< string, object >[] Claims)
Creates a new JWT token.
Definition: JwtFactory.cs:379

Waher.Security.JWT.JwtToken
Contains information about a Java Web Token (JWT). JWT is defined in RFC 7519: https://tools....
Definition: JwtToken.cs:22

Waher.Security.JWT.JwtToken.TryParse
static bool TryParse(string Token, out JwtToken ParsedToken)
Tries to parse a JWT token.
Definition: JwtToken.cs:68

Waher.Security.LoginMonitor.AnnotateEndpointEventArgs
Event arguments for endpoint annotation events.
Definition: AnnotateEndpointEventArgs.cs:11

Waher.Security.LoginMonitor.AnnotateEndpointEventArgs.RemoteEndPoint
string RemoteEndPoint
Remote endpoint.
Definition: AnnotateEndpointEventArgs.cs:27

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.LoginAuditor
Class that monitors login events, and help applications determine malicious intent....
Definition: LoginAuditor.cs:26

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:485

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:590

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:298

Waher.Security.LoginMonitor.LoginAuditor.Fail
static void Fail(string Message, string UserName, string RemoteEndPoint, string Protocol)
Handles a failed login attempt.
Definition: LoginAuditor.cs:540

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:408

Waher.Security.SHA3.SHAKE256
Implements the SHA3 SHAKE256 extendable-output functions, as defined in section 6....
Definition: SHAKE256.cs:9

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:24

Waher.Security.Users.User.UserName
string UserName
User Name
Definition: User.cs:60

Waher.Security.Users.User.CreateToken
async Task< string > CreateToken(JwtFactory Factory, bool Encrypted, params KeyValuePair< string, object >[] AdditionalClaims)
Creates a JWT Token referencing the user object.
Definition: User.cs:330

Waher.Security.Users.User.HasPrivilege
bool HasPrivilege(string Privilege)
If the user has a given privilege.
Definition: User.cs:187

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.Security.Users.Users.Source
static IUserSource Source
User source.
Definition: Users.cs:37

Waher.Service.IoTBroker.Admin.ChatState
State of a chat session
Definition: ChatState.cs:11

Waher.Service.IoTBroker.Admin.ChatState.Files
readonly Dictionary< string, FileInfo > Files
Currently accesible files
Definition: ChatState.cs:39

Waher.Service.IoTBroker.Admin.ChatState.Processes
readonly LinkedList< Process > Processes
Current processes related to session
Definition: ChatState.cs:44

Waher.Service.IoTBroker.Admin.ChatState.To
string To
Remote endpoint
Definition: ChatState.cs:24

Waher.Service.IoTBroker.Admin.ChatState.Folder
string Folder
Current folder
Definition: ChatState.cs:34

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:21

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:41

Waher.Service.IoTBroker.DataStorage.ApiKey
Definition: ApiKey.cs:16

Waher.Service.IoTBroker.DataStorage.Avatar
Definition: Avatar.cs:12

Waher.Service.IoTBroker.DataStorage.IP4Localization
Definition: IP4Localization.cs:11

Waher.Service.IoTBroker.DataStorage.PersistenceLayer
Definition: PersistenceLayer.cs:39

Waher.Service.IoTBroker.DataStorage.PersistenceLayer.GetRosterItem
async Task< IRosterItem > GetRosterItem(CaseInsensitiveString UserName, CaseInsensitiveString Jid)
Gets a roster item for an account.
Definition: PersistenceLayer.cs:646

Waher.Service.IoTBroker.DataStorage.PersistenceLayer.DeleteOfflineMessages
async Task DeleteOfflineMessages(IEnumerable< IOfflineMessage > Messages)
Deletes offline messages.
Definition: PersistenceLayer.cs:1508

Waher.Service.IoTBroker.DataStorage.PersistenceLayer.GetRoster
async Task< IEnumerable< IRosterItem > > GetRoster(CaseInsensitiveString UserName)
Gets the roster of an account.
Definition: PersistenceLayer.cs:596

Waher.Service.IoTBroker.DataStorage.RosterItem
Definition: RosterItem.cs:12

Waher.Service.IoTBroker.DataStorage.Tokenizers.AccountTokenizer
Tokenizes (for full-text-search) a broker account.
Definition: AccountTokenizer.cs:14

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.GeoSpatial.GeoSpatialComponent
Definition: GeoSpatialComponent.cs:22

Waher.Service.IoTBroker.GeoSpatial.GeoSpatialComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: GeoSpatialComponent.cs:105

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.Attachments.AttachmentCache
Attachment cache
Definition: AttachmentCache.cs:19

Waher.Service.IoTBroker.Legal.Attachments.AttachmentCache.DeleteOldAttachments
static async Task< int > DeleteOldAttachments()
Deletes old attachments from the cache and database.
Definition: AttachmentCache.cs:161

Waher.Service.IoTBroker.Legal.Contracts.Tokenizers.HumanReadableTextsTokenizer
Tokenizes a set of human readable texts.
Definition: HumanReadableTextsTokenizer.cs:19

Waher.Service.IoTBroker.Legal.Contracts.Tokenizers.ParametersTokenizer
Tokenizes a set of parameters.
Definition: ParametersTokenizer.cs:18

Waher.Service.IoTBroker.Legal.Contracts.Tokenizers.RolesTokenizer
Tokenizes a set of roles.
Definition: RolesTokenizer.cs:18

Waher.Service.IoTBroker.Legal.Contracts.ValidationSchema
Definition: ValidationSchema.cs:19

Waher.Service.IoTBroker.Legal.Contracts.ValidationSchema.XmlSchema
byte[] XmlSchema
XML Schema
Definition: ValidationSchema.cs:72

Waher.Service.IoTBroker.Legal.Identity.LegalIdentity
Definition: LegalIdentity.cs:32

Waher.Service.IoTBroker.Legal.Identity.Tokenizers.PropertiesTokenizer
Tokenizes a role.
Definition: PropertiesTokenizer.cs:17

Waher.Service.IoTBroker.Legal.LegalComponent
Legal (digital identities, smart contracts) service component.
Definition: LegalComponent.cs:68

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceSmartContractsNeuroFoundationV1
const string NamespaceSmartContractsNeuroFoundationV1
urn:nf:iot:leg:sc:1.0
Definition: LegalComponent.cs:106

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceLegalIdentityIeeeV1
const string NamespaceLegalIdentityIeeeV1
urn:ieee:iot:leg:id:1.0
Definition: LegalComponent.cs:72

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceLegalIdentityNeuroFoundationV1
const string NamespaceLegalIdentityNeuroFoundationV1
urn:nf:iot:leg:id:1.0
Definition: LegalComponent.cs:77

Waher.Service.IoTBroker.Legal.LegalComponent.GetOnboardingNeuronDomainName
static Task< string > GetOnboardingNeuronDomainName()
Gets the domain name of the Nnboarding Neuron.
Definition: LegalComponent.cs:547

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceE2ENeuroFoundationV1
const string NamespaceE2ENeuroFoundationV1
urn:nf:iot:e2e:1.0
Definition: LegalComponent.cs:135

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceSmartContractsIeeeV1
const string NamespaceSmartContractsIeeeV1
urn:ieee:iot:leg:sc:1.0
Definition: LegalComponent.cs:101

Waher.Service.IoTBroker.Legal.LegalComponent.NamespaceE2EIeeeV1
const string NamespaceE2EIeeeV1
urn:ieee:iot:e2e:1.0
Definition: LegalComponent.cs:130

Waher.Service.IoTBroker.Legal.LegalComponent.GetPublicKey
static Tuple< IE2eEndpoint, DateTime?, DateTime?> GetPublicKey(DateTime? Timestamp)
Returns the public key of the legal component, optionally, for a given point in time....
Definition: LegalComponent.cs:581

Waher.Service.IoTBroker.Legal.LegalComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: LegalComponent.cs:342

Waher.Service.IoTBroker.Legal.MFA.MultiFactorAuthentication
Web resource that allows calling applications to enable Multi-Factor Authentication using legal ident...
Definition: MultiFactorAuthentication.cs:19

Waher.Service.IoTBroker.Legal.MFA.QuickLogin
Web resource that allows calling applications to enable Quick-Login using legal identities.
Definition: QuickLogin.cs:41

Waher.Service.IoTBroker.Legal.MFA.QuickLogin.UserVariableName
const string UserVariableName
QuickLoginUser
Definition: QuickLogin.cs:50

Waher.Service.IoTBroker.Legal.MFA.RemoteLogin
Web resource that permits authentication of users into their remote systems, by triggering a digital ...
Definition: RemoteLogin.cs:50

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:64

Waher.Service.IoTBroker.NeuroFeatures.Tokenizers.NeuroFeatureTokenizer
Tokenizes (for full-text-search) a Neuro-Feature token.
Definition: NeuroFeatureTokenizer.cs:15

Waher.Service.IoTBroker.NeuroFeatures.WebServices.AddNote
Adds an external note to a token.
Definition: AddNote.cs:21

Waher.Service.IoTBroker.NeuroFeatures.WebServices.PublicTokenHistoryView
Public token history view.
Definition: PublicTokenHistoryView.cs:17

Waher.Service.IoTBroker.NeuroFeatures.WebServices.PublicTokenView
Public token view.
Definition: PublicTokenView.cs:19

Waher.Service.IoTBroker.Paiwise.PaiwiseProcessor
Paiwise processor, processing payment instructions defined in smart contracts.
Definition: PaiwiseProcessor.cs:36

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent
Provisioning and registry service component.
Definition: ProvisioningComponent.cs:35

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningOwnerIeeeV1
const string NamespaceProvisioningOwnerIeeeV1
urn:ieee:iot:prov:o:1.0
Definition: ProvisioningComponent.cs:59

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceSoftwareUpdatesNeuroFoundationV1
const string NamespaceSoftwareUpdatesNeuroFoundationV1
urn:nf:iot:swu:1.0
Definition: ProvisioningComponent.cs:89

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningTokenNeuroFoundationV1
const string NamespaceProvisioningTokenNeuroFoundationV1
urn:nf:iot:prov:t:1.0
Definition: ProvisioningComponent.cs:44

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceIoTDiscoveryNeuroFoundationV1
const string NamespaceIoTDiscoveryNeuroFoundationV1
urn:nf:iot:disco:1.0
Definition: ProvisioningComponent.cs:79

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningTokenIeeeV1
const string NamespaceProvisioningTokenIeeeV1
urn:ieee:iot:prov:t:1.0
Definition: ProvisioningComponent.cs:39

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningDeviceIeeeV1
const string NamespaceProvisioningDeviceIeeeV1
urn:ieee:iot:prov:d:1.0
Definition: ProvisioningComponent.cs:49

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceIoTDiscoveryIeeeV1
const string NamespaceIoTDiscoveryIeeeV1
urn:ieee:iot:disco:1.0
Definition: ProvisioningComponent.cs:74

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: ProvisioningComponent.cs:271

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceIoTDiscoveryXsfV0
const string NamespaceIoTDiscoveryXsfV0
urn:xmpp:iot:discovery
Definition: ProvisioningComponent.cs:69

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningOwnerNeuroFoundationV1
const string NamespaceProvisioningOwnerNeuroFoundationV1
urn:nf:iot:prov:o:1.0
Definition: ProvisioningComponent.cs:64

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceSoftwareUpdatesIeeeV1
const string NamespaceSoftwareUpdatesIeeeV1
urn:ieee:iot:swu:1.0
Definition: ProvisioningComponent.cs:84

Waher.Service.IoTBroker.Provisioning.ProvisioningComponent.NamespaceProvisioningDeviceNeuroFoundationV1
const string NamespaceProvisioningDeviceNeuroFoundationV1
urn:nf:iot:prov:d:1.0
Definition: ProvisioningComponent.cs:54

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package
Contains information about a software package.
Definition: Package.cs:21

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.PublicKey
byte[] PublicKey
Public key of issuer, used to create signature.
Definition: Package.cs:55

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Signature
byte[] Signature
Cryptographic signature of package, as calculated by the issuer of the package.
Definition: Package.cs:49

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Installed
DateTime Installed
When package was installed (if installed).
Definition: Package.cs:97

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.ContentOnly
bool ContentOnly
If package only contains content (i.e. no assemblies and executable files).
Definition: Package.cs:115

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.FileName
CaseInsensitiveString FileName
Filename of package.
Definition: Package.cs:43

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Published
DateTime Published
When package was published.
Definition: Package.cs:79

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Url
string Url
URL of package.
Definition: Package.cs:120

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.AesKey
byte[] AesKey
Symmetric cipher used to encrypt package file.
Definition: Package.cs:61

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Bytes
long Bytes
Number of bytes of package.
Definition: Package.cs:103

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Supersedes
DateTime Supersedes
Timestamp of superceded package.
Definition: Package.cs:85

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.Package.Created
DateTime Created
When package record was created
Definition: Package.cs:91

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates.PackageUrlValidator
Definition: PackageUrlValidator.cs:12

Waher.Service.IoTBroker.PubSub.PubSubComponent
PubSub component, as defined in XEP-0060. https://xmpp.org/extensions/xep-0060.html
Definition: PubSubComponent.cs:32

Waher.Service.IoTBroker.PubSub.PubSubComponent.DeleteExpiredNodes
async Task<(int, int)> DeleteExpiredNodes()
Deletes expired nodes
Definition: PubSubComponent.cs:4566

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:501

Waher.Service.IoTBroker.PubSub.PubSubComponent.Dispose
override void Dispose()
IDisposable.Dispose
Definition: PubSubComponent.cs:398

Waher.Service.IoTBroker.PubSub.PubSubComponent.Create
static async Task< PubSubComponent > Create(XmppServer Server, CaseInsensitiveString Subdomain, string Name)
PubSub component, as defined in XEP-0060.
Definition: PubSubComponent.cs:324

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.PerformanceAlertMonitor
Monitors performance samples, and alerts the operator if performance levels degrate.
Definition: PerformanceAlertMonitor.cs:11

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:27

Waher.Service.IoTBroker.Setup.RelayConfiguration.Instance
static RelayConfiguration Instance
Current instance of configuration.
Definition: RelayConfiguration.cs:121

Waher.Service.IoTBroker.Setup.RelayConfiguration.ConfigureSystem
override Task ConfigureSystem()
Is called during startup to configure the system.
Definition: RelayConfiguration.cs:146

Waher.Service.IoTBroker.Sources.Connections.ConnectionsSource
Definition: ConnectionsSource.cs:15

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:33

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:19

Waher.Service.IoTBroker.Sources.GatewayConfig.ProxyResource.Encrypted
bool Encrypted
If forwarded requests are encrypted (HTTPS) or not (HTTP).
Definition: ProxyResource.cs:109

Waher.Service.IoTBroker.Sources.ProgramData.ProgramDataSource
Data source mirroring the ProgramData folder for the broker.
Definition: ProgramDataSource.cs:19

Waher.Service.IoTBroker.Sources.Reports.Events.Commands.EventStatistic
Definition: EventStatistic.cs:11

Waher.Service.IoTBroker.Sources.Reports.Events.EventsRoot
Root node of Events report folder.
Definition: EventsRoot.cs:17

Waher.Service.IoTBroker.Sources.Reports.Events.EventsRoot.RegisterReports
static async Task RegisterReports()
Registers protocol reports.
Definition: EventsRoot.cs:42

Waher.Service.IoTBroker.Sources.Reports.Performance.AllocatedMemory
Report on allocated memory.
Definition: AllocatedMemory.cs:11

Waher.Service.IoTBroker.Sources.Reports.Performance.FreeHD
Report on available memory.
Definition: FreeHD.cs:11

Waher.Service.IoTBroker.Sources.Reports.Performance.FreeMemory
Report on available memory.
Definition: FreeMemory.cs:11

Waher.Service.IoTBroker.Sources.Reports.Performance.PerformanceRoot
Root node of reports.
Definition: PerformanceRoot.cs:11

Waher.Service.IoTBroker.Sources.Reports.Performance.PerformanceRoot.RegisterReports
static async Task RegisterReports()
Registers protocol reports.
Definition: PerformanceRoot.cs:32

Waher.Service.IoTBroker.Sources.Reports.Protocols.Commands.HttpStatistic
Definition: HttpStatistic.cs:12

Waher.Service.IoTBroker.Sources.Reports.Protocols.Commands.XmppStatistic
Definition: XmppStatistic.cs:12

Waher.Service.IoTBroker.Sources.Reports.Protocols.ProtocolsRoot
Root node of reports.
Definition: ProtocolsRoot.cs:12

Waher.Service.IoTBroker.Sources.Reports.Protocols.ProtocolsRoot.RegisterReports
static async Task RegisterReports()
Registers protocol reports.
Definition: ProtocolsRoot.cs:33

Waher.Service.IoTBroker.StateMachines.Model.Actions.EventLog.Message
Defines a message.
Definition: Message.cs:9

Waher.Service.IoTBroker.StateMachines.Model.Actions.EventLog.Object
Defines an object.
Definition: Object.cs:9

Waher.Service.IoTBroker.StateMachines.StateMachineProcessor
State-Machine processor
Definition: StateMachineProcessor.cs:47

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.Agent.Account.DomainInfo
Gets information about the domain.
Definition: DomainInfo.cs:13

Waher.Service.IoTBroker.WebServices.Agent.Account.DomainInfo.DomainInfo
DomainInfo()
Gets information about the domain.
Definition: DomainInfo.cs:17

Waher.Service.IoTBroker.WebServices.Agent.AgentResource.CreateAuthenticationSchemes
HttpAuthenticationScheme[] CreateAuthenticationSchemes(IUserSource Users)
Creates a set of authentication schemes for the resource.
Definition: AgentResource.cs:122

Waher.Service.IoTBroker.WebServices.Agent.AgentResource.AuthenticationSchemes
HttpAuthenticationScheme[] AuthenticationSchemes
Array of authentication schemes used for the resource.
Definition: AgentResource.cs:99

Waher.Service.IoTBroker.WebServices.CreateAccount
Definition: CreateAccount.cs:12

Waher.Service.IoTBroker.WebServices.CreateApiKey
Definition: CreateApiKey.cs:18

Waher.Service.IoTBroker.WebServices.DeleteAccount
Definition: DeleteAccount.cs:10

Waher.Service.IoTBroker.WebServices.DeletePackage
Definition: DeletePackage.cs:12

Waher.Service.IoTBroker.WebServices.DeletePubSubNode
Definition: DeletePubSubNode.cs:12

Waher.Service.IoTBroker.WebServices.Feedback
Definition: Feedback.cs:16

Waher.Service.IoTBroker.WebServices.Feedback.SiteVerify
static async Task< bool > SiteVerify(string RecaptchaResponse, string RemoteEndPoint)
Allows web pages and web services to verify that Google reCaptcha responses are valid.
Definition: Feedback.cs:166

Waher.Service.IoTBroker.WebServices.InstallPackage
Definition: InstallPackage.cs:15

Waher.Service.IoTBroker.WebServices.KillMachine
Definition: KillMachine.cs:20

Waher.Service.IoTBroker.WebServices.LegalIdentityStateChanged
Definition: LegalIdentityStateChanged.cs:15

Waher.Service.IoTBroker.WebServices.LoadMoreItems
Definition: LoadMoreItems.cs:14

Waher.Service.IoTBroker.WebServices.PublicNodes
Definition: PublicNodes.cs:17

Waher.Service.IoTBroker.WebServices.PublisherAvatar
Definition: PublisherAvatar.cs:14

Waher.Service.IoTBroker.WebServices.QR
Web Service, generating QR-codes based on URI input.
Definition: QR.cs:24

Waher.Service.IoTBroker.WebServices.RequestAccount
Definition: RequestAccount.cs:16

Waher.Service.IoTBroker.WebServices.RequestApiKey
Definition: RequestApiKey.cs:16

Waher.Service.IoTBroker.WebServices.SearchEvents
Definition: SearchEvents.cs:17

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:14

Waher.Service.IoTBroker.WebServices.UpdateAccount
Definition: UpdateAccount.cs:14

Waher.Service.IoTBroker.WebServices.UpdateApiKey
Definition: UpdateApiKey.cs:13

Waher.Service.IoTBroker.WebServices.UpdatePubSubNode
Definition: UpdatePubSubNode.cs:12

Waher.Service.IoTBroker.WebServices.UploadPackage
Definition: UploadPackage.cs:13

Waher.Service.IoTBroker.WebServices.UploadSignature
Definition: UploadSignature.cs:17

Waher.Service.IoTBroker.WebServices.ValidateContract
Definition: ValidateContract.cs:16

Waher.Service.IoTBroker.WebServices.ValidateLegalId
Definition: ValidateLegalId.cs:13

Waher.Service.IoTBroker.WebServices.Vault
Access to secured vault storage via signed URLs.
Definition: Vault.cs:20

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:136

Waher.Service.IoTBroker.XmppServerModule.SendMailMessage
static Task< bool > SendMailMessage(string To, string Subject, string Markdown)
Sends a mail message
Definition: XmppServerModule.cs:5237

Waher.Service.IoTBroker.XmppServerModule.NamespaceSynchronizationNeuroFoundationV1
const string NamespaceSynchronizationNeuroFoundationV1
urn:nf:iot:synchronization:1.0
Definition: XmppServerModule.cs:145

Waher.Service.IoTBroker.XmppServerModule.NamespaceSynchronizationIeeeV1
const string NamespaceSynchronizationIeeeV1
urn:ieee:iot:synchronization:1.0
Definition: XmppServerModule.cs:140

Waher.Service.IoTBroker.XmppServerModule.DefaultAuthenticationSchemesXmpp
HttpAuthenticationScheme[] DefaultAuthenticationSchemesXmpp
Default HTTP Authentication schemes for XMPP-authenticated resources.
Definition: XmppServerModule.cs:1026

Waher.Service.IoTBroker.XmppServerModule.DefaultAuthenticationSchemesAdmin
HttpAuthenticationScheme[] DefaultAuthenticationSchemesAdmin
Default HTTP Authentication schemes for administrative resources.
Definition: XmppServerModule.cs:1021

Waher.Service.IoTBroker.XmppServerModule.NamespaceDnsOverXmpp
const string NamespaceDnsOverXmpp
urn:xmpp:dox:0
Definition: XmppServerModule.cs:150

Waher.Service.IoTBroker.XmppServerModule.DB_Generation
const int DB_Generation
Current Database generation. Used for upgrading the internal database.
Definition: XmppServerModule.cs:160

Waher.Service.IoTBroker.XmppServerModule.Stop
async Task Stop()
Stops the module.
Definition: XmppServerModule.cs:1838

Waher.Service.IoTBroker.XmppServerModule.Calibrate
static void Calibrate()
Calibrates the internal clock with the high frequency timer.
Definition: XmppServerModule.cs:2235

Waher.Service.IoTBroker.XmppServerModule.Start
async Task Start()
Starts the module.
Definition: XmppServerModule.cs:322

Waher.Service.IoTBroker.XmppServerModule.LoadEncryptedFile
static async Task< byte[]> LoadEncryptedFile(string FileName, byte[] Salt, long? Size)
Loads an encrypted file.
Definition: XmppServerModule.cs:5939

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:5249

Waher.Service.IoTBroker.XmppServerModule.SaveEncryptedFile
static async Task SaveEncryptedFile(string FileName, byte[] Salt, Stream Data)
Saves an encrypted file.
Definition: XmppServerModule.cs:5995

Waher.Service.IoTBroker.XmppServerModule.FindIpAddress
static Task< IP4Localization > FindIpAddress(string RemoteEndPoint)
Finds locale information about an IP Address.
Definition: XmppServerModule.cs:1557

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:5335

Waher.Service.IoTBroker.XmppServerModule.NamespaceJwt
const string NamespaceJwt
urn:xmpp:jwt:0
Definition: XmppServerModule.cs:155

Waher.Service.IoTBroker.XmppServerModule.NamespaceSynchronization
static string NamespaceSynchronization(NamespaceSet Version)
Returns the namespace for IoT Clock Synchronization.
Definition: XmppServerModule.cs:167

Waher.Service.IoTBroker.XmppServerModule.GetVersion
static NamespaceSet GetVersion(string Namespace)
Gets the namespace set version corresponding to a given a namespace.
Definition: XmppServerModule.cs:183

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:5841

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:5316

Waher.Service.IoTBroker.XmppServerModule.IsContentPackage
static bool IsContentPackage(Package Package)
Checks if a Package is a Content-Only package.
Definition: XmppServerModule.cs:2864

Waher.Service.IoTBroker.XmppServerModule.EncodeBlob
static async Task< Stream > EncodeBlob(Stream Data)
Encodes a variable-length BLOB by prefixing it with its length. This permits the BLOB to be safely en...
Definition: XmppServerModule.cs:6025

Waher.Service.IoTBroker.XmppServerModule.SaveEncryptedFile
static Task SaveEncryptedFile(string FileName, byte[] Salt, byte[] Data)
Saves an encrypted file.
Definition: XmppServerModule.cs:5983

Waher.Service.IoTBroker.XmppServerModule.NormalizedSerialization
static ISerializerContext NormalizedSerialization
Serialization context for normalized serialization.
Definition: XmppServerModule.cs:1036

Waher.Service.IoTBroker.XmppServerModule.Now
static DateTimeHF Now
Current high-resolution date and time
Definition: XmppServerModule.cs:2268

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:1608

Waher.Service.IoTBroker.XmppServerModule.SendMailMessage
static Task< bool > SendMailMessage(string From, string To, string Subject, string Markdown)
Sends a mail message
Definition: XmppServerModule.cs:5269

Waher.Service.IoTBroker.XmppServerModule.LoadEncryptedFile
static Task< byte[]> LoadEncryptedFile(string FileName, byte[] Salt)
Loads an encrypted file.
Definition: XmppServerModule.cs:5927

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:5220

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:5282

Waher.Service.IoTBroker.XmppServerModule.DecodeBlob
static async Task< Stream > DecodeBlob(Stream Data)
Decodes a variable-length BLOB encoded by the EncodeBlob method. The length prefix is read first,...
Definition: XmppServerModule.cs:6058

Waher.Service.IoTBroker.XmppServerModule.FindIpAddress
static async Task< IP4Localization > FindIpAddress(IPAddress Addr)
Finds locale information about an IP Address.
Definition: XmppServerModule.cs:1572

Waher.Things.Authorities.MaximumAuthority
Origin of request has maximum authority.
Definition: MaximumAuthority.cs:7

Waher.Things.Authorities.NoAuthority
Origin of request has no authority.
Definition: NoAuthority.cs:7

Waher.Things.Http.HttpModule
HTTP module
Definition: HttpModule.cs:26

Waher.Things.Http.HttpModule.GetAuthenticationSchemes
static HttpAuthenticationScheme[] GetAuthenticationSchemes()
Gets an array of authentication schemes available to authorize access to a web resource.
Definition: HttpModule.cs:108

Waher.Things.Semantic.SemanticModule
Module for semantic things.
Definition: SemanticModule.cs:16

Waher.Content.Markdown.Consolidation.IConsolidator
Interface for consolidators.
Definition: IConsolidator.cs:10

Waher.Events.IObservableLayer.Information
void Information(string Comment)
Called to inform the viewer of something.

Waher.Events.IObservableLayer.Warning
void 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:12

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:11

Waher.Networking.XMPP.Server.IXmppServerPersistenceLayer
Interface for XMPP Server persistence layers. The persistence layer should implement caching.
Definition: IXmppServerPersistenceLayer.cs:35

Waher.Persistence.IEncryptedProperties
Interface for objects containing encrypted properties. Mark the properties that are encrypted with th...
Definition: IEncryptedProperties.cs:10

Waher.Persistence.IPersistentDictionary
Persistent dictionary that can contain more entries than possible in the internal memory.
Definition: IPersistentDictionary.cs:11

Waher.Persistence.IPersistentDictionary.TryGetValueAsync
Task< KeyValuePair< bool, object > > TryGetValueAsync(string key)
Gets the value associated with the specified key.

Waher.Persistence.IPersistentDictionary.ContainsKeyAsync
Task< bool > ContainsKeyAsync(string key)
Determines whether the System.Collections.Generic.IDictionary{string,object} contains an element with...

Waher.Persistence.IPersistentDictionary.RemoveAsync
Task< bool > RemoveAsync(string key)
Removes the element with the specified key from the System.Collections.IDictionary object.

Waher.Persistence.IPersistentDictionary.AddAsync
Task AddAsync(string key, object value)
Adds an element with the provided key and value to the System.Collections.Generic....

Waher.Persistence.Serialization.ISerializerContext
Serialization context.
Definition: ISerializerContext.cs:16

Waher.Runtime.Inventory.IModule
Interface for late-bound modules loaded at runtime.
Definition: IModule.cs:9

Waher.Runtime.Queue.IAsyncProcessor
Interface for AsyncProcessor<T> instances.
Definition: IAsyncProcessor.cs:10

Waher.Script.Abstraction.Elements.IElement
Basic interface for all types of elements.
Definition: IElement.cs:21

Waher.Script.Abstraction.Elements.IElement.AssociatedObjectValue
object AssociatedObjectValue
Associated object value.
Definition: IElement.cs:34

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.

_
Definition: ImplTypes.g.cs:58

EDaler
Definition: AccountEvent.cs:11

LegalLab.Script.CountryCode
class CountryCode(ScriptNode Argument, int Start, int Length, Expression Expression)
Looks up a Country Name and returns the corresponding Country Code.
Definition: CountryCode.cs:18

NeuroFeatures
Definition: CreationAttributesEventArgs.cs:5

SkiaSharp
Definition: ImplTypes.g.cs:1087

System.Collections.Generic
Definition: ImplTypes.g.cs:4970

System.Collections
Definition: ImplTypes.g.cs:4970

System.Net.Sockets
Definition: ImplTypes.g.cs:19120

System.Net
Definition: ImplTypes.g.cs:19120

System.Security.Cryptography
Definition: SafeTypes.g.cs:3565

System
Definition: Adapters.g.cs:58

Waher.Content.Emoji
Definition: LocalEmojiFiles.cs:13

Waher.Content.Html.Css
Definition: CssCodec.cs:9

Waher.Content.Html.JavaScript
Definition: JavascriptCodec.cs:9

Waher.Content.Html
Definition: CDATA.cs:6

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:9

Waher.Content.SystemFiles
Definition: FileSystem.cs:7

Waher.Content.Text
Definition: CsvCodec.cs:10

Waher.Content.Xml
Definition: Attribute.cs:7

Waher.Content.Xsl
Definition: Transform.cs:12

Waher.Content
Definition: Array.cs:6

Waher.Events.Statistics
Definition: EventStatistics.cs:5

Waher.Events
Definition: ConsoleEventSink.cs:8

Waher.Events.EventLevel
EventLevel
Event level.
Definition: EventLevel.cs:7

Waher.IoTGateway.Cssx
Definition: CssxDecoder.cs:9

Waher.IoTGateway.ScriptExtensions.Constants
Definition: Domain.cs:8

Waher.IoTGateway.Setup
Definition: App.xaml.cs:22

Waher.IoTGateway.Tokenizers
Definition: HtmlTokenizer.cs:12

Waher.IoTGateway.WebResources
Definition: DeleteExport.cs:11

Waher.IoTGateway
Definition: App.xaml.cs:23

Waher.Networking.DNS.Communication
Definition: DnsClient.cs:17

Waher.Networking.DNS.HTTPS
Definition: DnsOverHttpsResource.cs:9

Waher.Networking.DNS
Definition: DnsClient.cs:17

Waher.Networking.FTP.Server
Definition: ClientConnectionEventArgs.cs:4

Waher.Networking.HTTP
Definition: BrotliContentEncoding.cs:10

Waher.Networking.HTTP.HostDomainOptions
HostDomainOptions
Options on how to handle domain names provided in the Host header.
Definition: HttpFolderResource.cs:20

Waher.Networking.SMTP.Server
Definition: ClientConnectionEventArgs.cs:4

Waher.Networking.SMTP.Server.Priority
Priority
Priority of message
Definition: SmtpClientConnection.cs:46

Waher.Networking.Sniffers
Definition: BinaryPresentationMethod.cs:2

Waher.Networking.Sniffers.BinaryPresentationMethod
BinaryPresentationMethod
How binary data is to be presented.
Definition: BinaryPresentationMethod.cs:7

Waher.Networking.XMPP.Concentrator
Definition: ConcentratorClient.cs:20

Waher.Networking.XMPP.Contracts
Definition: AltitudeUse.cs:2

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:13

Waher.Networking.XMPP.Server
Definition: AccountRecipient.cs:5

Waher.Networking
Definition: Program.cs:9

Waher.Networking.ClientCertificates
ClientCertificates
Client Certificate Options
Definition: ClientCertificates.cs:7

Waher.Persistence.Files
Definition: Bookmark.cs:4

Waher.Persistence.Filters
Definition: Filter.cs:2

Waher.Persistence.FullTextSearch.Tokenizers
Definition: CaseInsensitiveStringCollectionTokenizer.cs:8

Waher.Persistence.FullTextSearch
Definition: CollectionInformation.cs:6

Waher.Persistence.Serialization
Definition: BinaryDeserializer.cs:5

Waher.Persistence
Definition: Bookmark.cs:4

Waher.Runtime.Cache
Definition: Cache.cs:10

Waher.Runtime.IO
Definition: Certificates.cs:7

Waher.Runtime.Inventory
Definition: TypesLoader.cs:9

Waher.Runtime.Queue
Definition: AsyncProcessor.cs:8

Waher.Runtime.ServiceRegistration
Definition: Annotation.cs:6

Waher.Runtime.Settings
Definition: EnvironmentSettings.cs:7

Waher.Runtime.Statistics
Definition: Bucket.cs:12

Waher.Runtime.Temporary
Definition: IoBytesEventArgs.cs:4

Waher.Runtime.Threading
Definition: AsyncMutex.cs:6

Waher.Script.Abstraction.Elements
Definition: AbelianGroupElement.cs:4

Waher.Script.Exceptions
Definition: ArgumentDimensionsInconsistentScriptException.cs:4

Waher.Script.Graphs
Definition: CanvasGraph.cs:12

Waher.Script.Model
Definition: BinaryBooleanOperator.cs:8

Waher.Script.Objects.Matrices
Definition: BooleanMatrices.cs:6

Waher.Script.Objects
Definition: BooleanValue.cs:7

Waher.Script.Operators.Matrices
Definition: ColumnVector.cs:9

Waher.Script.Persistence.SQL.Sources
Definition: CollectionSource.cs:14

Waher.Script
Definition: App.xaml.cs:4

Waher.Security.DTLS.ContentType
ContentType
DTLS Record content type.
Definition: Enumerations.cs:11

Waher.Security.EllipticCurves
Definition: BrainpoolP160.cs:5

Waher.Security.JWT
Definition: AudienceEventArgs.cs:4

Waher.Security.JWT.Reason
Reason
Reason a token is not valid.
Definition: JwtFactory.cs:15

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.Tokenizers
Definition: AccountTokenizer.cs:9

Waher.Service.IoTBroker.DataStorage
Definition: Account.cs:27

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.GeoSpatial
Definition: GeoSpatialComponent.cs:20

Waher.Service.IoTBroker.HttpX
Definition: Chunk.cs:2

Waher.Service.IoTBroker.Legal.Attachments
Definition: Attachment.cs:6

Waher.Service.IoTBroker.Legal.Contracts.Tokenizers
Definition: ContractTokenizer.cs:8

Waher.Service.IoTBroker.Legal.Contracts
Definition: AltitudeUse.cs:2

Waher.Service.IoTBroker.Legal.Identity.Tokenizers
Definition: LegalIdentityTokenizer.cs:8

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.Tokenizers
Definition: NeuroFeatureTokenizer.cs:10

Waher.Service.IoTBroker.NeuroFeatures.WebServices
Definition: AddNote.cs:16

Waher.Service.IoTBroker.Paiwise
Definition: PaiwiseProcessor.cs:31

Waher.Service.IoTBroker.Provisioning.SoftwareUpdates
Definition: Package.cs:11

Waher.Service.IoTBroker.Provisioning
Definition: ProvisioningComponent.cs:30

Waher.Service.IoTBroker.PubSub
Definition: DefaultFeatures.cs:4

Waher.Service.IoTBroker.Sampling
Definition: PerformanceAlertMonitor.cs:5

Waher.Service.IoTBroker.ServiceRegistrations
Definition: Annotation.cs:5

Waher.Service.IoTBroker.Setup
Definition: BrokerNotificationConfiguration.cs:12

Waher.Service.IoTBroker.Sources.Connections
Definition: ClientConnection.cs:12

Waher.Service.IoTBroker.Sources.GatewayConfig
Definition: ConfigurationNode.cs:9

Waher.Service.IoTBroker.Sources.ProgramData
Definition: CreateFolderCommand.cs:10

Waher.Service.IoTBroker.Sources.Reports.Events.Commands
Definition: EventStatistic.cs:5

Waher.Service.IoTBroker.Sources.Reports.Events
Definition: EventStatistic.cs:5

Waher.Service.IoTBroker.Sources.Reports.Performance
Definition: All.cs:6

Waher.Service.IoTBroker.Sources.Reports.Protocols.Commands
Definition: HttpStatistic.cs:6

Waher.Service.IoTBroker.Sources.Reports.Protocols
Definition: HttpStatistic.cs:6

Waher.Service.IoTBroker.StateMachines.Model.Actions.EventLog
Definition: Actor.cs:4

Waher.Service.IoTBroker.StateMachines
Definition: CurrentState.cs:11

Waher.Service.IoTBroker.Synchronization
Definition: Calibration.cs:4

Waher.Service.IoTBroker.WebServices
Definition: AuthenticateJwt.cs:14

Waher.Service.IoTBroker
Definition: CreateAccount.cs:10

Waher.Service.IoTBroker.NamespaceSet
NamespaceSet
Namespace versions
Definition: NamespaceSet.cs:7

Waher.Things.Authorities
Definition: Authority.cs:4

Waher.Things.Http
Definition: ExternalWebNode.cs:8

Waher.Things.Semantic
Definition: IDynamicGraph.cs:6

Waher.Content.Duration
Represents a duration value, as defined by the xsd:duration data type: http://www....
Definition: Duration.cs:14