d1/df3/_gateway_8cs_source.html

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Net;

using System.Net.NetworkInformation;

using System.Reflection;

using System.Runtime.ExceptionServices;

using System.Runtime.InteropServices;

using System.Security.Cryptography;

using System.Security.Cryptography.X509Certificates;

using System.Text;

using System.Text.RegularExpressions;

using System.Threading.Tasks;

using System.Xml;

using System.Xml.Schema;

using Waher.Content;

using Waher.Content.Emoji.Emoji1;

using Waher.Content.Html;

using Waher.Content.Images;

using Waher.Content.Markdown;

using Waher.Content.Markdown.GraphViz;

using Waher.Content.Markdown.Layout2D;

using Waher.Content.Markdown.PlantUml;

using Waher.Content.Markdown.Rendering;

using Waher.Content.Markdown.Web;

using Waher.Content.Markdown.Web.WebScript;

using Waher.Content.SystemFiles;

using Waher.Content.Text;

using Waher.Content.Xml;

using Waher.Content.Xsl;

using Waher.Content.Zip;

using Waher.Events;

using Waher.Events.Files;

using Waher.Events.Filter;

using Waher.Events.MQTT;

using Waher.Events.Persistence;

using Waher.Events.Pipe;

using Waher.Events.Queue;

using Waher.Events.Socket;

using Waher.Events.Syslog;

using Waher.Events.WebHook;

using Waher.Events.XMPP;

using Waher.Groups;

using Waher.IoTGateway.Cssx;

using Waher.IoTGateway.Events;

using Waher.IoTGateway.Exceptions;

using Waher.IoTGateway.Setup;

using Waher.IoTGateway.Setup.Legal;

using Waher.IoTGateway.WebResources;

using Waher.IoTGateway.WebResources.ExportFormats;

using Waher.Jobs;

using Waher.Networking;

using Waher.Networking.CoAP;

using Waher.Networking.HTTP;

using Waher.Networking.HTTP.Authentication;

using Waher.Networking.HTTP.ContentEncodings;

using Waher.Networking.HTTP.HeaderFields;

using Waher.Networking.HTTP.Mcp.Model;

using Waher.Networking.HTTP.OAuth;

using Waher.Networking.MQTT;

using Waher.Networking.PeerToPeer;

using Waher.Networking.Sniffers;

using Waher.Networking.XMPP;

using Waher.Networking.XMPP.Avatar;

using Waher.Networking.XMPP.Concentrator;

using Waher.Networking.XMPP.Contracts;

using Waher.Networking.XMPP.Contracts.EventArguments;

using Waher.Networking.XMPP.Control;

using Waher.Networking.XMPP.Events;

using Waher.Networking.XMPP.Geo;

using Waher.Networking.XMPP.HTTPX;

using Waher.Networking.XMPP.Mail;

using Waher.Networking.XMPP.MUC;

using Waher.Networking.XMPP.P2P.SOCKS5;

using Waher.Networking.XMPP.PEP;

using Waher.Networking.XMPP.PEP.Events;

using Waher.Networking.XMPP.Provisioning;

using Waher.Networking.XMPP.Provisioning.Events;

using Waher.Networking.XMPP.PubSub;

using Waher.Networking.XMPP.PubSub.Events;

using Waher.Networking.XMPP.Sensor;

using Waher.Networking.XMPP.Software;

using Waher.Networking.XMPP.Synchronization;

using Waher.Output;

using Waher.Persistence;

using Waher.Persistence.Filters;

using Waher.Processors;

using Waher.Reports;

using Waher.Reports.Files;

using Waher.Runtime.Cache;

using Waher.Runtime.Collections;

using Waher.Runtime.Inventory;

using Waher.Runtime.Inventory.Loader;

using Waher.Runtime.IO;

using Waher.Runtime.Language;

using Waher.Runtime.Profiling;

using Waher.Runtime.ServiceRegistration;

using Waher.Runtime.Settings;

using Waher.Runtime.Threading;

using Waher.Runtime.Threading.Sync;

using Waher.Runtime.Timing;

using Waher.Script;

using Waher.Script.Graphs;

using Waher.Script.Model;

using Waher.Security;

using Waher.Security.CallStack;

using Waher.Security.JWT;

using Waher.Security.LoginMonitor;

using Waher.Security.SHA3;

using Waher.Security.Users;

using Waher.Security.WAF;

using Waher.Things;

using Waher.Things.Authorities;

using Waher.Things.Http;

using Waher.Things.Metering;

using Waher.Things.SensorData;

using Waher.Things.SourceEvents;


namespace Waher.IoTGateway

{

    public delegate Task<IDatabaseProvider> GetDatabaseProviderEventHandler(XmlElement Definition);


    public delegate Task RegistrationEventHandler(MetaDataTag[] MetaData, RegistrationEventArgs e);


    public delegate Task<MetaDataTag[]> GetRegistryMetaDataEventHandler(MetaDataTag[] MetaData);


    public static class Gateway

    {

        public const string GatewayConfigLocalFileName = "Gateway.config";


        public const string WebApplicationFirewallLocalFileName = "WAF.xml";


        public const string GatewayConfigLocalName = "GatewayConfiguration";


        public const string GatewayConfigNamespace = "http://waher.se/Schema/GatewayConfiguration.xsd";


        private const int MaxChunkSize = 4096;


        private static readonly LinkedList<KeyValuePair<string, int>> ports = new LinkedList<KeyValuePair<string, int>>();

        private static readonly Dictionary<int, EventHandlerAsync> serviceCommandByNr = new Dictionary<int, EventHandlerAsync>();

        private static readonly Dictionary<EventHandlerAsync, int> serviceCommandNrByCallback = new Dictionary<EventHandlerAsync, int>();

        private static readonly Dictionary<string, DateTime> lastUnauthorizedAccess = new Dictionary<string, DateTime>();

        private static readonly DateTime startTime = DateTime.Now;

        private static Cache<string, XmlFileSniffer> xmlFileSnifferCache = null;

        private static byte[] emergencyMemory = new byte[1024 * 1024];

        private static IDatabaseProvider internalProvider = null;

        private static ThingRegistryClient thingRegistryClient = null;

        private static ProvisioningClient provisioningClient = null;

        private static XmppCredentials xmppCredentials = null;

        private static XmppClient xmppClient = null;

        private static AvatarClient avatarClient = null;

        private static Networking.XMPP.InBandBytestreams.IbbClient ibbClient = null;

        private static Socks5Proxy socksProxy = null;

        private static ConcentratorServer concentratorServer = null;

        private static SensorClient sensorClient = null;

        private static ControlClient controlClient = null;

        private static ConcentratorClient concentratorClient = null;

        private static SynchronizationClient synchronizationClient = null;

        private static PepClient pepClient = null;

        private static MultiUserChatClient mucClient = null;

        private static ContractsClient contractsClient = null;

        private static SoftwareUpdateClient softwareUpdateClient = null;

        private static GeoClient geoClient = null;

        private static MailClient mailClient = null;

        private static X509Certificate2 certificate = null;

        private static DateTime checkCertificate = DateTime.MinValue;

        private static DateTime checkIp = DateTime.MinValue;

        private static OAuth2Environment oauthEnvironment = null;

        private static HttpServer webServer = null;

        private static HttpFolderResource root = null;

        private static HttpxProxy httpxProxy = null;

        private static HttpxServer httpxServer = null;

        private static CoapEndpoint coapEndpoint = null;

        private static SystemConfiguration[] configurations;

        private static LoginAuditor loginAuditor = null;

        private static Scheduler scheduler = null;

        private readonly static RandomNumberGenerator rnd = RandomNumberGenerator.Create();

        private static AsyncMutex gatewayRunning = null;

        private static AsyncMutex startingServer = null;

        private static Emoji1LocalFiles emoji1_24x24 = null;

        private static StreamWriter exceptionFile = null;

        private static CaseInsensitiveString domain = null;

        private static CaseInsensitiveString[] alternativeDomains = null;

        private static CaseInsensitiveString ownerJid = null;

        private static Dictionary<string, string> defaultPageByHostName = null;

        private static CommunicationLayer firstChanceExceptions = new CommunicationLayer(true);

        private static IPersistentDictionary nonceValues;

        private static JwtFactory jwtFactory = null;

        private static XmlFileSnifferSet mcpSniffers = null;

        private static DateTime wafTimestamp = DateTime.MinValue;

        private static string instance;

        private static string appDataFolder;

        private static string runtimeFolder;

        private static string rootFolder;

        private static string reportsFolder;

        private static string applicationName;

        private static string exceptionFolder = null;

        private static string exceptionFileName = null;

        private static int nextServiceCommandNr = 128;

        private static int beforeUninstallCommandNr = 0;

        private static bool firstStart = true;

        private static bool registered = false;

        private static bool connected = false;

        private static bool immediateReconnect;

        private static bool consoleOutput;

        private static bool loopbackIntefaceAvailable;

        private static bool configuring = false;

        private static bool exportExceptions = false;

        private static bool stopped = false;


        #region Life Cycle


        public static DateTime StartTime => startTime;


        public static Task<bool> Start(bool ConsoleOutput)

        {

            return Start(ConsoleOutput, true, string.Empty);

        }


        public static Task<bool> Start(bool ConsoleOutput, bool LoopbackIntefaceAvailable)

        {

            return Start(ConsoleOutput, LoopbackIntefaceAvailable, string.Empty);

        }


        public static async Task<bool> Start(bool ConsoleOutput, bool LoopbackIntefaceAvailable, string InstanceName)

        {

            bool FirstStart = firstStart;


            firstStart = false;

            instance = InstanceName;


            string Suffix = string.IsNullOrEmpty(InstanceName) ? string.Empty : "." + InstanceName;

            gatewayRunning = new AsyncMutex(false, "Waher.IoTGateway.Running" + Suffix);

            if (!await gatewayRunning.WaitOne(1000))

                return false; // Is running in another process.


            startingServer = new AsyncMutex(false, "Waher.IoTGateway.Starting" + Suffix);

            if (!await startingServer.WaitOne(1000))

            {

                await gatewayRunning.ReleaseMutex();

                gatewayRunning.Dispose();

                gatewayRunning = null;


                startingServer.Dispose();

                startingServer = null;

                return false; // Being started in another process.

            }


            try

            {

                stopped = false;

                consoleOutput = ConsoleOutput;

                loopbackIntefaceAvailable = LoopbackIntefaceAvailable;


                appDataFolder = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);


                if (!appDataFolder.EndsWith(new string(Path.DirectorySeparatorChar, 1)))

                    appDataFolder += Path.DirectorySeparatorChar;


                appDataFolder += "IoT Gateway";


                if (!string.IsNullOrEmpty(InstanceName))

                    appDataFolder += " " + InstanceName;


                if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && !Directory.Exists(appDataFolder))

                    appDataFolder = appDataFolder.Replace("/usr/share", "/usr/local/share");

                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && !Directory.Exists(appDataFolder))

                    appDataFolder = appDataFolder.Replace("/usr/share", "/var/lib");


                appDataFolder += Path.DirectorySeparatorChar;

                rootFolder = appDataFolder + "Root" + Path.DirectorySeparatorChar;

                reportsFolder = appDataFolder + "Reports" + Path.DirectorySeparatorChar;


                Log.Register(new EventFilter("Alert Filter", new AlertNotifier("Alert Notifier"), EventType.Alert,

                    (Event) => string.IsNullOrEmpty(Event.Facility)));


                Log.Register(new XmlFileEventSink("XML File Event Sink",

                    appDataFolder + "Events" + Path.DirectorySeparatorChar + "Event Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",

                    appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "EventXmlToHtml.xslt", 7));


                if (FirstStart)

                    Assert.UnauthorizedAccess += Assert_UnauthorizedAccess;


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


                if (FirstStart)

                {

                    Initialize();


                    beforeUninstallCommandNr = RegisterServiceCommand(BeforeUninstall);

                    NextBytes(emergencyMemory);


                    if (!Directory.Exists(rootFolder))

                    {

                        string s = Path.Combine(runtimeFolder, "Root");

                        if (Directory.Exists(s))

                        {

                            CopyFolder(runtimeFolder, appDataFolder, "*.config", CopyOptions.IfNewer);

                            CopyFolders(s, rootFolder, CopyOptions.IfNewer);

                            CopyFolders(Path.Combine(runtimeFolder, "Graphics"), Path.Combine(appDataFolder, "Graphics"), CopyOptions.IfNewer);

                            CopyFolders(Path.Combine(runtimeFolder, "Transforms"), Path.Combine(appDataFolder, "Transforms"), CopyOptions.IfNewer);

                        }

                    }


                    string[] ManifestFiles = Directory.GetFiles(runtimeFolder, "*.manifest", SearchOption.TopDirectoryOnly);

                    Dictionary<string, CopyOptions> ContentOptions = new Dictionary<string, CopyOptions>();

                    int i;


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

                    {

                        foreach (string ManifestFile in ManifestFiles)

                        {

                            string FileName = Path.GetFileName(ManifestFile);

                            bool GatewayFile = FileName.StartsWith("Waher.IoTGateway", StringComparison.CurrentCultureIgnoreCase);


                            if ((i == 0 && GatewayFile) || (i == 1 && !GatewayFile))

                            {

                                CheckContentFiles(ManifestFile, ContentOptions);


                                if (ManifestFile.EndsWith("Waher.Utility.Install.manifest"))

                                    CheckInstallUtilityFiles(ManifestFile);

                            }

                        }

                    }

                }


                Types.SetModuleParameter("AppData", appDataFolder);

                Types.SetModuleParameter("Runtime", runtimeFolder);

                Types.SetModuleParameter("Root", rootFolder);

                Types.SetModuleParameter("Reports", reportsFolder);


                scheduler = new Scheduler();


                if (FirstStart)

                {

                    Task T = Task.Run(() =>

                    {

                        GraphViz.Init(rootFolder);

                        XmlLayout.Init(rootFolder);

                        PlantUml.Init(rootFolder);

                    });

                }


                string GatewayConfigFileName = ConfigFilePath;

                if (!File.Exists(GatewayConfigFileName))

                    GatewayConfigFileName = GatewayConfigLocalFileName;


                XmlDocument Config = XML.LoadFromFile(GatewayConfigFileName, true);


                XSL.Validate(GatewayConfigLocalFileName, Config, GatewayConfigLocalName, GatewayConfigNamespace,

                    XSL.LoadSchema(typeof(Gateway).Namespace + ".Schema.GatewayConfiguration.xsd", typeof(Gateway).Assembly));


                IDatabaseProvider DatabaseProvider = null;

                ClientCertificates ClientCertificates = ClientCertificates.NotUsed;

                bool TrustClientCertificates = false;

                Dictionary<int, KeyValuePair<ClientCertificates, bool>> PortSpecificMTlsSettings = null;

                TimeSpan CleanupTime = new TimeSpan(4, 15, 0);

                bool Http2Enabled = true;

                int Http2InitialStreamWindowSize = 2500000;

                int Http2InitialConnectionWindowSize = 5000000;

                int Http2MaxFrameSize = 16384;

                int Http2MaxConcurrentStreams = 100;

                int Http2HeaderTableSize = 8192;

                bool Http2NoRfc7540Priorities = false;

                bool Http2Profiling = false;

                bool HttpSniffersPerEndpoint = false;


                // Bandwidth Delay Product, 100 MBit/s * 200 ms = 20 MBit = 2.5 MB window size

                // to avoid congestion.


                foreach (XmlNode N in Config.DocumentElement.ChildNodes)

                {

                    if (N is XmlElement E)

                    {

                        switch (E.LocalName)

                        {

                            case "ApplicationName":

                                applicationName = E.InnerText;

                                break;


                            case "DefaultPage":

                                defaultPageByHostName ??= new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);

                                defaultPageByHostName[XML.Attribute(E, "host")] = E.InnerText;

                                break;


                            case "MutualTls":

                                ClientCertificates = XML.Attribute(E, "clientCertificates", ClientCertificates.NotUsed);

                                TrustClientCertificates = XML.Attribute(E, "trustCertificates", false);


                                foreach (XmlNode N2 in E.ChildNodes)

                                {

                                    if (N2.LocalName == "Port" && int.TryParse(N2.InnerText, out int PortNumber))

                                    {

                                        XmlElement E2 = (XmlElement)N2;

                                        ClientCertificates ClientCertificatesPort = XML.Attribute(E2, "clientCertificates", ClientCertificates);

                                        bool TrustClientCertificatesPort = XML.Attribute(E2, "trustCertificates", TrustClientCertificates);


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

                                        PortSpecificMTlsSettings[PortNumber] = new KeyValuePair<ClientCertificates, bool>(ClientCertificatesPort, TrustClientCertificatesPort);

                                    }

                                }

                                break;


                            case "Http2Settings":

                                Http2Enabled = XML.Attribute(E, "enabled", Http2Enabled);

                                Http2InitialStreamWindowSize = XML.Attribute(E, "initialWindowSize", Http2InitialStreamWindowSize);

                                Http2InitialConnectionWindowSize = XML.Attribute(E, "initialConnectionWindowSize", Http2InitialConnectionWindowSize);

                                Http2MaxFrameSize = XML.Attribute(E, "maxFrameSize", Http2MaxFrameSize);

                                Http2MaxConcurrentStreams = XML.Attribute(E, "maxConcurrentStreams", Http2MaxConcurrentStreams);

                                Http2HeaderTableSize = XML.Attribute(E, "headerTableSize", Http2HeaderTableSize);

                                Http2NoRfc7540Priorities = XML.Attribute(E, "noRfc7540Priorities", Http2NoRfc7540Priorities);

                                Http2Profiling = XML.Attribute(E, "profiling", Http2Profiling);

                                HttpSniffersPerEndpoint = XML.Attribute(E, "sniffersPerEndpoint", false);

                                break;


                            case "ContentEncodings":

                                foreach (XmlNode N2 in E.ChildNodes)

                                {

                                    if (N2.LocalName == "ContentEncoding")

                                    {

                                        XmlElement E2 = (XmlElement)N2;

                                        string Method = XML.Attribute(E2, "method");

                                        bool Dynamic = XML.Attribute(E2, "dynamic", true);

                                        bool Static = XML.Attribute(E2, "static", true);


                                        IContentEncoding Encoding = Types.FindBest<IContentEncoding, string>(Method);


                                        if (Encoding is null)

                                            Log.Error("Content-Encoding not found: " + Method, GatewayConfigLocalFileName);

                                        else

                                            Encoding.ConfigureSupport(Dynamic, Static);

                                    }

                                }


                                HttpFieldAcceptEncoding.ContentEncodingsReconfigured();

                                break;


                            case "ExportExceptions":

                                exceptionFolder = Path.Combine(appDataFolder, XML.Attribute(E, "folder", "Exceptions"));


                                if (!Directory.Exists(exceptionFolder))

                                    Directory.CreateDirectory(exceptionFolder);


                                DateTime UtcNow = DateTime.UtcNow;

                                string[] ExceptionFiles = Directory.GetFiles(exceptionFolder, "*.txt", SearchOption.TopDirectoryOnly);

                                foreach (string ExceptionFile in ExceptionFiles)

                                {

                                    try

                                    {

                                        DateTime TP = File.GetLastWriteTimeUtc(ExceptionFile);

                                        if ((UtcNow - TP).TotalDays > 90)

                                            File.Delete(ExceptionFile);

                                        else

                                        {

                                            string XmlFile = Path.ChangeExtension(ExceptionFile, "xml");

                                            if (!File.Exists(XmlFile))

                                            {

                                                Log.Informational("Processing " + ExceptionFile);

                                                Analyze.Process(ExceptionFile, XmlFile);

                                                File.Delete(ExceptionFile);

                                            }

                                        }

                                    }

                                    catch (Exception ex)

                                    {

                                        Log.Exception(ex, ExceptionFile);

                                    }

                                }


                                ExceptionFiles = Directory.GetFiles(exceptionFolder, "*.xml", SearchOption.TopDirectoryOnly);

                                foreach (string ExceptionFile in ExceptionFiles)

                                {

                                    try

                                    {

                                        DateTime TP = File.GetLastWriteTimeUtc(ExceptionFile);

                                        if ((UtcNow - TP).TotalDays > 90)

                                            File.Delete(ExceptionFile);

                                    }

                                    catch (Exception ex)

                                    {

                                        Log.Exception(ex, ExceptionFile);

                                    }

                                }


                                if (FirstStart)

                                {

                                    int MaxTries = 1000;


                                    do

                                    {

                                        UtcNow = DateTime.UtcNow;


                                        exceptionFileName = Path.Combine(exceptionFolder, UtcNow.Year.ToString("D4") + "-" + UtcNow.Month.ToString("D2") + "-" + UtcNow.Day.ToString("D2") +

                                            " " + UtcNow.Hour.ToString("D2") + "." + UtcNow.Minute.ToString("D2") + "." + UtcNow.Second.ToString("D2") + ".txt");


                                        try

                                        {

                                            if (!File.Exists(exceptionFileName))

                                            {

                                                exceptionFile = File.CreateText(exceptionFileName);

                                            }

                                            else

                                                await Task.Delay(1000);

                                        }

                                        catch (IOException)

                                        {

                                            exceptionFile = null;

                                            await Task.Delay(1000);

                                        }

                                    }

                                    while (exceptionFile is null && --MaxTries > 0);


                                    exportExceptions = !(exceptionFile is null);


                                    if (exportExceptions)

                                    {

                                        exceptionFile.Write("Start of export: ");

                                        exceptionFile.WriteLine(DateTime.UtcNow.ToString());


                                        AppDomain.CurrentDomain.FirstChanceException += (Sender, e) =>

                                        {

                                            if (!(exceptionFile is null))

                                            {

                                                lock (exceptionFile)

                                                {

                                                    bool Emergency;


                                                    if (e.Exception is SystemException &&

                                                        (e.Exception is StackOverflowException ||

                                                        e.Exception is OutOfMemoryException ||

                                                        e.Exception is AccessViolationException))

                                                    {

                                                        emergencyMemory = null;

                                                        GC.GetTotalMemory(true);

                                                        Emergency = true;

                                                    }

                                                    else

                                                        Emergency = false;


                                                    string StackTrace = e.Exception.StackTrace;


                                                    if (!exportExceptions || StackTrace.Contains("FirstChanceExceptionEventArgs"))

                                                        return;


                                                    StringBuilder sb = new StringBuilder();


                                                    sb.AppendLine(new string('-', 80));

                                                    sb.Append("Type: ");


                                                    if (!(e.Exception is null))

                                                        sb.AppendLine(e.Exception.GetType().FullName);

                                                    else

                                                        sb.AppendLine("null");


                                                    sb.Append("Time: ");

                                                    sb.AppendLine(DateTime.UtcNow.ToString());


                                                    if (!(e.Exception is null))

                                                    {

                                                        if (Emergency)

                                                        {

                                                            sb.AppendLine();

                                                            sb.AppendLine(e.Exception.Message);

                                                            sb.AppendLine();

                                                            sb.AppendLine(StackTrace);     // Avoid worsening the situation and conserve stack space.

                                                            sb.AppendLine();

                                                        }

                                                        else

                                                        {

                                                            LinkedList<Exception> Exceptions = new LinkedList<Exception>();

                                                            Exceptions.AddLast(e.Exception);


                                                            while (!(Exceptions.First is null))

                                                            {

                                                                Exception ex = Exceptions.First.Value;

                                                                Exceptions.RemoveFirst();


                                                                sb.AppendLine();

                                                                sb.AppendLine(ex.Message);

                                                                sb.AppendLine();

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

                                                                sb.AppendLine();


                                                                if (ex is AggregateException ex2)

                                                                {

                                                                    foreach (Exception ex3 in ex2.InnerExceptions)

                                                                        Exceptions.AddLast(ex3);

                                                                }

                                                                else if (!(ex.InnerException is null))

                                                                    Exceptions.AddLast(ex.InnerException);

                                                            }

                                                        }

                                                    }


                                                    exceptionFile.Write(sb.ToString());

                                                    exceptionFile.Flush();

                                                }


                                                if (firstChanceExceptions?.HasSniffers ?? false)

                                                    firstChanceExceptions.Exception(e.Exception);

                                            }

                                        };

                                    }

                                }

                                break;


                            case "Database":

                                if (FirstStart || !Database.HasProvider)

                                {

                                    if (!(DatabaseProvider is null))

                                        throw new Exception("Database provider already initiated.");


                                    if (!(GetDatabaseProvider is null))

                                        DatabaseProvider = await GetDatabaseProvider(E);

                                    else

                                        DatabaseProvider = null;


                                    if (DatabaseProvider is null)

                                        throw new Exception("Database provider not defined. Make sure the GetDatabaseProvider event has an appropriate event handler.");


                                    internalProvider = DatabaseProvider;

                                    Database.Register(DatabaseProvider, false);

                                }

                                else

                                {

                                    DatabaseProvider = Database.Provider;

                                    await DatabaseProvider.Start();


                                    if (Ledger.HasProvider)

                                        await Ledger.Provider.Start();

                                }

                                break;


                            case "Ports":

                                foreach (XmlNode N2 in E.ChildNodes)

                                {

                                    if (N2.LocalName == "Port")

                                    {

                                        XmlElement E2 = (XmlElement)N2;

                                        string Protocol = XML.Attribute(E2, "protocol");

                                        if (!string.IsNullOrEmpty(Protocol) && int.TryParse(E2.InnerText, out int Port2))

                                            ports.AddLast(new KeyValuePair<string, int>(Protocol, Port2));

                                    }

                                }

                                break;


                            case "LoginAuditor":


                                static LoginInterval[] ParseIntervals(XmlElement E)

                                {

                                    List<LoginInterval> LoginIntervals = new List<LoginInterval>();

                                    Duration LastInterval = Duration.Zero;

                                    bool LastMaxInterval = false;


                                    foreach (XmlNode N2 in E.ChildNodes)

                                    {

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

                                        {

                                            if (LastMaxInterval)

                                            {

                                                Log.Error("Only the last login auditor interval can be the empty 'eternal' interval.",

                                                    GatewayConfigLocalFileName);

                                                break;

                                            }


                                            int NrAttempts = XML.Attribute(E2, "nrAttempts", 0);

                                            if (NrAttempts <= 0)

                                            {

                                                Log.Error("Number of attempts must be positive when defining an interval for the LoginAuditor",

                                                    GatewayConfigLocalFileName);

                                                continue;

                                            }


                                            if (!E2.HasAttribute("interval"))

                                            {

                                                LoginIntervals.Add(new LoginInterval(NrAttempts, TimeSpan.MaxValue));

                                                LastMaxInterval = true;

                                            }

                                            else

                                            {

                                                Duration Interval = XML.Attribute(E2, "interval", Duration.Zero);

                                                if (Interval <= Duration.Zero)

                                                {

                                                    Log.Error("Login Auditor intervals must be positive", GatewayConfigLocalFileName);

                                                    continue;

                                                }


                                                if (Interval <= LastInterval)

                                                {

                                                    Log.Error("Login Auditor intervals must be specified in an increasing order.",

                                                        GatewayConfigLocalFileName);

                                                    continue;

                                                }


                                                LoginIntervals.Add(new LoginInterval(NrAttempts, Interval));

                                                LastInterval = Interval;

                                            }

                                        }

                                    }


                                    return LoginIntervals.ToArray();

                                }


                                LoginInterval[] LoginIntervals = ParseIntervals(E);

                                List<RemoteEndpointIntervals> EndpointExceptions = new List<RemoteEndpointIntervals>();


                                foreach (XmlNode N2 in E.ChildNodes)

                                {

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

                                    {

                                        string EndPoint = XML.Attribute(E2, "endpoint");

                                        LoginInterval[] ExceptionIntervals = ParseIntervals(E2);


                                        if (ExceptionIntervals.Length == 0)

                                            Log.Error("Login Auditor exception intervals not specified for endpoint: " + EndPoint, GatewayConfigLocalFileName);

                                        else

                                            loginAuditor = new LoginAuditor("Login Auditor", LoginIntervals);


                                        if (ExceptionIntervals.Length == 0)

                                            Log.Error("Login Auditor intervals not specified.", GatewayConfigLocalFileName);

                                        else

                                            EndpointExceptions.Add(new RemoteEndpointIntervals(EndPoint, ExceptionIntervals));

                                    }

                                }


                                if (LoginIntervals.Length == 0)

                                    Log.Error("Login Auditor intervals not specified.", GatewayConfigLocalFileName);

                                else

                                    loginAuditor = new LoginAuditor("Login Auditor", EndpointExceptions.ToArray(), LoginIntervals);


                                break;


                            case "EventSinks":


                                static IEventSink[] ParseSinks(XmlElement E, ref TimeSpan CleanupTime)

                                {

                                    ChunkedList<IEventSink> Sinks = new ChunkedList<IEventSink>();


                                    foreach (XmlNode N2 in E.ChildNodes)

                                    {

                                        if (!(N2 is XmlElement E2) || E2.NamespaceURI != E.NamespaceURI)

                                            continue;


                                        try

                                        {

                                            switch (E2.LocalName)

                                            {

                                                case "TextFileEventSink":

                                                    string SinkId = XML.Attribute(E2, "id");

                                                    string FileName = XML.Attribute(E2, "fileName");

                                                    int DeleteAfterDays = XML.Attribute(E2, "deleteAfterDays", 7);


                                                    Sinks.Add(new TextFileEventSink(SinkId, FileName, DeleteAfterDays));

                                                    break;


                                                case "XmlFileEventSink":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    FileName = XML.Attribute(E2, "fileName");

                                                    DeleteAfterDays = XML.Attribute(E2, "deleteAfterDays", 7);


                                                    string TransformFileName = XML.Attribute(E2, "transformFileName");

                                                    if (string.IsNullOrEmpty(TransformFileName))

                                                        TransformFileName = appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "EventXmlToHtml.xslt";


                                                    Sinks.Add(new XmlFileEventSink(SinkId, FileName, TransformFileName, DeleteAfterDays));

                                                    break;


                                                case "MqttEventSink":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    string Broker = XML.Attribute(E2, "broker");

                                                    int Port = XML.Attribute(E2, "port", 1883);

                                                    bool Tls = XML.Attribute(E2, "tls", false);

                                                    string UserName = XML.Attribute(E2, "userName");

                                                    string Password = XML.Attribute(E2, "password");

                                                    string Topic = XML.Attribute(E2, "topic");


                                                    MqttClient MqttClient;


                                                    if (string.IsNullOrEmpty(UserName))

                                                    {

                                                        MqttClient = new MqttClient(Broker, Port, certificate,

                                                            null, MqttQualityOfService.AtMostOnce, false, null);

                                                    }

                                                    else

                                                    {

                                                        MqttClient = new MqttClient(Broker, Port, Tls, UserName, Password,

                                                            null, MqttQualityOfService.AtMostOnce, false, null);

                                                    }


                                                    Sinks.Add(new MqttEventSink(SinkId, MqttClient, Topic, true));

                                                    break;


                                                case "PipeEventSink":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    string PipeName = XML.Attribute(E2, "pipeName");


                                                    Sinks.Add(new PipeEventSink(SinkId, PipeName));

                                                    break;


                                                case "SocketEventSink":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    string Host = XML.Attribute(E2, "host");

                                                    Port = XML.Attribute(E2, "port", 0);

                                                    Tls = XML.Attribute(E2, "tls", false);


                                                    Sinks.Add(new SocketEventSink(SinkId, Host, Port, Tls));

                                                    break;


                                                case "SyslogEventSink":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    string Name = XML.Attribute(E2, "name");

                                                    Host = XML.Attribute(E2, "host");

                                                    Port = XML.Attribute(E2, "port", 514);

                                                    Tls = XML.Attribute(E2, "tls", false);

                                                    SyslogEventSeparation Separation = XML.Attribute(E2, "separation", SyslogEventSeparation.OctetCounting);


                                                    if (Tls)

                                                    {

                                                        if (certificate is null)

                                                        {

                                                            Sinks.Add(new SyslogEventSink(Host, Port, true, Name, applicationName,

                                                                Separation, SinkId));

                                                        }

                                                        else

                                                        {

                                                            Sinks.Add(new SyslogEventSink(Host, Port, certificate, Name, applicationName,

                                                                Separation, SinkId));

                                                        }

                                                    }

                                                    else

                                                    {

                                                        Sinks.Add(new SyslogEventSink(Host, Port, false, Name, applicationName,

                                                            Separation, SinkId));

                                                    }

                                                    break;


                                                case "WebHookEventSink":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    string Url = XML.Attribute(E2, "url");


                                                    int MaxSecondsUsed = XML.Attribute(E2, "maxSecondsUsed", 0);

                                                    int MaxSecondsUnused = XML.Attribute(E2, "maxSecondsUnused", 0);

                                                    bool CollectOnType = XML.Attribute(E2, "collectOnType", false);

                                                    bool CollectOnLevel = XML.Attribute(E2, "collectOnLevel", false);

                                                    bool CollectOnEventId = XML.Attribute(E2, "collectOnEventId", false);

                                                    bool CollectOnObject = XML.Attribute(E2, "collectOnObject", false);

                                                    bool CollectOnActor = XML.Attribute(E2, "collectOnActor", false);

                                                    bool CollectOnFacility = XML.Attribute(E2, "collectOnFacility", false);

                                                    bool CollectOnModule = XML.Attribute(E2, "collectOnModule", false);


                                                    Sinks.Add(new WebHookEventSink(SinkId, Url, null, MaxSecondsUsed,

                                                        MaxSecondsUnused, CollectOnType, CollectOnLevel,

                                                        CollectOnEventId, CollectOnObject, CollectOnActor,

                                                        CollectOnFacility, CollectOnModule));

                                                    break;


                                                case "XmppEventSink":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    string Jid = XML.Attribute(E2, "jid");


                                                    Sinks.Add(new XmppEventSink(SinkId, xmppClient, Jid, false));

                                                    break;


                                                case "EventFilter":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    FromEventLevel Debug = XML.Attribute(E2, "debug", FromEventLevel.None);

                                                    FromEventLevel Informational = XML.Attribute(E2, "informational", FromEventLevel.None);

                                                    FromEventLevel Notice = XML.Attribute(E2, "notice", FromEventLevel.None);

                                                    FromEventLevel Warning = XML.Attribute(E2, "warning", FromEventLevel.None);

                                                    FromEventLevel Error = XML.Attribute(E2, "error", FromEventLevel.None);

                                                    FromEventLevel Critical = XML.Attribute(E2, "critical", FromEventLevel.None);

                                                    FromEventLevel Alert = XML.Attribute(E2, "alert", FromEventLevel.None);

                                                    FromEventLevel Emergency = XML.Attribute(E2, "emergency", FromEventLevel.None);

                                                    string EventIdsString = XML.Attribute(E2, "eventIds").Trim();

                                                    string[] EventIds;


                                                    if (string.IsNullOrEmpty(EventIdsString))

                                                        EventIds = null;

                                                    else

                                                        EventIds = EventIdsString.Split(',', StringSplitOptions.RemoveEmptyEntries);


                                                    IEventSink[] ChildSinks = ParseSinks(E2, ref CleanupTime);


                                                    switch (ChildSinks.Length)

                                                    {

                                                        case 0:

                                                            break;


                                                        case 1:

                                                            Sinks.Add(new EventFilter(SinkId, ChildSinks[0], Debug, Informational, Notice, Warning,

                                                                Error, Critical, Alert, Emergency, null, EventIds));

                                                            break;


                                                        default:

                                                            Sinks.Add(new EventFilter(SinkId, new EventSinks(SinkId, ChildSinks), Debug, Informational, Notice, Warning,

                                                                Error, Critical, Alert, Emergency, null, EventIds));

                                                            break;

                                                    }

                                                    break;


                                                case "EventQueue":

                                                    SinkId = XML.Attribute(E2, "id");

                                                    string QueueName = XML.Attribute(E2, "name");

                                                    DeleteAfterDays = XML.Attribute(E2, "deleteAfterDays", 7);


                                                    Sinks.Add(new EventQueue(SinkId, QueueName, DeleteAfterDays, CleanupTime));

                                                    CleanupTime = CleanupTime.Add(TimeSpan.FromMinutes(2));

                                                    break;

                                            }

                                        }

                                        catch (Exception ex)

                                        {

                                            Log.Exception(ex, GatewayConfigLocalFileName);

                                        }

                                    }


                                    return Sinks.ToArray();

                                }


                                foreach (IEventSink Sink in ParseSinks(E, ref CleanupTime))

                                    Log.Register(Sink);


                                break;

                        }

                    }

                }


                if (DatabaseProvider is null)

                    throw new Exception("Database provider not defined in " + GatewayConfigLocalFileName + ".");


                Database.CollectionRepaired += Database_CollectionRepaired;


                await RepairIfInproperShutdown();


                PersistedEventLog PersistedEventLog = new PersistedEventLog(90, CleanupTime);

                CleanupTime = CleanupTime.Add(TimeSpan.FromMinutes(2));


                Log.Register(PersistedEventLog);

                try

                {

                    await PersistedEventLog.Queue(new Event(EventType.Informational, "Server starting up.", string.Empty, string.Empty, string.Empty, EventLevel.Minor, string.Empty, string.Empty, string.Empty));

                }

                catch (Exception ex)

                {

                    Event Event = new Event(DateTime.UtcNow, EventType.Critical, ex.Message, PersistedEventLog.ObjectID, string.Empty, string.Empty,

                        EventLevel.Major, string.Empty, ex.Source, Log.CleanStackTrace(ex.StackTrace));


                    Event.Avoid(PersistedEventLog);


                    Log.Event(Event);

                }


                loginAuditor ??= new LoginAuditor("Login Auditor",

                    new LoginInterval(5, TimeSpan.FromHours(1)),    // Maximum 5 failed login attempts in an hour

                    new LoginInterval(2, TimeSpan.FromDays(1)),     // Maximum 2x5 failed login attempts in a day

                    new LoginInterval(2, TimeSpan.FromDays(7)),     // Maximum 2x2x5 failed login attempts in a week

                    new LoginInterval(2, TimeSpan.MaxValue));       // Maximum 2x2x2x5 failed login attempts in total, then blocked.


                Log.Register(loginAuditor);


                nonceValues = await Database.GetDictionary("Nonces");


                // Protecting Markdown resources:

                if (!MarkdownCodec.IsRawEncodingAllowedLocked)

                    MarkdownCodec.AllowRawEncoding(false, true);

                HttpFolderResource.ProtectContentType(MarkdownCodec.ContentType);

                HttpFolderResource.ProtectContentType(CssxDecoder.DefaultContentType);

                ObjectToZipConverter.ProtectContentType(MarkdownCodec.ContentType);

                ObjectToZipConverter.ProtectContentType(CssxDecoder.DefaultContentType);


                // Protecting web-script resources:

                if (!WsCodec.IsRawEncodingAllowedLocked)

                    WsCodec.AllowRawEncoding(false, true);

                HttpFolderResource.ProtectContentType(WsCodec.ContentType);

                ObjectToZipConverter.ProtectContentType(WsCodec.ContentType);


                LinkedList<SystemConfiguration> NewConfigurations = null;

                Dictionary<string, Type> SystemConfigurationTypes = new Dictionary<string, Type>();

                Dictionary<string, SystemConfiguration> SystemConfigurations = new Dictionary<string, SystemConfiguration>();

                bool Configured = true;

                bool CheckDeferredConfigurations = false;

                bool Simplify = (await ServiceRegistrationClient.GetRegistrationTime()).HasValue;


                foreach (Type SystemConfigurationType in Types.GetTypesImplementingInterface(typeof(ISystemConfiguration)))

                {

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

                        continue;


                    SystemConfigurationTypes[SystemConfigurationType.FullName] = SystemConfigurationType;

                }


                foreach (SystemConfiguration SystemConfiguration in await Database.Find<SystemConfiguration>())

                {

                    string s = SystemConfiguration.GetType().FullName;


                    if (SystemConfigurations.ContainsKey(s))

                        await Database.Delete(SystemConfiguration);     // No duplicates allowed by mistake

                    else

                    {

                        SystemConfigurations[s] = SystemConfiguration;

                        SystemConfigurationTypes.Remove(s);


                        if (!SystemConfiguration.Complete)

                        {

                            if (await SystemConfiguration.EnvironmentConfiguration())

                            {

                                await SystemConfiguration.MakeCompleted();

                                await Database.Update(SystemConfiguration);


                                NewConfigurations ??= new LinkedList<SystemConfiguration>();

                                NewConfigurations.AddLast(SystemConfiguration);

                                continue;

                            }


                            if (Simplify && await SystemConfiguration.SimplifiedConfiguration())

                            {

                                await SystemConfiguration.MakeCompleted();

                                await Database.Update(SystemConfiguration);


                                NewConfigurations ??= new LinkedList<SystemConfiguration>();

                                NewConfigurations.AddLast(SystemConfiguration);

                                continue;

                            }


                            Configured = false;

                        }

                    }

                }


                foreach (KeyValuePair<string, Type> P in SystemConfigurationTypes)

                {

                    try

                    {

                        SystemConfiguration SystemConfiguration = (SystemConfiguration)Types.Instantiate(P.Value);

                        SystemConfiguration.Complete = false;

                        SystemConfiguration.Created = DateTime.Now;


                        await Database.Insert(SystemConfiguration);


                        SystemConfigurations[P.Key] = SystemConfiguration;


                        if (await SystemConfiguration.EnvironmentConfiguration())

                        {

                            await SystemConfiguration.MakeCompleted();

                            await Database.Update(SystemConfiguration);


                            NewConfigurations ??= new LinkedList<SystemConfiguration>();

                            NewConfigurations.AddLast(SystemConfiguration);


                            CheckDeferredConfigurations = true;

                            continue;

                        }


                        if (Simplify && await SystemConfiguration.SimplifiedConfiguration())

                        {

                            await SystemConfiguration.MakeCompleted();

                            await Database.Update(SystemConfiguration);


                            NewConfigurations ??= new LinkedList<SystemConfiguration>();

                            NewConfigurations.AddLast(SystemConfiguration);

                            continue;

                        }


                        Configured = false;

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                        continue;

                    }

                }


                configurations = new SystemConfiguration[SystemConfigurations.Count];

                SystemConfigurations.Values.CopyTo(configurations, 0);

                Array.Sort(configurations, (c1, c2) => c1.Priority - c2.Priority);


                ISystemConfiguration CurrentConfiguration = null;

                LinkedList<HttpResource> SetupResources = null;


                if (!Configured)

                {

                    configuring = true;


                    if (loopbackIntefaceAvailable)

                        Log.Notice("System needs to be configured. This is done by navigating to the loopback interface using a browser on this machine.");

                    else

                        Log.Notice("System needs to be configured. This is done by navigating to the machine using a browser on another machine in the same network.");


                    webServer = new HttpServer(GetConfigPorts("HTTP"), null, null)

                    {

                        ResourceOverride = "/Starting.md",

                        ResourceOverrideFilter = "(?<!Login)[.]md(\\?[.]*)?$",

                        LoginAuditor = loginAuditor

                    };


                    webServer.Register("/Starting.md", StartingMd);

                    webServer.CustomError += WebServer_CustomError;


                    SetupResources = new LinkedList<HttpResource>();


                    SetupResources.AddLast(webServer.Register(new HttpFolderResource("/Graphics", Path.Combine(appDataFolder, "Graphics"), false, false, true, false, HostDomainOptions.SameForAllDomains))); // TODO: Add authentication mechanisms for PUT & DELETE.

                    SetupResources.AddLast(webServer.Register(new HttpFolderResource("/Transforms", Path.Combine(appDataFolder, "Transforms"), false, false, true, false, HostDomainOptions.SameForAllDomains))); // TODO: Add authentication mechanisms for PUT & DELETE.

                    SetupResources.AddLast(webServer.Register(new HttpFolderResource("/highlight", "Highlight", false, false, true, false, HostDomainOptions.SameForAllDomains)));   // Syntax highlighting library, provided by http://highlightjs.org

                    SetupResources.AddLast(webServer.Register(root = new HttpFolderResource(string.Empty, rootFolder, false, false, true, true, HostDomainOptions.UseDomainSubfolders)));    // TODO: Add authentication mechanisms for PUT & DELETE.

                    SetupResources.AddLast(webServer.Register("/", GoToDefaultPage));

                    SetupResources.AddLast(webServer.Register(new ClientEvents()));

                    SetupResources.AddLast(webServer.Register(new ClientEventsWebSocket()));

                    SetupResources.AddLast(webServer.Register(new Login()));

                    SetupResources.AddLast(webServer.Register(new Logout()));

                    SetupResources.AddLast(webServer.Register(new MasterJavascript(webServer)));


                    emoji1_24x24 = new Emoji1LocalFiles(Emoji1SourceFileType.Svg, 24, 24, "/Graphics/Emoji1/svg/%FILENAME%",

                        Path.Combine(runtimeFolder, "Graphics", "Emoji1.zip"), Path.Combine(appDataFolder, "Graphics"));


                    root.AllowTypeConversion();


                    MarkdownSettings.SetDefaultEmojiSource(emoji1_24x24, true);

                    MarkdownToHtmlConverter.EmojiSource = emoji1_24x24;

                    MarkdownToHtmlConverter.RootFolder = rootFolder;

                }


                foreach (SystemConfiguration Configuration in configurations)

                {

                    Configuration.SetStaticInstance(Configuration);


                    if (!(webServer is null))

                        await Configuration.InitSetup(webServer);

                }


                bool ReloadConfigurations;


                do

                {

                    ReloadConfigurations = false;


                    foreach (SystemConfiguration Configuration in configurations)

                    {

                        bool NeedsCleanup = false;


                        if (!Configuration.Complete)

                        {

                            CurrentConfiguration = Configuration;


                            if (!(webServer is null))

                                webServer.ResourceOverride = Configuration.Resource;


                            Configuration.SetStaticInstance(Configuration);


                            if (!(startingServer is null))

                            {

                                await startingServer.ReleaseMutex();

                                startingServer.Dispose();

                                startingServer = null;

                            }


                            await ClientEvents.PushEvent(ClientEvents.GetTabIDs(), "Reload", string.Empty);


                            if (!(webServer is null) && await Configuration.SetupConfiguration(webServer))

                                ReloadConfigurations = true;


                            NeedsCleanup = true;

                        }


                        DateTime StartConfig = DateTime.UtcNow;


                        try

                        {

                            await Configuration.ConfigureSystem();

                        }

                        catch (Exception)

                        {

                            await RepairIfInproperShutdown();


                            try

                            {

                                await Configuration.ConfigureSystem();

                            }

                            catch (Exception ex)

                            {

                                Log.Exception(ex);

                            }

                        }


                        if (NeedsCleanup && !(webServer is null))

                            await Configuration.CleanupAfterConfiguration(webServer);


                        if (ReloadConfigurations)

                        {

                            Configured = true;


                            foreach (SystemConfiguration SystemConfiguration in await Database.Find<SystemConfiguration>())

                            {

                                string s = SystemConfiguration.GetType().FullName;


                                if (!(webServer is null) && SystemConfigurations.TryGetValue(s, out SystemConfiguration OldConfiguration))

                                    await OldConfiguration.UnregisterSetup(webServer);


                                SystemConfigurations[s] = SystemConfiguration;

                                SystemConfiguration.SetStaticInstance(SystemConfiguration);


                                if (!(webServer is null))

                                    await SystemConfiguration.InitSetup(webServer);

                            }


                            foreach (SystemConfiguration SystemConfiguration in SystemConfigurations.Values)

                            {

                                if (!SystemConfiguration.Complete)

                                {

                                    Configured = false;

                                    break;

                                }

                            }


                            configurations = new SystemConfiguration[SystemConfigurations.Count];

                            SystemConfigurations.Values.CopyTo(configurations, 0);

                            Array.Sort(configurations, (c1, c2) => c1.Priority - c2.Priority);


                            break;

                        }


                        if (DateTime.UtcNow.Subtract(StartConfig).TotalSeconds > 2)

                            await ClientEvents.PushEvent(ClientEvents.GetTabIDs(), "Reload", string.Empty);

                    }

                }

                while (ReloadConfigurations);


                configuring = false;

                loginAuditor.Domain = DomainConfiguration.Instance.Domain;


                if (!(webServer is null))

                {

                    webServer.ResourceOverride = "/Starting.md";

                    await ClientEvents.PushEvent(ClientEvents.GetTabIDs(), "Reload", string.Empty);


                    if (!(SetupResources is null))

                    {

                        foreach (HttpResource Resource in SetupResources)

                            webServer.Unregister(Resource);

                    }


                    webServer.ConfigureMutualTls(ClientCertificates, TrustClientCertificates, PortSpecificMTlsSettings, true);

                    webServer.NetworkChanged();


                    webServer.AddHttpPorts(GetConfigPorts("HTTP"));


                    if (!(certificate is null))

                    {

                        webServer.AddHttpsPorts(GetConfigPorts("HTTPS"));

                        webServer.UpdateCertificate(certificate);

                    }

                }

                else

                {

                    if (!(certificate is null))

                    {

                        webServer = new HttpServer(GetConfigPorts("HTTP"), GetConfigPorts("HTTPS"), certificate, true,

                            ClientCertificates, TrustClientCertificates, PortSpecificMTlsSettings, true);

                    }

                    else

                        webServer = new HttpServer(GetConfigPorts("HTTP"), null, null);


                    webServer.Register("/Starting.md", StartingMd);

                    webServer.ResourceOverride = "/Starting.md";

                    webServer.LoginAuditor = loginAuditor;


                    webServer.CustomError += WebServer_CustomError;


                    foreach (SystemConfiguration Configuration in configurations)

                    {

                        try

                        {

                            await Configuration.InitSetup(webServer);

                        }

                        catch (Exception)

                        {

                            await RepairIfInproperShutdown();


                            try

                            {

                                await Configuration.InitSetup(webServer);

                            }

                            catch (Exception ex)

                            {

                                Log.Exception(ex);

                            }

                        }

                    }

                }


                if (CheckDeferredConfigurations)

                {

                    foreach (SystemConfiguration Configuration in configurations)

                    {

                        try

                        {

                            await Configuration.DeferredConfiguration(webServer);

                        }

                        catch (Exception ex)

                        {

                            Log.Exception(ex);

                        }

                    }

                }


                webServer.SetHttp2ConnectionSettings(Http2Enabled, Http2InitialStreamWindowSize,

                    Http2InitialConnectionWindowSize, Http2MaxFrameSize, Http2MaxConcurrentStreams,

                    Http2HeaderTableSize, false, Http2NoRfc7540Priorities, Http2Profiling, true);


                webServer.ConnectionProfiled += WebServer_ConnectionProfiled;

                webServer.OnTryGetLocalResourceFileName += (string Resource, string Host, out string FileName) =>

                    TryGetLocalResourceFileName(Resource, Host, out FileName);


                Types.SetModuleParameter("HTTP", webServer);

                Types.SetModuleParameter("X509", certificate);

                Types.SetModuleParameter("LoginAuditor", webServer.LoginAuditor);


                InternetContent.LocalDomainCheck += InternetContent_LocalDomainCheck;


                await WriteWebServerOpenPorts();

                webServer.OnNetworkChanged += async (Sender, e) =>

                {

                    try

                    {

                        await WriteWebServerOpenPorts();

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                    }

                };


                await CheckWAF();


                InternetContent.SetDefaultTimeout(60000, true);


                if (HasDomain)

                {

                    if (DomainConfiguration.Instance.UseEncryption)

                        jwtFactory = JwtFactory.CreateHmacSha256("https://" + Domain);

                    else

                        jwtFactory = JwtFactory.CreateHmacSha256("http://" + Domain);


                    JwtFactory.ValidateAudience += (sender, e) =>

                    {

                        foreach (string Audience in e.Audience)

                        {

                            if (IsDomain(Audience, true))

                            {

                                e.Acceptable = true;

                                return;

                            }

                        }

                    };

                }

                else

                    jwtFactory = JwtFactory.CreateHmacSha256(string.Empty);


                oauthEnvironment = new OAuth2Environment

                {

                    LoginMasterFileName = Path.Combine(rootFolder, "MasterOAuth.md")

                };


                Types.SetModuleParameter("JWT", jwtFactory);

                Types.SetModuleParameter("Users", Users.Source);

                Types.SetModuleParameter("OAUTH2", oauthEnvironment);


                webServer.Register(new ProtectedResourceMetaData(oauthEnvironment));

                webServer.Register(new OAuthTokenResource(oauthEnvironment));

                webServer.Register(new OAuthDeviceAuthorizationResource(oauthEnvironment));

                webServer.Register(new OAuthAuthorizeResource(oauthEnvironment));

                webServer.Register(new OAuthIntrospectionResource(oauthEnvironment));

                webServer.Register(new AuthorizationServerMetaData(oauthEnvironment));

                webServer.Register(new OAuthRegistrationResource(oauthEnvironment));

                webServer.Register(new OAuthManagementResource(oauthEnvironment));

                webServer.Register(new HttpFolderResource("/Graphics", Path.Combine(appDataFolder, "Graphics"), false, false, true, false, HostDomainOptions.SameForAllDomains)); // TODO: Add authentication mechanisms for PUT & DELETE.

                webServer.Register(new HttpFolderResource("/Transforms", Path.Combine(appDataFolder, "Transforms"), false, false, true, false, HostDomainOptions.SameForAllDomains)); // TODO: Add authentication mechanisms for PUT & DELETE.

                webServer.Register(new HttpFolderResource("/highlight", "Highlight", false, false, true, false, HostDomainOptions.SameForAllDomains));   // Syntax highlighting library, provided by http://highlightjs.org

                webServer.Register(root = new HttpFolderResource(string.Empty, rootFolder, false, false, true, true, HostDomainOptions.UseDomainSubfolders));    // TODO: Add authentication mechanisms for PUT & DELETE.

                webServer.Register(httpxProxy = new HttpxProxy("/HttpxProxy", xmppClient, MaxChunkSize));

                webServer.Register("/", GoToDefaultPage);

                webServer.Register(new HttpConfigurableFileResource("/robots.txt", Path.Combine(rootFolder, "robots.txt"), PlainTextCodec.DefaultContentType, true));

                webServer.Register(new HttpConfigurableFileResource("/favicon.ico", Path.Combine(rootFolder, "favicon.ico"), ImageCodec.ContentTypeIcon, false));

                webServer.Register(new ClientEvents());

                webServer.Register(new ClientEventsWebSocket());

                webServer.Register(new Login());

                webServer.Register(new Logout());

                webServer.Register(new MasterJavascript(webServer));

                webServer.Register(new Echo());

                webServer.Register(new WebResources.Ping());

                webServer.Register(new ProposeContract());

                webServer.Register(new UrlShortener());


                Icon FavIcon = new Icon(new Uri(GetUrl("/favicon.ico")),

                    ImageCodec.ContentTypeIcon);

                Icon[] Icons = new Icon[] { FavIcon };


                mcpSniffers = new XmlFileSnifferSet(appDataFolder + "MCP" + Path.DirectorySeparatorChar +

                    "Sniffers", "MCP Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml", TimeSpan.FromHours(8),

                    appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",

                    7, BinaryPresentationMethod.ByteCount);


                webServer.Register(new Mcp.Content.InternetContentMcpServer("/MCP/Content", Icons, null, mcpSniffers));

                webServer.Register(new Mcp.Events.EventLogMcpServer("/MCP/EventLog", Icons, null, mcpSniffers));

                webServer.Register(new Mcp.Files.FileStorageMcpServer("/MCP/Files",

                    Path.Combine(appDataFolder, "MCP", "Files"), Icons, null, mcpSniffers));


                if (emoji1_24x24 is null)

                {

                    emoji1_24x24 = new Emoji1LocalFiles(Emoji1SourceFileType.Svg, 24, 24, "/Graphics/Emoji1/svg/%FILENAME%",

                        Path.Combine(runtimeFolder, "Graphics", "Emoji1.zip"), Path.Combine(appDataFolder, "Graphics"));


                    MarkdownSettings.SetDefaultEmojiSource(emoji1_24x24, true);

                    MarkdownToHtmlConverter.EmojiSource = emoji1_24x24;

                    MarkdownToHtmlConverter.RootFolder = rootFolder;

                }


                root.AllowTypeConversion();


                XmlElement DefaultHttpResponseHeaders = Config.DocumentElement["DefaultHttpResponseHeaders"];

                if (!(DefaultHttpResponseHeaders is null))

                {

                    foreach (XmlNode N in DefaultHttpResponseHeaders.ChildNodes)

                    {

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

                        {

                            string HeaderKey = XML.Attribute(E, "key");

                            string HeaderValue = XML.Attribute(E, "value");


                            root.AddDefaultResponseHeader(HeaderKey, HeaderValue);

                        }

                    }

                }


                XmlElement FileFolders = Config.DocumentElement["FileFolders"];

                if (!(FileFolders is null))

                {

                    foreach (XmlNode N in FileFolders.ChildNodes)

                    {

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

                        {

                            string WebFolder = XML.Attribute(E, "webFolder");

                            string FolderPath = XML.Attribute(E, "folderPath");


                            HttpFolderResource FileFolder = new HttpFolderResource(WebFolder, FolderPath, false, false, true, true, HostDomainOptions.SameForAllDomains);

                            webServer.Register(FileFolder);


                            foreach (XmlNode N2 in E.ChildNodes)

                            {

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

                                {

                                    string HeaderKey = XML.Attribute(E2, "key");

                                    string HeaderValue = XML.Attribute(E2, "value");


                                    FileFolder.AddDefaultResponseHeader(HeaderKey, HeaderValue);

                                }

                            }

                        }

                    }

                }


                XmlElement VanityResources = Config.DocumentElement["VanityResources"];

                if (!(VanityResources is null))

                {

                    foreach (XmlNode N in VanityResources.ChildNodes)

                    {

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

                        {

                            string RegEx = XML.Attribute(E, "regex");

                            string Url = XML.Attribute(E, "url");


                            try

                            {

                                webServer.RegisterVanityResource(RegEx, Url);

                            }

                            catch (Exception ex)

                            {

                                Log.Error("Unable to register vanity resource: " + ex.Message,

                                    new KeyValuePair<string, object>("RegEx", RegEx),

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

                            }

                        }

                    }

                }


                XmlElement Redirections = Config.DocumentElement["Redirections"];

                if (!(Redirections is null))

                {

                    foreach (XmlNode N in Redirections.ChildNodes)

                    {

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

                        {

                            string Resource = XML.Attribute(E, "resource");

                            string Location = XML.Attribute(E, "location");

                            bool IncludeSubPaths = XML.Attribute(E, "includeSubPaths", false);

                            bool Permanent = XML.Attribute(E, "permanent", false);


                            try

                            {

                                webServer.Register(new HttpRedirectionResource(Resource, Location, IncludeSubPaths, Permanent));

                            }

                            catch (Exception ex)

                            {

                                Log.Error("Unable to register redirection: " + ex.Message,

                                    new KeyValuePair<string, object>("Resource", Resource),

                                    new KeyValuePair<string, object>("Location", Location),

                                    new KeyValuePair<string, object>("IncludeSubPaths", IncludeSubPaths),

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

                            }

                        }

                    }

                }


                XmlElement ReverseProxy = Config.DocumentElement["ReverseProxy"];

                if (!(ReverseProxy is null))

                {

                    foreach (XmlNode N in ReverseProxy.ChildNodes)

                    {

                        if (!(N is XmlElement E))

                            continue;


                        switch (E.LocalName)

                        {

                            case "ProxyResource":

                                string LocalResource = XML.Attribute(E, "localResource");

                                string RemoteDomain = XML.Attribute(E, "remoteDomain");

                                string RemoteFolder = XML.Attribute(E, "remoteFolder");

                                bool Encrypted = XML.Attribute(E, "encrypted", false);

                                int RemotePort = XML.Attribute(E, "remotePort", Encrypted ? HttpServer.DefaultHttpsPort : HttpServer.DefaultHttpPort);

                                bool UseSession = XML.Attribute(E, "useSession", false);

                                int TimeoutMs = XML.Attribute(E, "timeoutMs", 10000);

                                string Privilege = XML.Attribute(E, "privilege");


                                try

                                {

                                    if (string.IsNullOrEmpty(Privilege))

                                    {

                                        webServer.Register(new HttpReverseProxyResource(LocalResource, RemoteDomain, RemotePort, RemoteFolder, Encrypted,

                                            TimeSpan.FromMilliseconds(TimeoutMs), UseSession));

                                    }

                                    else

                                    {

                                        webServer.Register(new HttpReverseProxyResource(LocalResource, RemoteDomain, RemotePort, RemoteFolder, Encrypted,

                                            TimeSpan.FromMilliseconds(TimeoutMs), UseSession, HttpModule.GetAuthenticationSchemes(Privilege),

                                            Privilege));

                                    }

                                }

                                catch (Exception ex)

                                {

                                    Log.Error("Unable to register reverse proxy: " + ex.Message,

                                        new KeyValuePair<string, object>("LocalResource", LocalResource),

                                        new KeyValuePair<string, object>("RemoteDomain", RemoteDomain),

                                        new KeyValuePair<string, object>("Encrypted", Encrypted),

                                        new KeyValuePair<string, object>("RemotePort", RemotePort),

                                        new KeyValuePair<string, object>("RemoteFolder", RemoteFolder),

                                        new KeyValuePair<string, object>("UseSession", UseSession),

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

                                }

                                break;


                            case "ProxyDomain":

                                string LocalDomain = XML.Attribute(E, "localDomain");

                                RemoteDomain = XML.Attribute(E, "remoteDomain");

                                RemoteFolder = XML.Attribute(E, "remoteFolder");

                                Encrypted = XML.Attribute(E, "encrypted", false);

                                RemotePort = XML.Attribute(E, "remotePort", Encrypted ? HttpServer.DefaultHttpsPort : HttpServer.DefaultHttpPort);

                                UseSession = XML.Attribute(E, "useSession", false);

                                TimeoutMs = XML.Attribute(E, "timeoutMs", 10000);

                                Privilege = XML.Attribute(E, "privilege");


                                try

                                {

                                    if (string.IsNullOrEmpty(Privilege))

                                    {

                                        webServer.RegisterDomainProxy(LocalDomain, new HttpReverseProxyResource(

                                            "/", RemoteDomain, RemotePort, RemoteFolder, Encrypted,

                                            TimeSpan.FromMilliseconds(TimeoutMs), UseSession));

                                    }

                                    else

                                    {

                                        webServer.RegisterDomainProxy(LocalDomain, new HttpReverseProxyResource(

                                            "/", RemoteDomain, RemotePort, RemoteFolder, Encrypted,

                                            TimeSpan.FromMilliseconds(TimeoutMs), UseSession,

                                            HttpModule.GetAuthenticationSchemes(Privilege), Privilege));

                                    }

                                }

                                catch (Exception ex)

                                {

                                    Log.Error("Unable to register reverse proxy: " + ex.Message,

                                        new KeyValuePair<string, object>("LocalDomain", LocalDomain),

                                        new KeyValuePair<string, object>("RemoteDomain", RemoteDomain),

                                        new KeyValuePair<string, object>("Encrypted", Encrypted),

                                        new KeyValuePair<string, object>("RemotePort", RemotePort),

                                        new KeyValuePair<string, object>("RemoteFolder", RemoteFolder),

                                        new KeyValuePair<string, object>("UseSession", UseSession),

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

                                }

                                break;

                        }

                    }

                }


                await LoadScriptResources();


                httpxServer = new HttpxServer(xmppClient, webServer, MaxChunkSize);

                Types.SetModuleParameter("HTTPX", httpxProxy);

                Types.SetModuleParameter("HTTPXS", httpxServer);


                httpxProxy.IbbClient = ibbClient;

                httpxServer.IbbClient = ibbClient;


                httpxProxy.Socks5Proxy = socksProxy;

                httpxServer.Socks5Proxy = socksProxy;


                if (xmppCredentials.Sniffer || HttpSniffersPerEndpoint)

                {

                    ISniffer Sniffer;


                    Sniffer = new XmlFileSniffer(appDataFolder + "HTTP" + Path.DirectorySeparatorChar +

                        "HTTP Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",

                        appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",

                        7, BinaryPresentationMethod.ByteCount);

                    webServer.Add(Sniffer);


                    if (HttpSniffersPerEndpoint)

                    {

                        xmlFileSnifferCache = new Cache<string, XmlFileSniffer>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromHours(1));

                        xmlFileSnifferCache.Removed += XmlFileSnifferCache_Removed;


                        webServer.GetCustomSniffers += GetCustomHttpSniffers;

                    }

                }


                await ClientEvents.PushEvent(ClientEvents.GetTabIDs(), "Reload", string.Empty);


                try

                {

                    coapEndpoint = new CoapEndpoint();

                    Types.SetModuleParameter("CoAP", coapEndpoint);

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                GetDataSourcesEventArgs Sources;

                IDataSource[] InitialSources = null;


                try

                {

                    InitialSources = new IDataSource[]

                    {

                        new GroupSource(),

                        new JobSource(),

                        new MeteringTopology(),

                        new OutputSource(),

                        new ProcessorSource(),

                        new ReportsDataSource()

                    };


                    Sources = new GetDataSourcesEventArgs(InitialSources);

                }

                catch (Exception)

                {

                    await RepairIfInproperShutdown();


                    try

                    {

                        InitialSources ??= new IDataSource[]

                        {

                            new GroupSource(),

                            new JobSource(),

                            new MeteringTopology(),

                            new OutputSource(),

                            new ProcessorSource(),

                            new ReportsDataSource()

                        };


                        Sources = new GetDataSourcesEventArgs(InitialSources);

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                        Sources = new GetDataSourcesEventArgs();

                    }

                }


                await ReportsDataSource.RegisterRootNode(new ReportFilesFolder(reportsFolder, "Report Files", null));


                Types.GetLoadedModules();   // Makes sure all modules are instantiated, allowing static constructors to add

                                            // appropriate data sources, if necessary.


                await GetDataSources.Raise(typeof(Gateway), Sources);


                concentratorServer = await ConcentratorServer.Create(xmppClient, thingRegistryClient, provisioningClient, Sources.Sources);

                avatarClient = new AvatarClient(xmppClient, pepClient);


                Types.SetModuleParameter("Concentrator", concentratorServer);

                Types.SetModuleParameter("Sources", concentratorServer.DataSources);

                Types.SetModuleParameter("DefaultSource", MeteringTopology.SourceID);

                Types.SetModuleParameter("Sensor", concentratorServer.SensorServer);

                Types.SetModuleParameter("Control", concentratorServer.ControlServer);

                Types.SetModuleParameter("Registry", thingRegistryClient);

                Types.SetModuleParameter("Provisioning", provisioningClient);

                Types.SetModuleParameter("Contracts", contractsClient);

                Types.SetModuleParameter("Avatar", avatarClient);

                Types.SetModuleParameter("Scheduler", scheduler);

                Types.SetModuleParameter("FavIcon", GetUrl("/favicon.ico"));


                if (HasDomain)

                    Types.SetModuleParameter("Domain", Domain.Value);


                if (FirstStart)

                {

                    concentratorServer.SensorServer.AssignAuthority += SensorServer_AssignAuthority;

                    MeteringTopology.OnNewMomentaryValues += NewMomentaryValues;

                    ProvisionedMeteringNode.QrCodeUrlRequested += ProvisionedMeteringNode_QrCodeUrlRequested;

                }


                DeleteOldDataSourceEvents(null);


                try

                {

                    string BinaryFolder = AppDomain.CurrentDomain.BaseDirectory;

                    string[] LanguageFiles = Directory.GetFiles(BinaryFolder, "*.lng", SearchOption.AllDirectories);

                    string FileName;


                    if (LanguageFiles.Length > 0)

                    {

                        XmlSchema Schema = XSL.LoadSchema(Translator.SchemaResource, typeof(Translator).Assembly);


                        foreach (string LanguageFile in LanguageFiles)

                        {

                            string Xml = null;


                            try

                            {

                                FileName = LanguageFile;

                                if (FileName.StartsWith(BinaryFolder))

                                    FileName = FileName[BinaryFolder.Length..];


                                DateTime LastWriteTime = File.GetLastWriteTimeUtc(LanguageFile);

                                DateTime LastImportedTime = await RuntimeSettings.GetAsync(FileName, DateTime.MinValue);


                                if (LastWriteTime > LastImportedTime)

                                {

                                    Log.Informational("Importing language file.", FileName);


                                    Xml = await Files.ReadAllTextAsync(LanguageFile);

                                    XmlDocument Doc = XML.ParseXml(Xml, true);


                                    XSL.Validate(FileName, Doc, Translator.SchemaRoot, Translator.SchemaNamespace, Schema);


                                    using (XmlReader r = new XmlNodeReader(Doc))

                                    {

                                        await Translator.ImportAsync(r);

                                    }


                                    RuntimeSettings.Set(FileName, LastWriteTime);

                                }

                            }

                            catch (XmlException ex)

                            {

                                ex = XML.AnnotateException(ex, Xml);

                                Log.Exception(ex, LanguageFile);

                            }

                            catch (Exception ex)

                            {

                                Log.Exception(ex, LanguageFile);

                            }

                        }

                    }


                    foreach (string UnhandledException in Directory.GetFiles(appDataFolder, "UnhandledException*.txt", SearchOption.TopDirectoryOnly))

                    {

                        try

                        {

                            string Msg = await Files.ReadAllTextAsync(UnhandledException);

                            File.Delete(UnhandledException);


                            StringBuilder sb = new StringBuilder();


                            sb.AppendLine("Unhandled Exception");

                            sb.AppendLine("=======================");

                            sb.AppendLine();

                            sb.AppendLine("```");

                            sb.AppendLine(Msg);

                            sb.AppendLine("```");


                            Log.Emergency(sb.ToString());

                        }

                        catch (Exception ex)

                        {

                            Log.Emergency(ex, UnhandledException);

                        }

                    }


                    ChunkedList<IModule> FailedModules = new ChunkedList<IModule>();


                    if (await Types.StartAllModules(int.MaxValue, new ModuleStartOrder(), null, FailedModules))

                        Log.Informational("Server started.");

                    else

                    {

                        StringBuilder sb = new StringBuilder();


                        sb.AppendLine("Unable to start all modules. The following modules failed to load:");

                        sb.AppendLine();


                        foreach (IModule Module in FailedModules)

                        {

                            sb.Append("* `");

                            sb.Append(Module.GetType().FullName);

                            sb.AppendLine("`");

                        }


                        Log.Critical(sb.ToString());

                    }


                    await HttpModule.CheckLocalWebServerNode();

                    await ProcessServiceConfigurations(false);


                    if (!(NewConfigurations is null))

                    {

                        foreach (SystemConfiguration Configuration in NewConfigurations)

                        {

                            StringBuilder sb = new StringBuilder();


                            sb.AppendLine("New System Configuration");

                            sb.AppendLine("=============================");

                            sb.AppendLine();

                            sb.AppendLine("A new system configuration is available.");

                            sb.AppendLine("It has been set to simplified configuration, to not stop processing.");

                            sb.AppendLine("You should review the configuration however, as soon as possible.");

                            sb.AppendLine();

                            sb.Append("[Click here to review the new system configuration](http");


                            if (DomainConfiguration.Instance.UseEncryption && !string.IsNullOrEmpty(DomainConfiguration.Instance.Domain))

                                sb.Append('s');


                            sb.Append("://");

                            sb.Append(DomainConfiguration.Instance.Domain);

                            sb.Append(Configuration.Resource);

                            sb.AppendLine(").");


                            Log.Alert(sb.ToString());

                        }

                    }

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }

                finally

                {

                    if (!(webServer is null))

                    {

                        webServer.ResourceOverride = null;

                        webServer.ResourceOverrideFilter = null;


                        if (webServer.GetPorts(true, true).Length == 0) // No ports opened

                            ScheduleEvent(AttemptReopenPorts, DateTime.Now.AddMinutes(1), null);

                    }


                    if (!(startingServer is null))

                    {

                        await startingServer.ReleaseMutex();

                        startingServer.Dispose();

                        startingServer = null;

                    }


                    if (xmppClient.State != XmppState.Connected)

                        await xmppClient.Connect();

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);


                if (!(startingServer is null))

                {

                    await startingServer.ReleaseMutex();

                    startingServer.Dispose();

                    startingServer = null;

                }


                if (!(gatewayRunning is null))

                {

                    await gatewayRunning.ReleaseMutex();

                    gatewayRunning.Dispose();

                    gatewayRunning = null;

                }


                ExceptionDispatchInfo.Capture(ex).Throw();

            }


            return true;

        }


        public static async Task CheckWAF()

        {

            string WafFile = Path.Combine(appDataFolder, WebApplicationFirewallLocalFileName);

            if (File.Exists(WafFile))

            {

                try

                {

                    DateTime LastUpdated = File.GetLastWriteTimeUtc(WafFile);


                    if (LastUpdated > wafTimestamp)

                    {

                        if (webServer.WebApplicationFirewall is null)

                        {

                            WebApplicationFirewall Waf = WebApplicationFirewall.LoadFromFile(WafFile, loginAuditor, appDataFolder);

                            webServer.WebApplicationFirewall = Waf;

                            Log.Informational("Web Application Firewall configuration loaded.", WafFile);

                        }

                        else

                        {

                            await webServer.WebApplicationFirewall.Reload();

                            Log.Informational("Web Application Firewall configuration reloaded due to file change.", WafFile);

                        }


                        wafTimestamp = LastUpdated;

                    }

                }

                catch (Exception ex)

                {

                    Log.Exception(ex, WafFile);

                }

            }

        }


        private static void AttemptReopenPorts(object _)

        {

            webServer.NetworkChanged();


            if (webServer.GetPorts(true, true).Length == 0) // No ports opened

                ScheduleEvent(AttemptReopenPorts, DateTime.Now.AddMinutes(1), null);

        }


        private static Task GetCustomHttpSniffers(object Sender, CustomSniffersEventArgs e)

        {

            int i, c = e.Sniffers?.Length ?? 0;


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

            {

                if (e.Sniffers[i] is XmlFileSniffer)

                {

                    string RemoteIp = e.RemoteEndpoint.RemovePortNumber();


                    if (!(xmlFileSnifferCache?.TryGetValue(RemoteIp, out XmlFileSniffer Cached) ?? false))

                    {

                        Cached = new XmlFileSniffer(appDataFolder + "HTTP" + Path.DirectorySeparatorChar +

                            RemoteIp.Replace(':', '_') + Path.DirectorySeparatorChar +

                            "HTTP Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",

                            appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",

                            7, BinaryPresentationMethod.ByteCount);


                        Cached.OnBeforeWrite += (sender, e2) =>

                        {

                            xmlFileSnifferCache?.Ping(RemoteIp);

                        };


                        xmlFileSnifferCache?.Add(RemoteIp, Cached);

                    }


                    e.Sniffers[i] = Cached;

                }

            }


            return Task.CompletedTask;

        }


        private static async Task XmlFileSnifferCache_Removed(object Sender, CacheItemEventArgs<string, XmlFileSniffer> e)

        {

            await e.Value.DisposeAsync();

        }


        private static Task ProvisionedMeteringNode_QrCodeUrlRequested(object Sender, GetQrCodeUrlEventArgs e)

        {

            StringBuilder Link = new StringBuilder();

            Link.Append("https://");


            if (HasDomain)

                Link.Append(Domain);

            else

                Link.Append(XmppClient.Domain);


            Link.Append("/QR/");

            Link.Append(WebUtility.UrlEncode(e.Text));

            Link.Append("?w=400&h=400&q=2");


            e.Url = Link.ToString();


            return Task.CompletedTask;

        }


        private static async Task StartingMd(HttpRequest Request, HttpResponse Response)

        {

            if (string.IsNullOrEmpty(webServer?.ResourceOverride))

                throw new TemporaryRedirectException("/");


            string Markdown;


            try

            {

                Markdown = await Files.ReadAllTextAsync(Path.Combine(rootFolder, "Starting.md"));

            }

            catch (Exception)

            {

                StringBuilder sb = new StringBuilder();


                sb.AppendLine("Title: Starting");

                sb.AppendLine("Description: The starting page will be displayed while the service is being started.");

                sb.AppendLine("Cache-Control: max-age=0, no-cache, no-store");

                sb.AppendLine("Refresh: 2");

                sb.AppendLine();

                sb.AppendLine("============================================================================================================================================");

                sb.AppendLine();

                sb.AppendLine("Starting Service");

                sb.AppendLine("====================");

                sb.AppendLine();

                sb.AppendLine("Please wait while the service is being started. This page will update automatically.");


                Markdown = sb.ToString();

            }


            Variables v = Request.Session ?? new Variables();

            MarkdownSettings Settings = new MarkdownSettings(emoji1_24x24, true, v);

            MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Markdown, Settings);

            string Html = await Doc.GenerateHTML();


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

            await Response.Write(true, System.Text.Encoding.UTF8.GetBytes(Html));

            await Response.SendResponse();

        }


        private static Task GoToDefaultPage(HttpRequest Request, HttpResponse Response)

        {

            if (TryGetDefaultPage(Request, out string DefaultPage))

                return Response.SendResponse(new TemporaryRedirectException(DefaultPage));

            else

                return Response.SendResponse(new NotFoundException("No default page defined."));

        }


        private class ModuleStartOrder : IComparer<IModule>

        {

            private readonly DependencyOrder dependencyOrder = new DependencyOrder();


            public int Compare(IModule x, IModule y)

            {

                int c1 = this.ModuleCategory(x);

                int c2 = this.ModuleCategory(y);


                int i = c1 - c2;

                if (i != 0)

                    return i;


                return this.dependencyOrder.Compare(x, y);

            }


            private int ModuleCategory(IModule x)

            {

                if (x is Persistence.LifeCycle.DatabaseModule)

                    return 1;

                else if (x is Runtime.Transactions.TransactionModule)

                    return 2;

                else if (x is NetworkingModule)

                    return int.MaxValue;

                else

                    return 3;

            }

        }


        private static async Task RepairIfInproperShutdown()

        {

            IDatabaseProvider DatabaseProvider = Database.Provider;

            Type ProviderType = DatabaseProvider.GetType();

            PropertyInfo AutoRepairReportFolder = ProviderType.GetProperty("AutoRepairReportFolder");

            AutoRepairReportFolder?.SetValue(DatabaseProvider, Path.Combine(AppDataFolder, "Backup"));


            MethodInfo MI = ProviderType.GetMethod("RepairIfInproperShutdown", new Type[] { typeof(string) });


            if (!(MI is null))

            {

                Task T = MI.Invoke(DatabaseProvider, new object[] { AppDataFolder + "Transforms" + Path.DirectorySeparatorChar + "DbStatXmlToHtml.xslt" }) as Task;


                if (T is Task<string[]> StringArrayTask)

                    DatabaseConfiguration.RepairedCollections = await StringArrayTask;

                else if (!(T is null))

                    await T;

            }

        }


        private static async Task WriteWebServerOpenPorts()

        {

            StringBuilder sb = new StringBuilder();


            foreach (int Port in webServer.OpenPorts)

                sb.AppendLine(Port.ToString());


            try

            {

                await Files.WriteAllTextAsync(appDataFolder + "Ports.txt", sb.ToString());

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        private static void Assert_UnauthorizedAccess(object Sender, UnauthorizedAccessEventArgs e)

        {

            DateTime Now = DateTime.Now;

            string Key = e.Trace.ToString();


            lock (lastUnauthorizedAccess)

            {

                if (lastUnauthorizedAccess.TryGetValue(Key, out DateTime TP) && (Now - TP).TotalHours < 1)

                    return;


                lastUnauthorizedAccess[Key] = Now;

            }


            StringBuilder Markdown = new StringBuilder();


            Markdown.AppendLine("Unauthorized access detected and prevented.");

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

            Markdown.AppendLine();

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

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

            Markdown.Append("| Method | `");

            Markdown.Append(e.Method.Name);

            Markdown.AppendLine("` |");

            Markdown.Append("| Type | `");

            Markdown.Append(e.Type.FullName);

            Markdown.AppendLine("` |");

            Markdown.Append("| Assembly | `");

            Markdown.Append(e.Assembly.GetName().Name);

            Markdown.AppendLine("` |");

            Markdown.Append("| Date | ");

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

            Markdown.AppendLine(" |");

            Markdown.Append("| Time | ");

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

            Markdown.AppendLine(" |");

            Markdown.AppendLine();

            Markdown.AppendLine("Stack Trace:");

            Markdown.AppendLine();

            Markdown.AppendLine("```");

            Markdown.AppendLine(Log.CleanStackTrace(e.Trace.ToString()));

            Markdown.AppendLine("```");


            SendNotification(Markdown.ToString());

        }


        private static void CheckContentFiles(string ManifestFileName, Dictionary<string, CopyOptions> ContentOptions)

        {

            try

            {

                XmlDocument Doc = XML.LoadFromFile(ManifestFileName, true);


                if (!(Doc.DocumentElement is null) &&

                    Doc.DocumentElement.LocalName == "Module" &&

                    Doc.DocumentElement.NamespaceURI == "http://waher.se/Schema/ModuleManifest.xsd")

                {

                    CheckContentFiles(Doc.DocumentElement, runtimeFolder, runtimeFolder, appDataFolder, ContentOptions);

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex, ManifestFileName);

            }

        }


        private enum CopyOptions

        {

            IfNewer,

            Always,

            IfNotExists

        }


        private static void CheckContentFiles(XmlElement Element, string RuntimeFolder, string RuntimeSubfolder, string AppDataSubFolder,

            Dictionary<string, CopyOptions> ContentOptions)

        {

            bool AppDataFolderChecked = false;


            foreach (XmlNode N in Element.ChildNodes)

            {

                if (N is XmlElement E)

                {

                    switch (E.LocalName)

                    {

                        case "Folder":

                            string Name = XML.Attribute(E, "name");

                            CheckContentFiles(E, RuntimeFolder, Path.Combine(RuntimeSubfolder, Name), Path.Combine(AppDataSubFolder, Name),

                                ContentOptions);

                            break;


                        case "Content":

                            Name = XML.Attribute(E, "fileName");

                            CopyOptions CopyOptions = XML.Attribute(E, "copy", CopyOptions.IfNewer);


                            string s = Path.Combine(RuntimeSubfolder, Name);

                            if (!File.Exists(s))

                            {

                                s = Path.Combine(RuntimeFolder, Name);

                                if (!File.Exists(s))

                                    break;

                            }


                            if (!AppDataFolderChecked)

                            {

                                AppDataFolderChecked = true;


                                if (!Directory.Exists(AppDataSubFolder))

                                    Directory.CreateDirectory(AppDataSubFolder);

                            }


                            string s2 = Path.Combine(AppDataSubFolder, Name);


                            if (CopyOptions == CopyOptions.Always || !File.Exists(s2))

                            {

                                File.Copy(s, s2, true);

                                ContentOptions[s2] = CopyOptions;

                            }

                            else

                            {

                                DateTime TP = File.GetLastWriteTimeUtc(s);

                                DateTime TP2 = File.GetLastWriteTimeUtc(s2);


                                if (TP > TP2 &&

                                    (!ContentOptions.TryGetValue(s2, out CopyOptions CopyOptions2) ||

                                    CopyOptions2 != CopyOptions.Always))

                                {

                                    File.Copy(s, s2, true);

                                    ContentOptions[s2] = CopyOptions;

                                }

                            }

                            break;

                    }

                }

            }

        }


        private static void CheckInstallUtilityFiles(string ManifestFileName)

        {

            try

            {

                XmlDocument Doc = XML.LoadFromFile(ManifestFileName, true);


                if (!(Doc.DocumentElement is null) &&

                    Doc.DocumentElement.LocalName == "Module" &&

                    Doc.DocumentElement.NamespaceURI == "http://waher.se/Schema/ModuleManifest.xsd")

                {

                    string InstallUtilityFolder = Path.Combine(runtimeFolder, "InstallUtility");

                    bool NoticeLogged = false;


                    if (!Directory.Exists(InstallUtilityFolder))

                        Directory.CreateDirectory(InstallUtilityFolder);


                    foreach (XmlNode N in Doc.DocumentElement.ChildNodes)

                    {

                        if (N is XmlElement E)

                        {

                            switch (E.LocalName)

                            {

                                case "Assembly":

                                    string Name = XML.Attribute(E, "fileName");

                                    CopyOptions CopyOptions = XML.Attribute(E, "copy", CopyOptions.IfNewer);


                                    string s = Path.Combine(runtimeFolder, Name);

                                    if (!File.Exists(s))

                                        break;


                                    string s2 = Path.Combine(InstallUtilityFolder, Name);


                                    if (CopyOptions == CopyOptions.IfNewer && File.Exists(s2))

                                    {

                                        DateTime TP = File.GetLastWriteTimeUtc(s);

                                        DateTime TP2 = File.GetLastWriteTimeUtc(s2);


                                        if (TP <= TP2)

                                            break;

                                    }


                                    if (!NoticeLogged)

                                    {

                                        NoticeLogged = true;

                                        Log.Notice("Copying Installation Utility executable files to InstallUtility subfolder.");

                                    }


                                    File.Copy(s, s2, true);

                                    break;

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex, ManifestFileName);

            }

        }


        internal static bool ConsoleOutput => consoleOutput;


        internal static async Task ConfigureXmpp(XmppConfiguration Configuration)

        {

            xmppCredentials = Configuration.GetCredentials();

            xmppClient = new XmppClient(xmppCredentials, "en", typeof(Gateway).Assembly);

            xmppClient.OnValidateSender += XmppClient_OnValidateSender;

            Types.SetModuleParameter("XMPP", xmppClient);


            if (xmppCredentials.Sniffer)

            {

                ISniffer Sniffer;


                if (consoleOutput)

                {

                    Sniffer = new ConsoleOutSniffer(BinaryPresentationMethod.ByteCount, LineEnding.PadWithSpaces);

                    xmppClient.Add(Sniffer);

                }


                Sniffer = new XmlFileSniffer(appDataFolder + "XMPP" + Path.DirectorySeparatorChar +

                    "XMPP Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",

                    appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",

                    7, BinaryPresentationMethod.ByteCount);

                xmppClient.Add(Sniffer);

            }


            if (!string.IsNullOrEmpty(xmppCredentials.Events))

            {

                string s = xmppCredentials.Events;

                int i = s.IndexOf('.');

                if (i > 0)

                    s = s[(i + 1)..];


                if (!IsDomain(s, true))

                {

                    Log.Register(new EventFilter("XMPP Event Filter",

                        new XmppEventSink("XMPP Event Sink", xmppClient, xmppCredentials.Events, false),

                        EventType.Critical, (Event) => string.IsNullOrEmpty(Event.Facility)));

                }

            }


            if (!string.IsNullOrEmpty(xmppCredentials.ThingRegistry))

            {

                thingRegistryClient = new ThingRegistryClient(xmppClient, xmppCredentials.ThingRegistry);

                thingRegistryClient.Claimed += ThingRegistryClient_Claimed;

                thingRegistryClient.Disowned += ThingRegistryClient_Disowned;

                thingRegistryClient.Removed += ThingRegistryClient_Removed;

            }


            if (!string.IsNullOrEmpty(xmppCredentials.Provisioning))

                provisioningClient = new ProvisioningClient(xmppClient, xmppCredentials.Provisioning);

            else

                provisioningClient = null;


            scheduler.Add(DateTime.Now.AddMinutes(1), CheckConnection, null);


            xmppClient.OnStateChanged += XmppClient_OnStateChanged;


            ibbClient = new Networking.XMPP.InBandBytestreams.IbbClient(xmppClient, MaxChunkSize);

            Types.SetModuleParameter("IBB", ibbClient);


            socksProxy = new Socks5Proxy(xmppClient);

            Types.SetModuleParameter("SOCKS5", socksProxy);


            sensorClient = new SensorClient(xmppClient);

            controlClient = new ControlClient(xmppClient);

            concentratorClient = new ConcentratorClient(xmppClient);

            synchronizationClient = new SynchronizationClient(xmppClient);

            pepClient = new PepClient(xmppClient, XmppConfiguration.Instance.PubSub);


            if (!string.IsNullOrEmpty(XmppConfiguration.Instance.LegalIdentities))

            {

                contractsClient = new ContractsClient(xmppClient, XmppConfiguration.Instance.LegalIdentities);

                contractsClient.SetKeySettingsInstance(string.Empty, true);


                await contractsClient.LoadKeys(true);

            }

            else

                contractsClient = null;


            if (!string.IsNullOrEmpty(XmppConfiguration.Instance.MultiUserChat))

                mucClient = new MultiUserChatClient(xmppClient, XmppConfiguration.Instance.MultiUserChat);

            else

                mucClient = null;


            if (!string.IsNullOrEmpty(XmppConfiguration.Instance.SoftwareUpdates))

            {

                string PackagesFolder = Path.Combine(appDataFolder, "Packages");

                if (!Directory.Exists(PackagesFolder))

                    Directory.CreateDirectory(PackagesFolder);


                softwareUpdateClient = new SoftwareUpdateClient(xmppClient, XmppConfiguration.Instance.SoftwareUpdates, PackagesFolder);

            }

            else

                softwareUpdateClient = null;


            if (!string.IsNullOrEmpty(XmppConfiguration.Instance.Geo))

                geoClient = new GeoClient(xmppClient, XmppConfiguration.Instance.Geo);

            else

                geoClient = null;


            mailClient = new MailClient(xmppClient);

            mailClient.MailReceived += MailClient_MailReceived;

        }


        internal static async Task ConfigureDomain(DomainConfiguration Configuration)

        {

            int i, c = Configuration.AlternativeDomains?.Length ?? 0;


            domain = Configuration.Domain;

            alternativeDomains = new CaseInsensitiveString[c];


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

                alternativeDomains[i] = Configuration.AlternativeDomains[i];


            if (Configuration.UseDomainName)

            {

                if (Configuration.DynamicDns)

                {

                    await Configuration.CheckDynamicIp();


                    if (Configuration.DynDnsInterval > 0)

                    {

                        if (checkIp > DateTime.MinValue)

                        {

                            scheduler.Remove(checkIp);

                            checkIp = DateTime.MinValue;

                        }


                        checkIp = scheduler.Add(DateTime.Now.AddSeconds(Configuration.DynDnsInterval), CheckIp, Configuration);

                    }

                }


                if (Configuration.UseEncryption && Configuration.HasCertificate)

                {

                    await UpdateCertificate(Configuration);


                    if (checkCertificate > DateTime.MinValue)

                    {

                        scheduler.Remove(checkCertificate);

                        checkCertificate = DateTime.MinValue;

                    }


                    checkCertificate = scheduler.Add(DateTime.Now.AddHours(0.5 + NextDouble()), CheckCertificate, Configuration);

                }

                else

                    certificate = null;

            }

            else

                certificate = null;


            if (!Users.HashMethodLocked)

                Users.Register(ComputeUserPasswordHash, "DIGEST-SHA3-256", LoginAuditor, domain, true);


            await Privileges.LoadAll();

            await Roles.LoadAll();

        }


        public static byte[] ComputeUserPasswordHash(string UserName, string Password)

        {

            SHA3_256 H = new SHA3_256();

            return H.ComputeVariable(System.Text.Encoding.UTF8.GetBytes(UserName + ":" + domain.Value + ":" + Password));

        }


        internal static async Task<bool> UpdateCertificate(DomainConfiguration Configuration)

        {

            try

            {

                if (!(Configuration.PFX is null))

                    certificate = new X509Certificate2(Configuration.PFX, Configuration.Password);

                else

                {

                    RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

                    RSA.ImportCspBlob(Configuration.PrivateKey);


                    certificate = new X509Certificate2(Configuration.Certificate)

                    {

                        PrivateKey = RSA

                    };

                }


                try

                {

                    webServer?.UpdateCertificate(Certificate);


                    foreach (IEventSink Sink in Log.Sinks)

                    {

                        if (Sink is ITlsCertificateEndpoint TlsCertificateEndpoint)

                            TlsCertificateEndpoint.UpdateCertificate(Certificate);

                    }


                    await OnNewCertificate.Raise(typeof(Gateway), new Events.CertificateEventArgs(certificate));

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                return true;

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }


            return false;

        }


        private static async void CheckCertificate(object P)

        {

            DomainConfiguration Configuration = (DomainConfiguration)P;

            DateTime Now = DateTime.Now;


            try

            {

                if (Now.AddDays(50) >= certificate.NotAfter)

                {

                    Log.Notice("Updating certificate");


                    if (await Configuration.CreateCertificate())

                    {

                        Log.Notice("Certificate created.");

                        if (!await UpdateCertificate(Configuration))

                            Log.Error("Unable to update gatetway with new certificate.");

                    }

                    else

                    {

                        int DaysLeft = (int)Math.Round((certificate.NotAfter - Now.Date).TotalDays);


                        if (DaysLeft < 2)

                            Log.Emergency("Unable to generate new certificate.", domain);

                        else if (DaysLeft < 5)

                            Log.Alert("Unable to generate new certificate.", domain);

                        else if (DaysLeft < 10)

                            Log.Critical("Unable to generate new certificate.", domain);

                        else if (DaysLeft < 20)

                            Log.Error("Unable to generate new certificate.", domain);

                        else

                            Log.Warning("Unable to generate new certificate.", domain);

                    }

                }

            }

            catch (Exception ex)

            {

                int DaysLeft = (int)Math.Round((certificate.NotAfter - Now.Date).TotalDays);


                if (DaysLeft < 2)

                    Log.Emergency(ex, domain);

                else if (DaysLeft < 5)

                    Log.Alert(ex, domain);

                else

                    Log.Exception(ex);

            }

            finally

            {

                checkCertificate = scheduler.Add(DateTime.Now.AddDays(0.5 + NextDouble()), CheckCertificate, Configuration);

            }

        }


        public static event EventHandlerAsync<Events.CertificateEventArgs> OnNewCertificate = null;


        private static async void CheckIp(object P)

        {

            DomainConfiguration Configuration = (DomainConfiguration)P;


            try

            {

                await Configuration.CheckDynamicIp();

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

            finally

            {

                checkIp = scheduler.Add(DateTime.Now.AddSeconds(Configuration.DynDnsInterval), CheckIp, Configuration);

            }

        }


        private static async void DeleteOldDataSourceEvents(object P)

        {

            try

            {

                TimeSpan Limit = TimeSpan.FromDays(7);


                await MeteringTopology.DeleteOldEvents(Limit);

                await GroupSource.DeleteOldEvents(Limit);

                await JobSource.DeleteOldEvents(Limit);

                await ProcessorSource.DeleteOldEvents(Limit);

                await OutputSource.DeleteOldEvents(Limit);

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

            finally

            {

                ScheduleEvent(DeleteOldDataSourceEvents, DateTime.Today.AddDays(1).AddHours(4), null);

            }

        }


        public static event GetDatabaseProviderEventHandler GetDatabaseProvider = null;


        public static event EventHandlerAsync<GetDataSourcesEventArgs> GetDataSources = null;


        public static CommunicationLayer FirstChanceExceptions => firstChanceExceptions;


        private static void Initialize()

        {

            string Folder = Assembly.GetExecutingAssembly().Location;

            if (string.IsNullOrEmpty(Folder))

                Folder = AppDomain.CurrentDomain.BaseDirectory;


            runtimeFolder = Path.GetDirectoryName(Folder);


            Directory.SetCurrentDirectory(runtimeFolder);


            TypesLoader.Initialize(runtimeFolder, (FileName) =>

            {

                FileName = Path.GetFileName(FileName).ToLower();

                if (FileName.StartsWith("api-ms-win-") ||

                    FileName.StartsWith("system.") ||

                    FileName.StartsWith("microsoft.") ||

                    FileName.StartsWith("windows.") ||

                    FileName.StartsWith("waher.client.") ||

                    FileName.StartsWith("waher.utility.") ||

                    FileName.StartsWith("mscordaccore_x86_x86_") ||

                    FileName.StartsWith("sos_x86_x86_"))

                {

                    return false;

                }


                switch (FileName)

                {

                    case "clrcompression.dll":

                    case "clretwrc.dll":

                    case "clrgc.dll":

                    case "clrjit.dll":

                    case "coreclr.dll":

                    case "dbgshim.dll":

                    case "hostpolicy.dll":

                    case "hostfxr.dll":

                    case "libegl.dll":

                    case "libglesv2.dll":

                    case "libskiasharp.dll":

                    case "libzstd.dll":

                    case "mongocrypt.dll":

                    case "mscordaccore.dll":

                    case "mscordbi.dll":

                    case "mscorlib.dll":

                    case "mscorrc.debug.dll":

                    case "mscorrc.dll":

                    case "msquic.dll":

                    case "netstandard.dll":

                    case "snappy32.dll":

                    case "snappy64.dll":

                    case "snappier.dll":

                    case "sni.dll":

                    case "sos.dll":

                    case "sos.netcore.dll":

                    case "ucrtbase.dll":

                    case "windowsbase.dll":

                    case "waher.persistence.fileslw.dll":

                    case "waher.persistence.serialization.dll":

                    case "zstdsharp.dll":

                        return false;

                }


                return true;

            });

        }


        private static bool CopyFile(string From, string To, CopyOptions CopyOptions)

        {

            if (From == To)

                return false;


            if (!File.Exists(From))

                return false;


            if (CopyOptions != CopyOptions.Always && File.Exists(To))

            {

                if (CopyOptions == CopyOptions.IfNotExists)

                    return false;

                else if (CopyOptions == CopyOptions.IfNewer)

                {

                    DateTime ToTP = File.GetLastWriteTimeUtc(To);

                    DateTime FromTP = File.GetLastWriteTimeUtc(From);


                    if (ToTP >= FromTP)

                        return false;

                }

            }


            File.Copy(From, To, true);


            return true;

        }


        private static void CopyFolder(string From, string To, string Mask, CopyOptions CopyOptions)

        {

            if (Directory.Exists(From))

            {

                if (!Directory.Exists(To))

                    Directory.CreateDirectory(To);


                string[] Files = Directory.GetFiles(From, Mask, SearchOption.TopDirectoryOnly);


                foreach (string File in Files)

                {

                    string FileName = Path.GetFileName(File);

                    CopyFile(File, Path.Combine(To, FileName), CopyOptions);

                }

            }

        }


        private static void CopyFolders(string From, string To, CopyOptions CopyOptions)

        {

            if (Directory.Exists(From))

            {

                CopyFolder(From, To, "*.*", CopyOptions);


                string[] Folders = Directory.GetDirectories(From, "*.*", SearchOption.TopDirectoryOnly);


                foreach (string Folder in Folders)

                {

                    string FolderName = Path.GetFileName(Folder);

                    CopyFolders(Folder, Path.Combine(To, FolderName), CopyOptions);

                }

            }

        }


        public static async Task Stop()

        {

            if (stopped)

            {

                Log.Notice("Request to stop Gateway, but Gateway already stopped.");

                return;

            }


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


            bool StopInternalProvider = !(internalProvider is null) && Database.Provider != internalProvider;


            stopped = true;

            try

            {

                SafeDispose(scheduler);

                scheduler = null;


                try

                {

                    await PlantUml.Terminate();

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                try

                {

                    await GraphViz.Terminate();

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                try

                {

                    await Script.Threading.Functions.Background.TerminateTasks(10000);

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                try

                {

                    await Types.StopAllModules();

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                Database.CollectionRepaired -= Database_CollectionRepaired;


                if (StopInternalProvider)

                {

                    try

                    {

                        await internalProvider.Stop();

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                    }

                }


                if (!(startingServer is null))

                {

                    await startingServer.ReleaseMutex();

                    SafeDispose(startingServer);

                    startingServer = null;

                }


                if (!(gatewayRunning is null))

                {

                    await gatewayRunning.ReleaseMutex();

                    SafeDispose(gatewayRunning);

                    gatewayRunning = null;

                }


                if (!(configurations is null))

                {

                    foreach (SystemConfiguration Configuration in configurations)

                    {

                        try

                        {

                            if (Configuration is IDisposableAsync DAsync)

                                await SafeDispose(DAsync);

                            else if (Configuration is IDisposable D)

                                SafeDispose(D);

                        }

                        catch (Exception ex)

                        {

                            Log.Exception(ex);

                        }

                    }


                    configurations = null;

                }


                SafeDispose(ibbClient);

                ibbClient = null;


                SafeDispose(httpxProxy);

                httpxProxy = null;


                SafeDispose(httpxServer);

                httpxServer = null;


                SafeDispose(provisioningClient);

                provisioningClient = null;


                SafeDispose(thingRegistryClient);

                thingRegistryClient = null;


                SafeDispose(concentratorServer);

                concentratorServer = null;


                SafeDispose(avatarClient);

                avatarClient = null;


                SafeDispose(sensorClient);

                sensorClient = null;


                SafeDispose(controlClient);

                controlClient = null;


                SafeDispose(concentratorClient);

                concentratorClient = null;


                SafeDispose(synchronizationClient);

                synchronizationClient = null;


                SafeDispose(pepClient);

                pepClient = null;


                SafeDispose(mucClient);

                mucClient = null;


                SafeDispose(mailClient);

                mailClient = null;


                SafeDispose(contractsClient);

                contractsClient = null;


                SafeDispose(softwareUpdateClient);

                softwareUpdateClient = null;


                SafeDispose(geoClient);

                geoClient = null;


                if (!(xmppClient is null))

                {

                    try

                    {

                        await xmppClient.OfflineAndDisposeAsync();

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                    }


                    xmppClient = null;

                }


                await SafeDispose(coapEndpoint);

                coapEndpoint = null;


                InternetContent.LocalDomainCheck -= InternetContent_LocalDomainCheck;


                if (!(webServer is null))

                {

                    try

                    {

                        await webServer.RemoveRange(webServer.Sniffers, true);

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex);

                    }


                    await SafeDispose(webServer);

                    webServer = null;

                }


                SafeDispose(xmlFileSnifferCache);

                xmlFileSnifferCache = null;


                SafeDispose(jwtFactory);

                jwtFactory = null;


                SafeDispose(mcpSniffers);

                mcpSniffers = null;


                root = null;


                if (exportExceptions)

                {

                    lock (exceptionFile)

                    {

                        exportExceptions = false;

                        firstChanceExceptions = null;


                        exceptionFile.WriteLine(new string('-', 80));

                        exceptionFile.Write("End of export: ");

                        exceptionFile.WriteLine(DateTime.Now.ToString());


                        exceptionFile.Flush();

                        exceptionFile.Close();

                    }


                    exceptionFile = null;

                }

            }

            finally

            {

                Persistence.LifeCycle.DatabaseModule.Flush().Wait(60000);


                if (StopInternalProvider)

                    internalProvider.Flush().Wait(60000);

            }

        }


        public static void SafeDispose(IDisposable Object)

        {

            if (!(Object is null))

            {

                try

                {

                    Object.Dispose();

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }

            }

        }


        public static async Task SafeDispose(IDisposableAsync Object)

        {

            if (!(Object is null))

            {

                try

                {

                    await Object.DisposeAsync();

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }

            }

        }


        public static X509Certificate2 Certificate => certificate ?? Types.TryGetModuleParameter<X509Certificate2>("X509");


        public static CaseInsensitiveString Domain => domain;


        public static bool HasDomain

        {

            get

            {

                if (!(DomainConfiguration.Instance?.UseDomainName ?? false))

                    return false;


                if (CaseInsensitiveString.IsNullOrEmpty(domain))

                    return false;


                switch (domain.LowerCase)

                {

                    case "localhost":

                    case "example.com":

                    case "example2.com":

                    case "example3.com":

                    case "example.org":

                    case "example2.org":

                    case "example3.org":

                        return false;


                    default:

                        return true;

                }

            }

        }


        public static CaseInsensitiveString[] AlternativeDomains => alternativeDomains;


        public static string InstanceName => instance;


        public static string AppDataFolder => appDataFolder ?? Types.TryGetModuleParameter<string>("AppData");


        public static string RuntimeFolder => runtimeFolder ?? Types.TryGetModuleParameter<string>("Runtime");


        public static string RootFolder => rootFolder ?? Types.TryGetModuleParameter<string>("Root");


        public static string ReportsFolder => reportsFolder ?? Types.TryGetModuleParameter<string>("Reports");


        public static HttpFolderResource Root => root;


        public static string ApplicationName

        {

            get => applicationName;

            internal set => applicationName = value;

        }


        public static Emoji1LocalFiles Emoji1_24x24 => emoji1_24x24;


        public static bool Configuring => configuring;


        public static IDatabaseProvider InternalDatabase => internalProvider;


        public static string ConfigFilePath => Path.Combine(appDataFolder, GatewayConfigLocalFileName);


        public static JwtFactory JwtFactory => jwtFactory;


        public static ISnifferSet McpSniffers => mcpSniffers;


        public static int[] GetConfigPorts(string Protocol)

        {

            List<int> Result = new List<int>();


            foreach (KeyValuePair<string, int> P in ports)

            {

                if (P.Key == Protocol)

                    Result.Add(P.Value);

            }


            return Result.ToArray();

        }


        public static string[] GetProtocols()

        {

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


            foreach (KeyValuePair<string, int> P in ports)

                Protocols[P.Key] = true;


            string[] Result = new string[Protocols.Count];

            Protocols.Keys.CopyTo(Result, 0);


            return Result;

        }


        public static Task Terminate()

        {

            EventHandlerAsync h = OnTerminate ?? throw new InvalidOperationException("No OnTerminate event handler set.");

            return h.Raise(instance, EventArgs.Empty, false);

        }


        public static event EventHandlerAsync OnTerminate = null;


        public static bool TryGetDefaultPage(HttpRequest Request, out string DefaultPage)

        {

            return TryGetDefaultPage(Request.Header.Host?.Value ?? string.Empty, out DefaultPage);

        }


        public static bool TryGetDefaultPage(string Host, out string DefaultPage)

        {

            if (defaultPageByHostName.TryGetValue(Host, out DefaultPage))

                return true;


            if (Host.StartsWith("www.", StringComparison.CurrentCultureIgnoreCase) && defaultPageByHostName.TryGetValue(Host[4..], out DefaultPage))

                return true;


            if (defaultPageByHostName.TryGetValue(string.Empty, out DefaultPage))

                return true;


            DefaultPage = string.Empty;

            return false;

        }


        internal static void SetDefaultPages(params KeyValuePair<string, string>[] DefaultPages)

        {

            Dictionary<string, string> List = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);


            foreach (KeyValuePair<string, string> P in DefaultPages)

                List[P.Key] = P.Value;


            defaultPageByHostName = List;

        }


        #endregion


        #region XMPP


        private static Task XmppClient_OnValidateSender(object Sender, ValidateSenderEventArgs e)

        {

            RosterItem Item;

            string BareJid = e.FromBareJID.ToLower();


            if (string.IsNullOrEmpty(BareJid) ||

                (!(xmppClient is null) &&

                (BareJid == xmppClient.Domain.ToLower() ||

                BareJid == xmppClient.BareJID.ToLower())))

            {

                e.Accept();

            }

            else if (BareJid.IndexOf('@') > 0 &&

                (xmppClient is null ||

                (Item = xmppClient.GetRosterItem(BareJid)) is null ||

                Item.State == SubscriptionState.None ||

                Item.State == SubscriptionState.Remove ||

                Item.State == SubscriptionState.Unknown))

            {

                foreach (XmlNode N in e.Stanza.ChildNodes)

                {

                    if (N.LocalName == "query" && N.NamespaceURI == XmppClient.NamespaceServiceDiscoveryInfo)

                        return Task.CompletedTask;

                }


                e.Reject();

            }


            return Task.CompletedTask;

        }


        private static async void CheckConnection(object State)

        {

            try

            {

                if (!stopped && !NetworkingModule.Stopping)

                {

                    scheduler.Add(DateTime.Now.AddMinutes(1), CheckConnection, null);


                    XmppState? State2 = xmppClient?.State;

                    if (State2.HasValue &&

                        (State2 == XmppState.Offline || State2 == XmppState.Error || State2 == XmppState.Authenticating) &&

                        !(xmppClient is null))

                    {

                        try

                        {

                            await xmppClient.Reconnect();

                        }

                        catch (Exception ex)

                        {

                            Log.Exception(ex);

                        }

                    }


                    await CheckBackup();


                    await MinuteTick.Raise(null, EventArgs.Empty);

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        public static event EventHandlerAsync MinuteTick = null;


        private static async Task XmppClient_OnStateChanged(object _, XmppState NewState)

        {

            switch (NewState)

            {

                case XmppState.Connected:

                    connected = true;


                    MarkdownToHtmlConverter.BareJID = xmppClient.BareJID;


                    if (!registered && !(thingRegistryClient is null))

                    {

                        _ = Task.Run(async () =>

                        {

                            try

                            {

                                await Register();

                            }

                            catch (Exception ex)

                            {

                                Log.Exception(ex);

                            }

                        });

                    }


                    if (!socksProxy.HasProxy)

                        await socksProxy.StartSearch(null);

                    break;


                case XmppState.Offline:

                    immediateReconnect = connected;

                    connected = false;


                    if (immediateReconnect &&

                        !(xmppClient is null) &&

                        !NetworkingModule.Stopping)

                    {

                        await xmppClient.Reconnect();

                    }

                    break;

            }

        }


        public static async Task CheckLocalLogin(HttpRequest Request)

        {

            Profiler Profiler = new Profiler();

            Profiler.Start();


            ProfilerThread Thread = Profiler.CreateThread("Check Local Login", ProfilerThreadType.Sequential);


            Thread.Start();

            try

            {

                Thread.NewState("Checks");


                string RemoteEndpoint = Request.RemoteEndPoint;

                string From;

                int i;

                bool DoLog = false;


                if (Request.Header.TryGetQueryParameter("debug", out string s) &&

                    CommonTypes.TryParse(s, out bool b))

                {

                    DoLog = b;

                }


                if (Request.Session is null)

                {

                    if (DoLog)

                        Log.Debug("No local login: No session.");


                    return;

                }


                if (Request.Session.TryGetVariable("from", out Variable v))

                {

                    if (string.IsNullOrEmpty(From = v.ValueObject as string))

                        From = "/";

                }

                else

                    From = Request.Header.ResourcePart;


                if (Request.Session.TryGetVariable("User", out v) &&

                    v.ValueObject is IUser &&

                    !string.IsNullOrEmpty(From) &&

                    !From.Contains("Login"))

                {

                    if (DoLog)

                        Log.Debug("Already logged in.");


                    await Request.Response.SendResponse(new SeeOtherException(From));

                    return;

                }


                if (!loopbackIntefaceAvailable && (XmppConfiguration.Instance is null || !XmppConfiguration.Instance.Complete || configuring))

                {

                    LoginAuditor.Success("User logged in by default, since XMPP not configued and loopback interface not available.",

                        string.Empty, Request.RemoteEndPoint, "Web");


                    await Login.DoLogin(Request, From);

                    return;

                }


                if (DoLog)

                    Log.Debug("Checking for local login from: " + RemoteEndpoint);


                i = RemoteEndpoint.LastIndexOf(':');

                if (i < 0 || !int.TryParse(RemoteEndpoint[(i + 1)..], out int Port))

                {

                    if (DoLog)

                        Log.Debug("Invalid port number: " + RemoteEndpoint);


                    return;

                }


                if (!IPAddress.TryParse(RemoteEndpoint[..i], out IPAddress Address))

                {

                    if (DoLog)

                        Log.Debug("Invalid IP Address: " + RemoteEndpoint);


                    return;

                }


                if (!IsLocalCall(Address, Request, DoLog))

                {

                    if (DoLog)

                        Log.Debug("Request not local: " + RemoteEndpoint);


                    return;

                }


#if !MONO

                if (XmppConfiguration.Instance is null || !XmppConfiguration.Instance.Complete || configuring)

#endif

                {

                    LoginAuditor.Success("Local user logged in.", string.Empty, Request.RemoteEndPoint, "Web");

                    await Login.DoLogin(Request, From);

                    return;

                }


#if !MONO

                try

                {

                    string FileName;

                    string Arguments;

                    bool WaitForExit;


                    switch (Environment.OSVersion.Platform)

                    {

                        case PlatformID.Win32S:

                        case PlatformID.Win32Windows:

                        case PlatformID.Win32NT:

                        case PlatformID.WinCE:

                            FileName = "netstat.exe";

                            Arguments = "-a -n -o";

                            WaitForExit = false;


                            Thread.NewState("netstat.exe");

                            break;


                        case PlatformID.Unix:

                        case PlatformID.MacOSX:

                            FileName = "netstat";

                            Arguments = "-anv -p tcp";

                            WaitForExit = true;


                            Thread.NewState("netstat");

                            break;


                        default:

                            if (DoLog)

                                Log.Debug("No local login: Unsupported operating system: " + Environment.OSVersion.Platform.ToString());


                            return;

                    }


                    using Process Proc = new Process();

                    ProcessStartInfo StartInfo = new ProcessStartInfo()

                    {

                        FileName = FileName,

                        Arguments = Arguments,

                        WindowStyle = ProcessWindowStyle.Hidden,

                        UseShellExecute = false,

                        RedirectStandardInput = true,

                        RedirectStandardOutput = true,

                        RedirectStandardError = true

                    };


                    DateTime Start = DateTime.Now;


                    Proc.StartInfo = StartInfo;

                    Proc.Start();


                    if (WaitForExit)

                    {

                        Proc.WaitForExit(5000);

                        if (!Proc.HasExited)

                            return;

                    }


                    string Output = Proc.StandardOutput.ReadToEnd();

                    DateTime Return = DateTime.Now;


                    Thread.Interval(Start, Return, "Shell");


                    if (DoLog)

                        Log.Debug("Netstat output:\r\n\r\n" + Output);


                    if (Proc.ExitCode != 0)

                    {

                        Thread.Exception(new Exception("Exit code: " + Proc.ExitCode.ToString()));


                        if (DoLog)

                            Log.Debug("Netstat exit code: " + Proc.ExitCode.ToString());


                        return;

                    }


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


                    foreach (string Row in Rows)

                    {

                        string[] Tokens = Regex.Split(Row, @"\s+");


                        switch (Environment.OSVersion.Platform)

                        {

                            case PlatformID.Win32S:

                            case PlatformID.Win32Windows:

                            case PlatformID.Win32NT:

                            case PlatformID.WinCE:

                                if (Tokens.Length < 6)

                                    break;


                                if (Tokens[1] != "TCP")

                                    break;


                                if (!SameEndpoint(Tokens[2], RemoteEndpoint))

                                    break;


                                if (Tokens[4] != "ESTABLISHED")

                                    break;


                                if (!int.TryParse(Tokens[5], out int PID))

                                    break;


                                Process P = Process.GetProcessById(PID);

                                int CurrentSession = WTSGetActiveConsoleSessionId();


                                if (P.SessionId == CurrentSession)

                                {

                                    LoginAuditor.Success("Local user logged in.", string.Empty, Request.RemoteEndPoint, "Web");

                                    await Login.DoLogin(Request, From);

                                    return;

                                }

                                break;


                            case PlatformID.Unix:

                            case PlatformID.MacOSX:

                                if (Tokens.Length < 9)

                                    break;


                                if (Tokens[0] != "tcp4" && Tokens[0] != "tcp6")

                                    break;


                                if (!SameEndpoint(Tokens[4], RemoteEndpoint))

                                    break;


                                if (Tokens[5] != "ESTABLISHED")

                                    break;


                                if (!int.TryParse(Tokens[8], out PID))

                                    break;


                                P = Process.GetProcessById(PID);

                                CurrentSession = Process.GetCurrentProcess().SessionId;


                                if (P.SessionId == CurrentSession)

                                {

                                    LoginAuditor.Success("Local user logged in.", string.Empty, Request.RemoteEndPoint, "Web");

                                    await Login.DoLogin(Request, From);

                                    return;

                                }

                                break;


                            default:

                                if (DoLog)

                                    Log.Debug("No local login: Unsupported operating system: " + Environment.OSVersion.Platform.ToString());


                                return;

                        }

                    }

                }

                catch (HttpException ex)

                {

                    Thread.Exception(ex);


                    if (DoLog)

                        Log.Exception(ex);


                    ExceptionDispatchInfo.Capture(ex).Throw();

                }

                catch (Exception ex)

                {

                    Thread.Exception(ex);


                    if (DoLog)

                        Log.Exception(ex);


                    return;

                }

#endif

            }

            finally

            {

                Thread.Stop();

                Profiler.Stop();


                double TotalSeconds = Profiler.ElapsedSeconds;


                if (TotalSeconds >= 1.0)

                {

                    string Uml = Profiler.ExportPlantUml(TimeUnit.MilliSeconds);


                    Log.Debug("Long local login check.\r\n\r\n```uml\r\n" + Uml + "\r\n```");

                }

            }

        }


        private static bool SameEndpoint(string EP1, string EP2)

        {

            if (string.Compare(EP1, EP2, true) == 0)

                return true;


            switch (Environment.OSVersion.Platform)

            {

                case PlatformID.Unix:

                case PlatformID.MacOSX:

                    int i = EP1.LastIndexOf('.');

                    if (i < 0)

                        break;


                    if (!int.TryParse(EP1[(i + 1)..], out int Port1))

                        break;


                    if (!IPAddress.TryParse(EP1[..i], out IPAddress Addr1))

                        break;


                    i = EP2.LastIndexOf(':');

                    if (i < 0)

                        break;


                    if (!int.TryParse(EP2[(i + 1)..], out int Port2) || Port1 != Port2)

                        break;


                    if (!IPAddress.TryParse(EP2[..i], out IPAddress Addr2))

                        break;


                    string s1 = Addr1.ToString();

                    string s2 = Addr2.ToString();


                    if (string.Compare(s1, s2, true) == 0)

                        return true;


                    break;

            }


            return false;

        }


        private static readonly IPAddress ipv6Local = IPAddress.Parse("[::1]");

        private static readonly IPAddress ipv4Local = IPAddress.Parse("127.0.0.1");


        private static bool IsLocalCall(IPAddress Address, HttpRequest Request, bool DoLog)

        {

            if (Address.Equals(ipv4Local) || Address.Equals(ipv6Local))

                return true;


            string s = Request.Header.Host?.Value.RemovePortNumber() ?? string.Empty;


            if (string.Compare(s, "localhost", true) != 0)

            {

                if (!IPAddress.TryParse(s, out IPAddress IP) || !Address.Equals(IP))

                {

                    if (DoLog)

                        Log.Debug("Host is not localhost or an IP Address: " + (Request.Header.Host?.Value ?? string.Empty));


                    return false;

                }

            }


            try

            {

                foreach (NetworkInterface Interface in NetworkInterface.GetAllNetworkInterfaces())

                {

                    if (Interface.OperationalStatus != OperationalStatus.Up)

                        continue;


                    IPInterfaceProperties Properties = Interface.GetIPProperties();


                    foreach (UnicastIPAddressInformation UnicastAddress in Properties.UnicastAddresses)

                    {

                        if (Address.Equals(UnicastAddress.Address))

                            return true;

                    }

                }


                if (DoLog)

                    Log.Debug("IP Address not found among network adapters: " + Address.ToString());


                if (InternetGatewayRegistrator.IsPublicAddress(Address))

                {

                    if (DoLog)

                        Log.Debug("IP Address public: " + Address.ToString());


                    return false;

                }


                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) &&

                    string.IsNullOrEmpty(XmppConfiguration.Instance?.Host) &&

                    Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER") == "true")

                {

                    return true;

                }


                return false;

            }

            catch (Exception ex)

            {

                if (DoLog)

                    Log.Debug(ex.Message);


                return false;

            }

        }


#if !MONO

        [DllImport("kernel32.dll")]

        static extern int WTSGetActiveConsoleSessionId();

#endif


        public static RequiredPrivileges LoggedIn(string[] Privileges)

        {

            return LoggedIn(SessionAuthentication.DefaultUserVariable, Privileges);

        }


        public static RequiredPrivileges LoggedIn(string UserVariable, string[] Privileges)

        {

            return new RequiredPrivileges(

                new HttpAuthenticationScheme[]

                {

                    new SessionAuthentication(UserVariable, webServer)

                },

                Privileges);

        }


        public static RequiredPrivileges LoggedIn(IAuthorization<HttpRequest> Authorization)

        {

            return LoggedIn(SessionAuthentication.DefaultUserVariable, Authorization);

        }


        public static RequiredPrivileges LoggedIn(string UserVariable, IAuthorization<HttpRequest> Authorization)

        {

            return new RequiredPrivileges(

                new HttpAuthenticationScheme[]

                {

                    new SessionAuthentication(UserVariable, webServer)

                },

                Authorization);

        }


        public static LoginAuditor LoginAuditor => loginAuditor;


        public static IUser AssertUserAuthenticated(HttpRequest Request, string Privilege)

        {

            return AssertUserAuthenticated(Request.Session, Privilege);

        }


        public static IUser AssertUserAuthenticated(Variables Session, string Privilege)

        {

            IUser User = null;


            if (Session is null ||

                !Session.TryGetVariable("User", out Variable v) ||

                ((User = v.ValueObject as IUser) is null) ||

                !User.HasPrivilege(Privilege))

            {

                throw ForbiddenException.AccessDenied(string.Empty, User?.UserName, Privilege);

            }


            return User;

        }


        public static IUser AssertUserAuthenticated(HttpRequest Request, string[] Privileges)

        {

            return AssertUserAuthenticated(Request.Session, Privileges);

        }


        public static IUser AssertUserAuthenticated(Variables Session, string[] Privileges)

        {

            if (Session is null ||

                !Session.TryGetVariable("User", out Variable v) ||

                (!(v.ValueObject is IUser User)))

            {

                throw ForbiddenException.AccessDenied(string.Empty, string.Empty, string.Empty);

            }


            foreach (string Privilege in Privileges)

            {

                if (!User.HasPrivilege(Privilege))

                    throw ForbiddenException.AccessDenied(string.Empty, User.UserName, Privilege);

            }


            return User;

        }


        private static Task SensorServer_AssignAuthority(object Sender, AuthorityEventArgs e)

        {

            if (e.Authority is null)

            {

                if (!string.IsNullOrEmpty(provisioningClient?.OwnerJid) &&

                    provisioningClient.OwnerJid == e.BareJid)

                {

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

                }

                else

                {

                    RosterItem Item = xmppClient?.GetRosterItem(e.BareJid);


                    if (!(Item is null) &&

                        (Item.State == SubscriptionState.Both ||

                        Item.State == SubscriptionState.From))

                    {

                        e.Authority = new ViewOnlyAuthority(e.BareJid, MeteringTopology.SourceID);

                    }

                }

            }


            return Task.CompletedTask;

        }


        #endregion


        #region Thing Registry


        private static Task ThingRegistryClient_Claimed(object Sender, ClaimedEventArgs e)

        {

            if (e.Node.IsEmpty)

            {

                ownerJid = e.JID;

                Log.Informational("Gateway has been claimed.", ownerJid, new KeyValuePair<string, object>("Public", e.IsPublic));

            }


            return Task.CompletedTask;

        }


        private static Task ThingRegistryClient_Disowned(object Sender, Networking.XMPP.Provisioning.Events.NodeEventArgs e)

        {

            if (e.Node.IsEmpty)

            {

                Log.Informational("Gateway has been disowned.", ownerJid);

                ownerJid = string.Empty;

                Task.Run(Register);

            }


            return Task.CompletedTask;

        }


        private static Task ThingRegistryClient_Removed(object Sender, Networking.XMPP.Provisioning.Events.NodeEventArgs e)

        {

            if (e.Node.IsEmpty)

                Log.Informational("Gateway has been removed from the public registry.", ownerJid);


            return Task.CompletedTask;

        }


        private static async Task Register()

        {

            string Key = Guid.NewGuid().ToString().Replace("-", string.Empty);


            // For info on tag names, see: http://xmpp.org/extensions/xep-0347.html#tags

            MetaDataTag[] MetaData = new MetaDataTag[]

            {

                new MetaDataStringTag("KEY", Key),

                new MetaDataStringTag("CLASS", "Gateway"),

                new MetaDataStringTag("MAN", "waher.se"),

                new MetaDataStringTag("MODEL", "Waher.IoTGateway"),

                new MetaDataStringTag("PURL", "https://github.com/PeterWaher/IoTGateway#iotgateway"),

                new MetaDataNumericTag("V", 1.0)

            };


            if (!(GetMetaData is null))

                MetaData = await GetMetaData(MetaData);


            await thingRegistryClient.RegisterThing(MetaData, async (sender2, e2) =>

            {

                if (e2.Ok)

                {

                    registered = true;


                    if (e2.IsClaimed)

                        ownerJid = e2.OwnerJid;

                    else

                        ownerJid = string.Empty;


                    RegistrationEventHandler h = RegistrationSuccessful;

                    if (!(h is null))

                        await h(MetaData, e2);

                }

            }, null);

        }


        public static event GetRegistryMetaDataEventHandler GetMetaData = null;


        public static event RegistrationEventHandler RegistrationSuccessful = null;


        public static XmppClient XmppClient => xmppClient ?? Types.TryGetModuleParameter<XmppClient>("XMPP");


        public static ThingRegistryClient ThingRegistryClient => thingRegistryClient ?? Types.TryGetModuleParameter<ThingRegistryClient>("Registry");


        public static ProvisioningClient ProvisioningClient => provisioningClient ?? Types.TryGetModuleParameter<ProvisioningClient>("Provisioning");


        public static ConcentratorServer ConcentratorServer => concentratorServer ?? Types.TryGetModuleParameter<ConcentratorServer>("Concentrator");


        public static AvatarClient AvatarClient => avatarClient ?? Types.TryGetModuleParameter<AvatarClient>("Avatar");


        public static SensorClient SensorClient => sensorClient;


        public static ControlClient ControlClient => controlClient;


        public static ConcentratorClient ConcentratorClient => concentratorClient;


        public static SynchronizationClient SynchronizationClient => synchronizationClient;


        public static PepClient PepClient => pepClient;


        public static MultiUserChatClient MucClient => mucClient;


        public static PubSubClient PubSubClient => pepClient.PubSubClient;


        public static SoftwareUpdateClient SoftwareUpdateClient => softwareUpdateClient;


        public static GeoClient GeoClient => geoClient;


        public static MailClient MailClient => mailClient;


        public static OAuth2Environment OAuthEnvironment => oauthEnvironment;


        public static HttpServer HttpServer => webServer ?? Types.TryGetModuleParameter<HttpServer>("HTTP");


        public static HttpxServer HttpxServer => httpxServer ?? Types.TryGetModuleParameter<HttpxServer>("HTTPXS");


        public static HttpxProxy HttpxProxy => httpxProxy ?? Types.TryGetModuleParameter<HttpxProxy>("HTTPX");


        public static Socks5Proxy Socks5Proxy => socksProxy ?? Types.TryGetModuleParameter<Socks5Proxy>("SOCKS5");


        public static CoapEndpoint CoapEndpoint => coapEndpoint ?? Types.TryGetModuleParameter<CoapEndpoint>("CoAP");


        // TODO: Teman: http://mmistakes.github.io/skinny-bones-jekyll/, http://jekyllrb.com/


        #endregion


        #region Service Commands


        public static async Task<bool> ExecuteServiceCommand(int CommandNr)

        {

            EventHandlerAsync h;


            lock (serviceCommandByNr)

            {

                if (!serviceCommandByNr.TryGetValue(CommandNr, out h))

                    h = null;

            }


            if (h is null)

            {

                Log.Warning("Service command lacking command handler invoked.", CommandNr.ToString());

                return false;

            }

            else

            {

                try

                {

                    await h(null, EventArgs.Empty);

                }

                catch (Exception ex)

                {

                    Log.Exception(ex);

                }


                return true;

            }

        }


        public static int RegisterServiceCommand(EventHandlerAsync Callback)

        {

            int i;


            lock (serviceCommandByNr)

            {

                if (serviceCommandNrByCallback.TryGetValue(Callback, out i))

                    return i;


                i = nextServiceCommandNr++;


                serviceCommandNrByCallback[Callback] = i;

                serviceCommandByNr[i] = Callback;

            }


            return i;

        }


        public static bool UnregisterServiceCommand(EventHandlerAsync Callback)

        {

            lock (serviceCommandByNr)

            {

                if (serviceCommandNrByCallback.TryGetValue(Callback, out int i))

                {

                    serviceCommandByNr.Remove(i);

                    serviceCommandNrByCallback.Remove(Callback);


                    return true;

                }

            }


            return false;

        }


        public static int BeforeUninstallCommandNr => beforeUninstallCommandNr;


        public static event EventHandlerAsync OnBeforeUninstall = null;


        private static Task BeforeUninstall(object Sender, EventArgs e)

        {

            return OnBeforeUninstall.Raise(Sender, e, false);

        }


        #endregion


        #region Scheduling


        public static DateTime ScheduleEvent(Action<object> Callback, DateTime When, object State)

        {

            return scheduler?.Add(When, Callback, State) ?? DateTime.MinValue;

        }


        public static DateTime ScheduleEvent(Func<object, Task> Callback, DateTime When, object State)

        {

            return scheduler?.Add(When, Callback, State) ?? DateTime.MinValue;

        }


        public static bool CancelScheduledEvent(DateTime When)

        {

            return scheduler?.Remove(When) ?? false;

        }


        #endregion


        #region Random number generation


        public static double NextDouble()

        {

            byte[] b = new byte[8];


            lock (rnd)

            {

                rnd.GetBytes(b);

            }


            double d = BitConverter.ToUInt64(b, 0);

            d /= ulong.MaxValue;


            return d;

        }


        public static int NextInteger(int Max)

        {

            if (Max < 0)

                throw new ArgumentOutOfRangeException("Must be non-negative.", nameof(Max));


            if (Max == 0)

                return 0;


            int Result;


            do

            {

                Result = (int)(NextDouble() * Max);

            }

            while (Result >= Max);


            return Result;

        }


        public static byte[] NextBytes(int NrBytes)

        {

            if (NrBytes < 0)

                throw new ArgumentException("Number of bytes must be non-negative.", nameof(NrBytes));


            byte[] Result = new byte[NrBytes];


            lock (rnd)

            {

                rnd.GetBytes(Result);

            }


            return Result;

        }


        public static void NextBytes(byte[] Buffer)

        {

            NextBytes(Buffer, 0, Buffer.Length);

        }


        public static void NextBytes(byte[] Buffer, int Offset, int Count)

        {

            lock (rnd)

            {

                rnd.GetBytes(Buffer, Offset, Count);

            }

        }


        #endregion


        #region Momentary values


        public static Task NewMomentaryValues(params Field[] Values)

        {

            return concentratorServer?.SensorServer?.NewMomentaryValues(Values) ?? Task.CompletedTask;

        }


        public static Task NewMomentaryValues(IThingReference Reference, params Field[] Values)

        {

            return concentratorServer?.SensorServer?.NewMomentaryValues(Reference, Values) ?? Task.CompletedTask;

        }


        public static Task NewMomentaryValues(IEnumerable<Field> Values)

        {

            return concentratorServer?.SensorServer?.NewMomentaryValues(Values) ?? Task.CompletedTask;

        }


        public static Task NewMomentaryValues(IThingReference Reference, IEnumerable<Field> Values)

        {

            return concentratorServer?.SensorServer?.NewMomentaryValues(Reference, Values) ?? Task.CompletedTask;

        }


        #endregion


        #region Personal Eventing Protocol


        public static Task PublishPersonalEvent(IPersonalEvent PersonalEvent)

        {

            if (pepClient is null)

                throw new Exception("No PEP client available.");


            return pepClient.Publish(PersonalEvent, null, null);

        }


        public static void RegisterHandler(Type PersonalEventType, EventHandlerAsync<PersonalEventNotificationEventArgs> Handler)

        {

            pepClient?.RegisterHandler(PersonalEventType, Handler);

        }


        public static bool UnregisterHandler(Type PersonalEventType, EventHandlerAsync<PersonalEventNotificationEventArgs> Handler)

        {

            if (pepClient is null)

                return false;

            else

                return pepClient.UnregisterHandler(PersonalEventType, Handler);

        }


        public static event EventHandlerAsync<ItemNotificationEventArgs> PubSubItemNotification

        {

            add => pepClient.NonPepItemNotification += value;

            remove => pepClient.NonPepItemNotification -= value;

        }


        #endregion


        #region Backups


        private static async Task<bool> CheckBackup()

        {

            bool Result = false;


            try

            {

                if (await Export.GetAutomaticBackupsAsync())

                {

                    DateTime Now = DateTime.Now;

                    TimeSpan Timepoint = await Export.GetBackupTimeAsync();

                    DateTime EstimatedTime = Now.Date + Timepoint;

                    DateTime LastBackup = await Export.GetLastBackupAsync();


                    if ((Timepoint.Hours == Now.Hour && Timepoint.Minutes == Now.Minute) ||

                        (lastBackupTimeCheck.HasValue && lastBackupTimeCheck.Value < EstimatedTime && Now >= EstimatedTime) ||

                        LastBackup.AddDays(1) < EstimatedTime)

                    {

                        lastBackupTimeCheck = Now;

                        await DoBackup();


                        Result = true;

                    }

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }


            return Result;

        }


        public static async Task DoBackup()

        {

            DateTime Now = DateTime.Now;


            await Export.SetLastBackupAsync(Now);


            StartExport.ExportInfo ExportInfo = await StartExport.GetExporter("Encrypted", false, Array.Empty<string>());


            ExportFormat.UpdateClientsFileUpdated(ExportInfo.LocalBackupFileName, -1, Now);


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


            foreach (Export.FolderCategory FolderCategory in Export.GetRegisteredFolders())

                Folders.AddRange(FolderCategory.Folders);


            await StartExport.DoExport(ExportInfo, true, false, true, Folders.ToArray());


            long KeepDays = await Export.GetKeepDaysAsync();

            long KeepMonths = await Export.GetKeepMonthsAsync();

            long KeepYears = await Export.GetKeepYearsAsync();

            string ExportFolder = await Export.GetFullExportFolderAsync();

            string KeyFolder = await Export.GetFullKeyExportFolderAsync();


            DeleteOldFiles(ExportFolder, KeepDays, KeepMonths, KeepYears, Now, true);

            if (ExportFolder != KeyFolder)

                DeleteOldFiles(KeyFolder, KeepDays, KeepMonths, KeepYears, Now, true);


            DeleteOldFiles(Path.GetTempPath(), 7, 0, 0, Now, false);


            await OnAfterBackup.Raise(typeof(Gateway), EventArgs.Empty);

        }


        private static DateTime? lastBackupTimeCheck = null;


        public static event EventHandlerAsync OnAfterBackup = null;


        public static void DeleteOldFiles(string Path, long KeepDays)

        {

            DeleteOldFiles(Path, KeepDays, 0, 0, DateTime.Now, false);

        }


        private static void DeleteOldFiles(string Path, long KeepDays, long KeepMonths,

            long KeepYears, DateTime Now, bool LogIndividualFileEvents)

        {

            int Count = 0;


            try

            {

                if (!Directory.Exists(Path))

                    return;


                string[] Files = Directory.GetFiles(Path, "*.*", SearchOption.AllDirectories);

                DateTime CreationTime;


                foreach (string FileName in Files)

                {

                    try

                    {

                        CreationTime = File.GetCreationTime(FileName);


                        if (KeepMonths > 0 && CreationTime.Day == 1)

                        {

                            if (KeepYears > 0 && CreationTime.Month == 1)    // Yearly

                            {

                                if (Now.Year - CreationTime.Year <= KeepYears)

                                    continue;

                            }

                            else    // Monthly

                            {

                                if ((Now.Year * 12 + Now.Month - (CreationTime.Year * 12 + Now.Month)) <= KeepMonths)

                                    continue;

                            }

                        }

                        else    // Daily

                        {

                            if ((Now.Date - CreationTime.Date).TotalDays <= KeepDays)

                                continue;

                        }


                        File.Delete(FileName);

                        Count++;


                        if (LogIndividualFileEvents)

                            Log.Informational("File deleted.", FileName);


                        ExportFormat.UpdateClientsFileDeleted(System.IO.Path.GetFileName(FileName));

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex, FileName);

                    }

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

            finally

            {

                if (Count > 0 && !LogIndividualFileEvents)

                {

                    if (Count == 1)

                        Log.Informational("1 file deleted.", Path);

                    else

                        Log.Informational(Count.ToString() + " files deleted.", Path);

                }

            }

        }


        private static Task Database_CollectionRepaired(object Sender, CollectionRepairedEventArgs e)

        {

            StringBuilder Msg = new StringBuilder();


            Msg.Append("Collection repaired: ");

            Msg.AppendLine(e.Collection);


            if (!(e.Flagged is null))

            {

                foreach (FlagSource Source in e.Flagged)

                {

                    Msg.AppendLine();

                    Msg.Append("Reason: ");

                    Msg.Append(MarkdownDocument.Encode(Source.Reason));


                    if (Source.Count > 1)

                    {

                        Msg.Append(" (");

                        Msg.Append(Source.Count.ToString());

                        Msg.Append(" times)");

                    }


                    Msg.AppendLine();

                    Msg.AppendLine();

                    Msg.AppendLine("StackTrace:");

                    Msg.AppendLine();

                    Msg.AppendLine("```");

                    Msg.AppendLine(Source.StackTrace);

                    Msg.AppendLine("```");

                }

            }


            Log.Alert(Msg.ToString(), e.Collection);


            return Task.CompletedTask;

        }


        #endregion


        #region Notifications


        private static Task MailClient_MailReceived(object Sender, MailEventArgs e)

        {

            return MailReceived.Raise(Sender, e);

        }


        public static event EventHandlerAsync<MailEventArgs> MailReceived = null;


        public static Task SendNotification(Graph Graph)

        {

            return SendNotification(Content.Markdown.Functions.ToMarkdown.GraphToMarkdown(Graph));

        }


        public static Task SendNotification(PixelInformation Pixels)

        {

            return SendNotification(Content.Markdown.Functions.ToMarkdown.PixelsToMarkdown(Pixels));

        }


        public static Task SendNotification(string Markdown)

        {

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

        }


        public static Task SendNotification(string Markdown, string MessageId)

        {

            return SendNotification(Markdown, MessageId, false);

        }


        public static Task SendNotificationUpdate(string Markdown, string MessageId)

        {

            return SendNotification(Markdown, MessageId, true);

        }


        private static async Task SendNotification(string Markdown, string MessageId, bool Update)

        {

            try

            {

                CaseInsensitiveString[] Addresses = GetNotificationAddresses();

                (string Text, string Html) = await ConvertMarkdown(Markdown);


                foreach (CaseInsensitiveString AdminAddress in Addresses)

                {

                    try

                    {

                        await SendNotification(AdminAddress, Markdown, Text, Html, MessageId, Update);

                    }

                    catch (Exception ex)

                    {

                        Log.Exception(ex, AdminAddress);

                    }

                }


                Addresses = GetNotificationWebHooks();

                if (Addresses.Length > 0)

                {

                    Dictionary<string, object> Data = new Dictionary<string, object>()

                    {

                        { "Markdown", Markdown },

                        { "Text", Text },

                        { "Html", Html }

                    };


                    foreach (CaseInsensitiveString AdminUrl in Addresses)

                    {

                        try

                        {

                            ContentResponse Response = await InternetContent.PostAsync(new Uri(AdminUrl), Data, certificate);

                            if (Response.HasError)

                                Log.Error(Response.Error, AdminUrl);

                        }

                        catch (Exception ex)

                        {

                            Log.Exception(ex, AdminUrl);

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        private static Task<(string, string)> ConvertMarkdown(string Markdown)

        {

            return ConvertMarkdown(Markdown, true, true);

        }


        private static async Task<(string, string)> ConvertMarkdown(string Markdown, bool TextVersion, bool HtmlVersion)

        {

            if (TextVersion || HtmlVersion)

            {

                MarkdownSettings Settings = new MarkdownSettings()

                {

                    ParseMetaData = false

                };

                HtmlSettings HtmlSettings = new HtmlSettings()

                {

                    XmlEntitiesOnly = true

                };

                MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Markdown, Settings);

                string Text = TextVersion ? await Doc.GeneratePlainText() : null;

                string Html = HtmlVersion ? HtmlDocument.GetBody(await Doc.GenerateHTML(HtmlSettings)) : null;


                return (Text, Html);

            }

            else

                return (null, null);

        }


        public static CaseInsensitiveString[] GetNotificationAddresses()

        {

            return NotificationConfiguration.Instance?.Addresses ?? Array.Empty<CaseInsensitiveString>();

        }


        public static CaseInsensitiveString[] GetNotificationWebHooks()

        {

            return NotificationConfiguration.Instance?.Urls ?? Array.Empty<CaseInsensitiveString>();

        }


        private static async Task SendNotification(string To, string Markdown, string Text, string Html, string MessageId, bool Update)

        {

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

            {

                RosterItem Item = XmppClient.GetRosterItem(To);

                if (Item is null || (Item.State != SubscriptionState.To && Item.State != SubscriptionState.Both))

                {

                    await xmppClient.RequestPresenceSubscription(To);

                    ScheduleEvent(Resend, DateTime.Now.AddMinutes(15), new object[] { To, Markdown, Text, Html, MessageId, Update });

                }

                else

                    await SendChatMessage(MessageType.Chat, Markdown, Text, Html, To, MessageId, string.Empty, Update);

            }

            else

                ScheduleEvent(Resend, DateTime.Now.AddSeconds(30), new object[] { To, Markdown, Text, Html, MessageId, Update });

        }


        public static Task SendChatMessage(string Markdown, string To)

        {

            return SendChatMessage(Markdown, To, string.Empty);

        }


        public static Task SendChatMessage(string Markdown, string To, string MessageId)

        {

            return SendChatMessage(Markdown, To, MessageId, string.Empty);

        }


        public static async Task SendChatMessage(string Markdown, string To, string MessageId, string ThreadId)

        {

            (string Text, string Html) = await ConvertMarkdown(Markdown);

            await SendChatMessage(MessageType.Chat, Markdown, Text, Html, To, MessageId, ThreadId, false);

        }


        public static Task SendChatMessageUpdate(string Markdown, string To, string MessageId)

        {

            return SendChatMessageUpdate(Markdown, To, MessageId, string.Empty);

        }


        public static async Task SendChatMessageUpdate(string Markdown, string To, string MessageId, string ThreadId)

        {

            (string Text, string Html) = await ConvertMarkdown(Markdown);

            await SendChatMessage(MessageType.Chat, Markdown, Text, Html, To, MessageId, ThreadId, true);

        }


        public static Task SendGroupChatMessage(string Markdown, string To)

        {

            return SendGroupChatMessage(Markdown, To, string.Empty);

        }


        public static Task SendGroupChatMessage(string Markdown, string To, string MessageId)

        {

            return SendGroupChatMessage(Markdown, To, MessageId, string.Empty);

        }


        public static async Task SendGroupChatMessage(string Markdown, string To, string MessageId, string ThreadId)

        {

            (string Text, string Html) = await ConvertMarkdown(Markdown);

            await SendChatMessage(MessageType.GroupChat, Markdown, Text, Html, To, MessageId, ThreadId, false);

        }


        public static Task SendGroupChatMessageUpdate(string Markdown, string To, string MessageId)

        {

            return SendGroupChatMessageUpdate(Markdown, To, MessageId, string.Empty);

        }


        public static async Task SendGroupChatMessageUpdate(string Markdown, string To, string MessageId, string ThreadId)

        {

            (string Text, string Html) = await ConvertMarkdown(Markdown);

            await SendChatMessage(MessageType.GroupChat, Markdown, Text, Html, To, MessageId, ThreadId, true);

        }


        public static Task<string> GetMultiFormatChatMessageXml(string Markdown)

        {

            return GetMultiFormatChatMessageXml(Markdown, true, true);

        }


        public static async Task<string> GetMultiFormatChatMessageXml(string Markdown, bool TextVersion, bool HtmlVersion)

        {

            (string Text, string Html) = await ConvertMarkdown(Markdown, TextVersion, HtmlVersion);

            return GetMultiFormatChatMessageXml(Text, Html, Markdown);

        }


        public static string GetMultiFormatChatMessageXml(string Text, string Html, string Markdown)

        {

            StringBuilder Xml = new StringBuilder();

            AppendMultiFormatChatMessageXml(Xml, Text, Html, Markdown);

            return Xml.ToString();

        }


        public static void AppendMultiFormatChatMessageXml(StringBuilder Xml, string Text, string Html, string Markdown)

        {

            if (string.IsNullOrEmpty(Text))

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

            else

            {

                Xml.Append("<body>");


                if (Text.Contains("]]>"))

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

                else

                {

                    Xml.Append("<![CDATA[");

                    Xml.Append(Text);

                    Xml.Append("]]>");

                }


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

            }


            if (!string.IsNullOrEmpty(Markdown))

            {

                Xml.Append("<content xmlns=\"urn:xmpp:content\" type=\"text/markdown\">");


                if (Markdown.Contains("]]>"))

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

                else

                {

                    Xml.Append("<![CDATA[");

                    Xml.Append(Markdown);

                    Xml.Append("]]>");

                }


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

            }


            if (!string.IsNullOrEmpty(Html))

            {

                Xml.Append("<html xmlns='http://jabber.org/protocol/xhtml-im'>");

                Xml.Append("<body xmlns='http://www.w3.org/1999/xhtml'>");


                HtmlDocument Doc = new HtmlDocument("<root>" + Html + "</root>");

                IEnumerable<HtmlNode> Children = (Doc.Body ?? Doc.Root).Children;


                if (!(Children is null))

                {

                    foreach (HtmlNode N in Children)

                        N.Export(Xml);

                }


                Xml.Append("</body></html>");

            }

        }


        private static async Task SendChatMessage(MessageType Type, string Markdown, string Text, string Html, string To, string MessageId, string ThreadId, bool Update)

        {

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

            {

                StringBuilder Xml = new StringBuilder();


                AppendMultiFormatChatMessageXml(Xml, Text, Html, Markdown);


                if (Update && !string.IsNullOrEmpty(MessageId))

                {

                    Xml.Append("<replace id='");

                    Xml.Append(MessageId);

                    Xml.Append("' xmlns='urn:xmpp:message-correct:0'/>");


                    MessageId = string.Empty;

                }


                await xmppClient.SendMessage(QoSLevel.Unacknowledged, Type, MessageId, To, Xml.ToString(), string.Empty,

                    string.Empty, string.Empty, ThreadId, string.Empty, null, null);

            }

        }


        public static string GetUrl(string LocalResource)

        {

            return GetUrl(LocalResource, HttpServer);

        }


        public static string GetUrl(string LocalResource, HttpServer Server)

        {

            if (LocalResource.StartsWith("http://") ||

                LocalResource.StartsWith("https://"))

            {

                return LocalResource;

            }


            StringBuilder sb = new StringBuilder();

            int DefaultPort;

            int[] Ports;


            sb.Append("http");


            if (certificate is null)

            {

                Ports = Server?.OpenHttpPorts ?? GetConfigPorts("HTTP");

                DefaultPort = 80;

            }

            else

            {

                sb.Append('s');

                Ports = Server?.OpenHttpsPorts ?? GetConfigPorts("HTTPS");

                DefaultPort = 443;

            }


            sb.Append("://");

            if (DomainConfiguration.Instance?.UseDomainName ?? false)

                sb.Append(domain);

            /*else if (httpxProxy?.ServerlessMessaging?.Network.State == PeerToPeerNetworkState.Ready)

                sb.Append(httpxProxy.ServerlessMessaging.Network.ExternalAddress.ToString());


                TODO: P2P & Serverless messaging: Recognize HTTP request, and redirect to local HTTP Server, and return response.

             */

            else

            {

                IPAddress IP4 = null;

                IPAddress IP6 = null;


                if (!(Server is null))

                {

                    foreach (IPAddress Addr in Server.LocalIpAddresses)

                    {

                        if (IPAddress.IsLoopback(Addr))

                            continue;


                        switch (Addr.AddressFamily)

                        {

                            case System.Net.Sockets.AddressFamily.InterNetwork:

                                IP4 ??= Addr;

                                break;


                            case System.Net.Sockets.AddressFamily.InterNetworkV6:

                                IP6 ??= Addr;

                                break;

                        }

                    }

                }


                if (!(IP4 is null))

                    sb.Append(IP4.ToString());

                else if (!(IP6 is null))

                    sb.Append(IP6.ToString());

                else

                    sb.Append(Dns.GetHostName());

            }


            if (Array.IndexOf(Ports, DefaultPort) < 0 && Ports.Length > 0)

            {

                sb.Append(":");

                sb.Append(Ports[0].ToString());

            }


            sb.Append(LocalResource);


            return sb.ToString();

        }


        public static bool IsDomain(string DomainOrHost, bool IncludeAlternativeDomains)

        {

            if (DomainConfiguration.Instance?.UseDomainName ?? false)

            {

                if (DomainOrHost == domain)

                    return true;


                if (IncludeAlternativeDomains && !(alternativeDomains is null))

                {

                    foreach (CaseInsensitiveString s in alternativeDomains)

                    {

                        if (s == DomainOrHost)

                            return true;

                    }

                }

            }

            else

            {

                if (DomainOrHost == "localhost" || string.IsNullOrEmpty(DomainOrHost))

                    return true;


                if (!(webServer is null))

                {

                    foreach (IPAddress Addr in webServer.LocalIpAddresses)

                    {

                        if (Addr.ToString() == DomainOrHost)

                            return true;

                    }

                }


                if (DomainOrHost == Dns.GetHostName())

                    return true;

            }


            return false;

        }


        private static void InternetContent_LocalDomainCheck(object sender, LocalDomainEventArgs e)

        {

            e.IsLocal = IsDomain(e.DomainOrHost, e.IncludeAlternativeDomains);

        }


        private static async Task Resend(object P)

        {

            object[] P2 = (object[])P;

            await SendNotification((string)P2[0], (string)P2[1], (string)P2[2], (string)P2[3], (string)P2[4], (bool)P2[5]);

        }


        #endregion


        #region Settings


        internal static async Task SimplifiedConfiguration()

        {

            foreach (SystemConfiguration Configuration in configurations)

            {

                if (!Configuration.Complete)

                {

                    bool Updated = await Configuration.EnvironmentConfiguration();


                    if (!Configuration.Complete && await Configuration.SimplifiedConfiguration())

                        Updated = true;


                    if (Updated)

                    {

                        await Configuration.MakeCompleted();

                        await Database.Update(Configuration);

                    }

                }

            }

        }


        public static WebMenuItem[] GetSettingsMenu(HttpRequest Request, string UserVariable)

        {

            List<WebMenuItem> Result = new List<WebMenuItem>();

            Variables Session = Request.Session;

            if (Session is null)

                return Array.Empty<WebMenuItem>();


            Language Language = ScriptExtensions.Constants.Language.GetLanguageAsync(Session).Result;


            if (Session is null ||

                !Session.TryGetVariable(UserVariable, out Variable v) ||

                !(v.ValueObject is IUser User))

            {

                Result.Add(new WebMenuItem("Login", "/Login.md"));

            }

            else

            {

                if (!(configurations is null))

                {

                    foreach (SystemConfiguration Configuration in configurations)

                    {

                        if (User.HasPrivilege("Settings." + Configuration.GetType().FullName))

                            Result.Add(new WebMenuItem(Configuration.Title(Language).Result, Configuration.Resource));

                    }

                }


                if (!Session.TryGetVariable(Login.AutoLoginVariableName, out v) ||

                    !(v.ValueObject is bool AutoLogin) || !AutoLogin)

                {

                    Result.Add(new WebMenuItem("Logout", "/Logout"));

                }

            }


            return Result.ToArray();

        }


        #endregion


        #region Smart Contracts


        public static ContractsClient ContractsClient

        {

            get => contractsClient ?? Types.TryGetModuleParameter<ContractsClient>("Contracts");

            set

            {

                if (contractsClient is null ||

                    contractsClient == value ||

                    (value is null && LegalIdentityConfiguration.Instance is null))

                {

                    contractsClient = value;

                }

                else

                    throw new InvalidOperationException("Not allowed to set a new Contracts Client class.");

            }

        }


        public static string LatestApprovedLegalIdentityId => LegalIdentityConfiguration.LatestApprovedLegalIdentityId;


        public static async Task RequestContractSignature(Contract Contract, string Role, string Purpose)

        {

            bool RoleFound = false;


            if (Contract is null)

                throw new ArgumentException("Contract cannot be null.", nameof(Contract));


            // TODO: Check contract server signature is valid.


            foreach (Networking.XMPP.Contracts.Role R in Contract.Roles)

            {

                if (R.Name == Role)

                {

                    RoleFound = true;

                    break;

                }

            }


            if (!RoleFound)

                throw new ArgumentException("Invalid role.", nameof(Role));


            if (string.IsNullOrEmpty(Purpose) || Purpose.IndexOfAny(CommonTypes.CRLF) >= 0)

                throw new ArgumentException("Invalid purpose.", nameof(Purpose));


            try

            {

                string Module = string.Empty;

                int Skip = 1;


                while (true)

                {

                    StackFrame Frame = new StackFrame(Skip);

                    MethodBase Method = Frame.GetMethod();

                    if (Method is null)

                        break;


                    Type Type = Method.DeclaringType;

                    Assembly Assembly = Type.Assembly;

                    Module = Assembly.GetName().Name;


                    if (Type != typeof(Gateway) && !Module.StartsWith("System."))

                        break;


                    Skip++;

                }


                string Markdown;

                ContractSignatureRequest Request = await Database.FindFirstIgnoreRest<ContractSignatureRequest>(new FilterAnd(

                    new FilterFieldEqualTo("ContractId", Contract.ContractId),

                    new FilterFieldEqualTo("Role", Role),

                    new FilterFieldEqualTo("Module", Module),

                    new FilterFieldEqualTo("Provider", Contract.Provider),

                    new FilterFieldEqualTo("Purpose", Purpose)));


                if (Request is null)

                {

                    Request = new ContractSignatureRequest()

                    {

                        Received = DateTime.Now,

                        Signed = null,

                        ContractId = Contract.ContractId,

                        Role = Role,

                        Module = Module,

                        Provider = Contract.Provider,

                        Purpose = Purpose

                    };


                    Request.SetContract(Contract);


                    await Database.Insert(Request);


                    Markdown = await Files.ReadAllTextAsync(Path.Combine(rootFolder, "SignatureRequest.md"));


                    int i = Markdown.IndexOf("~~~~~~");

                    int c = Markdown.Length;


                    if (i >= 0)

                    {

                        i += 6;

                        while (i < c && Markdown[i] == '~')

                            i++;


                        Markdown = Markdown[i..].TrimStart();

                    }


                    i = Markdown.IndexOf("~~~~~~");

                    if (i > 0)

                        Markdown = Markdown[..i].TrimEnd();


                    Variables Variables = HttpServer.CreateSessionVariables();

                    Variables["RequestId"] = Request.ObjectId;

                    Variables["Request"] = Request;


                    MarkdownSettings Settings = new MarkdownSettings(emoji1_24x24, false, Variables);

                    Markdown = await MarkdownDocument.Preprocess(Markdown, Settings);


                    StringBuilder sb = new StringBuilder(Markdown);


                    sb.AppendLine();

                    sb.Append("Link: [`");

                    sb.Append(Request.ContractId);

                    sb.Append("](");

                    sb.Append(GetUrl("/SignatureRequest.md?RequestId=" + Request.ObjectId));

                    sb.AppendLine(")");


                    Markdown = sb.ToString();

                }

                else

                {

                    Markdown = "**Reminder**: Smart Contract [" + Request.ContractId + "](" +

                        GetUrl("/SignatureRequest.md?RequestId=" + Request.ObjectId) + ") is waiting for your signature.";

                }


                await SendNotification(Markdown);

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

            }

        }


        public static Task<bool> PetitionLegalIdentity(string LegalId, string PetitionId, string Purpose,

            EventHandlerAsync<LegalIdentityPetitionResponseEventArgs> Callback, TimeSpan Timeout,

            HttpRequest Request)

        {

            return LegalIdentityConfiguration.Instance.PetitionLegalIdentity(LegalId, PetitionId, Purpose, Callback, Timeout, Request);

        }


        public static Task<bool> PetitionLegalIdentity(string LegalId, string PetitionId, string Purpose, string Password,

            EventHandlerAsync<LegalIdentityPetitionResponseEventArgs> Callback, TimeSpan Timeout)

        {

            return LegalIdentityConfiguration.Instance.PetitionLegalIdentity(LegalId, PetitionId, Purpose, Password, Callback, Timeout);

        }


        public static Task<bool> PetitionContract(string ContractId, string PetitionId, string Purpose,

            EventHandlerAsync<ContractPetitionResponseEventArgs> Callback, TimeSpan Timeout,

            HttpRequest Request)

        {

            return LegalIdentityConfiguration.Instance.PetitionContract(ContractId, PetitionId, Purpose, Callback, Timeout, Request);

        }


        public static Task<bool> PetitionContract(string ContractId, string PetitionId, string Purpose, string Password,

            EventHandlerAsync<ContractPetitionResponseEventArgs> Callback, TimeSpan Timeout)

        {

            return LegalIdentityConfiguration.Instance.PetitionContract(ContractId, PetitionId, Purpose, Password, Callback, Timeout);

        }


        #endregion


        #region Finding Files


        public static string[] FindFiles(Environment.SpecialFolder[] Folders, string Pattern, bool IncludeSubfolders, bool BreakOnFirst)

        {

            return FileSystem.FindFiles(Folders, Pattern, IncludeSubfolders, BreakOnFirst);

        }


        public static string[] FindFiles(string[] Folders, string Pattern, bool IncludeSubfolders, bool BreakOnFirst)

        {

            return FileSystem.FindFiles(Folders, Pattern, IncludeSubfolders, BreakOnFirst);

        }


        public static string[] FindFiles(string[] Folders, string Pattern, bool IncludeSubfolders, int MaxCount)

        {

            return FileSystem.FindFiles(Folders, Pattern, IncludeSubfolders, MaxCount);

        }


        public static string[] FindFiles(string[] Folders, string Pattern, int SubfolderDepth, int MaxCount)

        {

            return FileSystem.FindFiles(Folders, Pattern, SubfolderDepth, MaxCount);

        }


        public static string[] GetFolders(Environment.SpecialFolder[] Folders, params string[] AppendWith)

        {

            return FileSystem.GetFolders(Folders, AppendWith);

        }


        public static string FindLatestFile(Environment.SpecialFolder[] Folders, string Pattern, bool IncludeSubfolders)

        {

            return FileSystem.FindLatestFile(Folders, Pattern, IncludeSubfolders);

        }


        public static string FindLatestFile(string[] Folders, string Pattern, bool IncludeSubfolders)

        {

            return FileSystem.FindLatestFile(Folders, Pattern, IncludeSubfolders);

        }


        public static string FindLatestFile(string[] Folders, string Pattern, int SubfolderDepth)

        {

            return FileSystem.FindLatestFile(Folders, Pattern, SubfolderDepth);

        }


        #endregion


        #region Custom Errors


        private static readonly Dictionary<string, KeyValuePair<DateTime, MarkdownDocument>> defaultDocuments = new Dictionary<string, KeyValuePair<DateTime, MarkdownDocument>>();


        private static async Task WebServer_CustomError(object Sender, CustomErrorEventArgs e)

        {

            HttpFieldAccept Accept = e.Request?.Header?.Accept;

            if (Accept is null || Accept.Value == "*/*")

                return;


            if (Accept.IsAcceptable(HtmlCodec.DefaultContentType))

            {

                string Html = await GetCustomErrorHtml(e.Request, e.StatusCode.ToString() + ".md", e.ContentType, e.Content);


                if (!string.IsNullOrEmpty(Html))

                    e.SetContent("text/html; charset=utf-8", System.Text.Encoding.UTF8.GetBytes(Html));

            }

        }


        public static async Task<string> GetCustomErrorHtml(HttpRequest Request, string LocalFileName, string ContentType, byte[] Content)

        {

            bool IsText;

            bool IsMarkdown;

            bool IsEmpty;


            if (string.IsNullOrEmpty(ContentType))

            {

                IsText = IsMarkdown = false;

                IsEmpty = true;

            }

            else

            {

                IsText = ContentType.StartsWith(PlainTextCodec.DefaultContentType);

                IsMarkdown = ContentType.StartsWith(MarkdownCodec.ContentType);

                IsEmpty = false;

            }


            if (IsEmpty || IsText || IsMarkdown)

            {

                MarkdownDocument Doc;

                DateTime TP;


                lock (defaultDocuments)

                {

                    if (defaultDocuments.TryGetValue(LocalFileName, out KeyValuePair<DateTime, MarkdownDocument> P))

                    {

                        TP = P.Key;

                        Doc = P.Value;

                    }

                    else

                    {

                        TP = DateTime.MinValue;

                        Doc = null;

                    }

                }


                string FullFileName = Path.Combine(appDataFolder, "Default", LocalFileName);


                if (File.Exists(FullFileName))

                {

                    DateTime TP2 = File.GetLastWriteTimeUtc(FullFileName);

                    SessionVariables SessionVariables = null;

                    MarkdownSettings Settings;

                    MarkdownDocument Detail;

                    string Markdown;

                    bool SessionLocked = false;


                    try

                    {

                        if (Doc is null || TP2 > TP)

                        {

                            Markdown = await Files.ReadAllTextAsync(FullFileName);

                            Settings = new MarkdownSettings(emoji1_24x24, true)

                            {

                                RootFolder = rootFolder,

                                Variables = SessionVariables = Request.Session ?? HttpServer.CreateSessionVariables()

                            };


                            if (!SessionVariables.Locked)

                            {

                                await SessionVariables.LockAsync();

                                SessionLocked = true;


                                SessionVariables.CurrentRequest = Request;

                                SessionVariables.CurrentResponse = Request.Response;

                            }


                            Doc = await MarkdownDocument.CreateAsync(Markdown, Settings, RootFolder, string.Empty, string.Empty);


                            lock (defaultDocuments)

                            {

                                defaultDocuments[LocalFileName] = new KeyValuePair<DateTime, MarkdownDocument>(TP2, Doc);

                            }

                        }


                        if (IsEmpty || Content is null)

                            Detail = null;

                        else

                        {

                            InternetContent.ParseContentType(ref ContentType,

                                out System.Text.Encoding Encoding, out _);


                            Encoding ??= System.Text.Encoding.UTF8;


                            Markdown = Strings.GetString(Content, Encoding);

                            if (IsText)

                            {

                                MarkdownSettings Settings2 = new MarkdownSettings(null, false);

                                Detail = await MarkdownDocument.CreateAsync("```\r\n" + Markdown + "\r\n```", Settings2);

                            }

                            else

                                Detail = await MarkdownDocument.CreateAsync(Markdown, Doc.Settings);

                        }


                        if (!(Doc.Tag is MultiReadSingleWriteObject DocSynchObj))

                        {

                            DocSynchObj = new MultiReadSingleWriteObject(Doc);

                            Doc.Tag = DocSynchObj;

                        }


                        if (await DocSynchObj.TryBeginWrite(30000))

                        {

                            try

                            {

                                Doc.Detail = Detail;

                                return await Doc.GenerateHTML();

                            }

                            finally

                            {

                                await DocSynchObj.EndWrite();

                            }

                        }

                        else

                            throw new ServiceUnavailableException("Unable to generate custom HTML error document.");

                    }

                    finally

                    {

                        if (SessionLocked)

                        {

                            SessionVariables.CurrentRequest = null;

                            SessionVariables.CurrentResponse = null;


                            SessionVariables?.Release();

                        }

                    }

                }

                else

                {

                    if (!(Doc is null))

                    {

                        lock (defaultDocuments)

                        {

                            defaultDocuments.Remove(LocalFileName);

                        }

                    }

                }

            }


            return null;

        }


        #endregion


        #region Sniffers & Events


        public static string AddWebSniffer(string SnifferId, HttpRequest Request, ICommunicationLayer ComLayer, string UserVariable, params string[] Privileges)

        {

            return AddWebSniffer(SnifferId, Request, BinaryPresentationMethod.ByteCount, ComLayer, UserVariable, Privileges);

        }


        public static string AddWebSniffer(string SnifferId, HttpRequest Request, BinaryPresentationMethod BinaryPresentationMethod,

            ICommunicationLayer ComLayer, string UserVariable, params string[] Privileges)

        {

            return AddWebSniffer(SnifferId, Request, TimeSpan.FromHours(1), BinaryPresentationMethod, ComLayer, UserVariable, Privileges);

        }


        public static string AddWebSniffer(string SnifferId, HttpRequest Request, TimeSpan MaxLife,

            BinaryPresentationMethod BinaryPresentationMethod, ICommunicationLayer ComLayer, string UserVariable, params string[] Privileges)

        {

            string Resource = Request.Header.ResourcePart;

            int i = Resource.IndexOfAny(new char[] { '?', '#' });

            if (i > 0)

                Resource = Resource[..i];


            return AddWebSniffer(SnifferId, Resource, MaxLife, BinaryPresentationMethod, ComLayer, UserVariable, Privileges);

        }


        public static string AddWebSniffer(string SnifferId, string PageResource, TimeSpan MaxLife,

            BinaryPresentationMethod BinaryPresentationMethod, ICommunicationLayer ComLayer, string UserVariable, params string[] Privileges)

        {

            bool Found = false;


            foreach (ISniffer Sniffer in ComLayer)

            {

                if (Sniffer is WebSniffer WebSniffer && WebSniffer.SnifferId == SnifferId)

                {

                    Found = true;

                    break;

                }

            }


            if (!Found)

            {

                WebSniffer Sniffer = new WebSniffer(SnifferId, PageResource, MaxLife, BinaryPresentationMethod, ComLayer, UserVariable, Privileges);

                ComLayer.Add(Sniffer);

            }


            return "\r\n\r\n![Sniffer](/Sniffers/Sniffer.md)\r\n\r\n";

        }


        public static void AddWebEventSink(string SinkId, HttpRequest Request, string UserVariable, params string[] Privileges)

        {

            AddWebEventSink(SinkId, Request, TimeSpan.FromHours(1), UserVariable, Privileges);

        }


        public static void AddWebEventSink(string SinkId, HttpRequest Request, TimeSpan MaxLife, string UserVariable, params string[] Privileges)

        {

            string Resource = Request.Header.ResourcePart;

            int i = Resource.IndexOfAny(new char[] { '?', '#' });

            if (i > 0)

                Resource = Resource[..i];


            AddWebEventSink(SinkId, Resource, MaxLife, UserVariable, Privileges);

        }


        public static void AddWebEventSink(string SinkId, string PageResource, TimeSpan MaxLife, string UserVariable, params string[] Privileges)

        {

            bool Found = false;


            foreach (IEventSink Sink in Log.Sinks)

            {

                if (Sink is WebEventSink WebEventSink && WebEventSink.ObjectID == SinkId)

                {

                    Found = true;

                    break;

                }

            }


            if (!Found)

            {

                WebEventSink Sink = new WebEventSink(SinkId, PageResource, MaxLife, UserVariable, Privileges);

                Log.Register(Sink);

            }

        }


        #endregion


        #region Script Resources


        public static async Task<bool> AddScriptResource(string ResourceName, Expression Expression, string ReferenceFileName)

        {

            if (!await RemoveScriptResource(ResourceName, true))

                return false;


            webServer.Register(new HttpScriptResource(ResourceName, Expression, ReferenceFileName, true));


            await RuntimeSettings.SetAsync("Gateway.ScriptResource." + ResourceName, ReferenceFileName + " ||| " + Expression.Script);


            return true;

        }


        public static async Task<bool> AddScriptResource(string ResourceName, ScriptNode Expression, string ReferenceFileName)

        {

            if (!await RemoveScriptResource(ResourceName, true))

                return false;


            webServer.Register(new HttpScriptResource(ResourceName, Expression, ReferenceFileName, true));


            await RuntimeSettings.SetAsync("Gateway.ScriptResource." + ResourceName, ReferenceFileName + " ||| " + Expression.SubExpression);


            return true;

        }


        public static Task<bool> RemoveScriptResource(string ResourceName)

        {

            return RemoveScriptResource(ResourceName, false);

        }


        private static async Task<bool> RemoveScriptResource(string ResourceName, bool ConsiderNonexistantRemoved)

        {

            if (!webServer.TryGetResource(ref ResourceName, false, out HttpResource Resource, out string SubPath))

                return false;


            if (!string.IsNullOrEmpty(SubPath))

                return ConsiderNonexistantRemoved;


            if (!(Resource is HttpScriptResource))

                return false;


            webServer.Unregister(Resource);


            await RuntimeSettings.DeleteAsync("Gateway.ScriptResource." + ResourceName);


            return true;

        }


        private static async Task LoadScriptResources()

        {

            Dictionary<string, object> Settings = await RuntimeSettings.GetWhereKeyLikeAsync("Gateway.ScriptResource.*", "*");


            foreach (KeyValuePair<string, object> Setting in Settings)

            {

                if (!(Setting.Value is string Value))

                {

                    Log.Error("Invalid Runtime setting found and ignored.",

                        new KeyValuePair<string, object>("Key", Setting.Key),

                        new KeyValuePair<string, object>("Value", Setting.Value));


                    continue;

                }


                string ResourceName = Setting.Key[23..];

                string ReferenceFileName;

                int i;

                Expression Exp;


                i = Value.IndexOf(" ||| ");

                if (i < 0)

                    ReferenceFileName = string.Empty;

                else

                {

                    ReferenceFileName = Value[..i];

                    Value = Value[(i + 5)..];

                }


                try

                {

                    Exp = new Expression(Value);

                    webServer.Register(new HttpScriptResource(ResourceName, Exp, ReferenceFileName, true));

                }

                catch (Exception ex)

                {

                    Log.Error("Invalid Runtime setting script. Resource could not be added.",

                        new KeyValuePair<string, object>("Resource", ResourceName),

                        new KeyValuePair<string, object>("Error", ex.Message),

                        new KeyValuePair<string, object>("ReferenceFileName", ReferenceFileName),

                        new KeyValuePair<string, object>("Script", Value));


                    continue;

                }

            }

        }


        public static Task<int> ProcessNewServiceConfigurations()

        {

            return ProcessServiceConfigurations(true);

        }


        private static async Task<int> ProcessServiceConfigurations(bool OnlyIfChanged)

        {

            string[] ConfigurationFiles = Directory.GetFiles(appDataFolder, "*.config", SearchOption.TopDirectoryOnly);

            int NrExecuted = 0;


            foreach (string ConfigurationFile in ConfigurationFiles)

            {

                if (await ProcessServiceConfigurationFile(ConfigurationFile, OnlyIfChanged))

                    NrExecuted++;

            }


            return NrExecuted;

        }


        private const string ServiceConfigurationRoot = "ServiceConfiguration";

        private const string ServiceConfigurationNamespace = "http://waher.se/Schema/ServiceConfiguration.xsd";


        public static async Task<bool> ProcessServiceConfigurationFile(string ConfigurationFileName, bool OnlyIfChanged)

        {

            try

            {

                ConfigurationFileName = Path.GetFullPath(ConfigurationFileName);


                string DirectoryName = Path.GetDirectoryName(ConfigurationFileName);

                if (!DirectoryName.EndsWith(new string(Path.DirectorySeparatorChar, 1)))

                    DirectoryName += Path.DirectorySeparatorChar;


                if (string.Compare(DirectoryName, appDataFolder, true) != 0)

                    return false;


                if (!File.Exists(ConfigurationFileName))

                    return false;


                XmlDocument Doc = XML.LoadFromFile(ConfigurationFileName);


                if (Doc.DocumentElement.LocalName != ServiceConfigurationRoot || Doc.DocumentElement.NamespaceURI != ServiceConfigurationNamespace)

                    return false;


                XSL.Validate(Path.GetFileName(ConfigurationFileName), Doc, ServiceConfigurationRoot, ServiceConfigurationNamespace,

                    XSL.LoadSchema(typeof(Gateway).Namespace + ".Schema.ServiceConfiguration.xsd", typeof(Gateway).Assembly));


                bool ExecuteInitScript = await Content.Markdown.Functions.InitScriptFile.NeedsExecution(ConfigurationFileName);


                if (OnlyIfChanged && !ExecuteInitScript)

                    return false;


                Log.Notice("Applying Service Configurations.", ConfigurationFileName);


                webServer.UnregisterVanityResources(ConfigurationFileName);


                foreach (XmlNode N in Doc.DocumentElement.ChildNodes)

                {

                    if (!(N is XmlElement E))

                        continue;


                    switch (E.LocalName)

                    {

                        case "VanityResources":

                            foreach (XmlNode N2 in E.ChildNodes)

                            {

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

                                {

                                    string RegEx = XML.Attribute(E2, "regex");

                                    string Url = XML.Attribute(E2, "url");


                                    try

                                    {

                                        webServer.RegisterVanityResource(RegEx, Url, ConfigurationFileName);

                                    }

                                    catch (Exception ex)

                                    {

                                        Log.Error("Unable to register vanity resource: " + ex.Message,

                                            new KeyValuePair<string, object>("RegEx", RegEx),

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

                                    }

                                }

                            }

                            break;


                        case "StartupScript":           // Always execute

                            Expression Exp = new Expression(E.InnerText);

                            Variables v = HttpServer.CreateSessionVariables();

                            await Exp.EvaluateAsync(v);

                            break;


                        case "InitializationScript":    // Execute, only if changed

                            if (ExecuteInitScript)

                            {

                                Exp = new Expression(E.InnerText);

                                v = HttpServer.CreateSessionVariables();

                                await Exp.EvaluateAsync(v);

                            }

                            break;

                    }

                }


                return true;

            }

            catch (Exception ex)

            {

                Log.Exception(ex, ConfigurationFileName);

                return false;

            }

        }


        #endregion


        #region Profiling


        private static async Task WebServer_ConnectionProfiled(object Sender, ProfilingEventArgs e)

        {

            try

            {

                Profiler Profiler = e.Profiler;

                DateTime Now = DateTime.UtcNow;

                StringBuilder sb = new StringBuilder();


                sb.Append("Profiling ");

                sb.Append(Now.Year.ToString("D4"));

                sb.Append('-');

                sb.Append(Now.Month.ToString("D2"));

                sb.Append('-');

                sb.Append(Now.Day.ToString("D2"));

                sb.Append('T');

                sb.Append(Now.Hour.ToString("D2"));

                sb.Append('_');

                sb.Append(Now.Minute.ToString("D2"));

                sb.Append('_');

                sb.Append(Now.Second.ToString("D2"));

                sb.Append('_');

                sb.Append(Now.Millisecond.ToString("D3"));

                sb.Append(".uml");


                string Folder = Path.Combine(appDataFolder, "HTTP");


                if (!httpProfilingFolderChecked)

                {

                    if (!Directory.Exists(Folder))

                        Directory.CreateDirectory(Folder);


                    httpProfilingFolderChecked = true;

                }


                int NrNodes = 0;

                string BaseFileName = sb.ToString();

                string FileName = Path.Combine(Folder, BaseFileName);

                string Uml = Profiler.ExportPlantUml(TimeUnit.Seconds);

                string Uml2 = e.FlowControl?.ExportPlantUml(out NrNodes);


                await Files.WriteAllTextAsync(FileName, Uml);


                if (NrNodes > 0)

                {

                    FileName = Path.Combine(Folder, BaseFileName.Replace("Profiling ", "States "));

                    await Files.WriteAllTextAsync(FileName, Uml2);

                }


                StringBuilder Markdown = new StringBuilder();


                Markdown.AppendLine("```uml");

                Markdown.AppendLine(Uml.TrimEnd());

                Markdown.AppendLine("```");


                await SendNotification(Markdown.ToString());


                if (NrNodes > 0)

                {

                    Markdown.Clear();

                    Markdown.AppendLine("```uml");

                    Markdown.AppendLine(Uml.TrimEnd());

                    Markdown.AppendLine("```");


                    await SendNotification(Markdown.ToString());

                }

            }

            catch (Exception ex)

            {

                Log.Exception(ex);

                httpProfilingFolderChecked = false;

            }

        }


        private static bool httpProfilingFolderChecked = false;


        #endregion


        #region Local, Temporary, and short URLs


        public static string GetShortUrl(string Url, bool OneTimeUse)

        {

            return UrlShortener.GetShortUrl(Url, OneTimeUse);

        }


        public static bool TryGetLocalResourceFileName(string Resource, string Host, out string FileName)

        {

            if (!Uri.TryCreate(Resource, UriKind.RelativeOrAbsolute, out Uri ParsedResource))

            {

                FileName = null;

                return false;

            }


            if (ParsedResource.IsAbsoluteUri)

            {

                if (!IsDomain(ParsedResource.Host, true))

                {

                    FileName = null;

                    return false;

                }


                Resource = ParsedResource.LocalPath;

            }


            if (!string.IsNullOrEmpty(Host) &&

                HttpServer.TryGetFileName("/" + Host + Resource, out FileName))

            {

                return true;

            }


            return HttpServer.TryGetFileName(Resource, out FileName);

        }


        #endregion


        #region Nonce values


        public static Task<bool> HasNonceBeenUsed(string Nonce)

        {

            return nonceValues?.ContainsKeyAsync(Nonce) ?? Task.FromResult(false);

        }


        public static Task RegisterNonceValue(string Nonce)

        {

            return nonceValues?.AddAsync(Nonce, true) ?? Task.CompletedTask;

        }


        #endregion


    }

}

Waher.Content.CommonTypes
Helps with parsing of commong data types.
Definition: CommonTypes.cs:15

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.ContentResponse
Contains information about a response to a content request.
Definition: ContentResponse.cs:11

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

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

Waher.Content.Emoji.Emoji1.Emoji1LocalFiles
Provides emojis from Emoji One (http://emojione.com/) stored as local files.
Definition: LocalEmojiFiles.cs:44

Waher.Content.Html.HtmlCodec
HTML encoder/decoder.
Definition: HtmlCodec.cs:15

Waher.Content.Html.HtmlCodec.DefaultContentType
const string DefaultContentType
Default Content-Type for HTML: text/html
Definition: HtmlCodec.cs:26

Waher.Content.Html.HtmlDocument
HTML document.
Definition: HtmlDocument.cs:15

Waher.Content.Html.HtmlDocument.Root
HtmlElement Root
Root element.
Definition: HtmlDocument.cs:73

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.HtmlNode
Base class for all HTML nodes.
Definition: HtmlNode.cs:11

Waher.Content.Html.HtmlNode.Export
abstract void Export(XmlWriter Output, Dictionary< string, string > Namespaces)
Exports the HTML document to XML.

Waher.Content.Images.ImageCodec
Image encoder/decoder.
Definition: ImageCodec.cs:14

Waher.Content.Images.ImageCodec.ContentTypeIcon
const string ContentTypeIcon
image/x-icon
Definition: ImageCodec.cs:40

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

Waher.Content.InternetContent.SetDefaultTimeout
static void SetDefaultTimeout(int Timeout, bool Lock)
Sets the default timeout of internet access methods, in milliseconds.
Definition: InternetContent.cs:148

Waher.Content.InternetContent.PostAsync
static Task< ContentResponse > PostAsync(Uri Uri, object Data, params KeyValuePair< string, string >[] Headers)
Posts to a resource, using a Uniform Resource Identifier (or Locator).
Definition: InternetContent.cs:1641

Waher.Content.InternetContent.ParseContentType
static bool ParseContentType(ref string ContentType, out Encoding Encoding, out KeyValuePair< string, string >[] Fields)
Parses a Content-Type, providing the base Content-Type, character encoding, if any,...
Definition: InternetContent.cs:689

Waher.Content.LocalDomainEventArgs
Local domain check event arguments.
Definition: LocalDomainEventArgs.cs:9

Waher.Content.LocalDomainEventArgs.IncludeAlternativeDomains
bool IncludeAlternativeDomains
If alternative domains are to be checked.
Definition: LocalDomainEventArgs.cs:51

Waher.Content.LocalDomainEventArgs.DomainOrHost
string DomainOrHost
Domain or host name.
Definition: LocalDomainEventArgs.cs:42

Waher.Content.Markdown.GraphViz.GraphViz
Class managing GraphViz integration into Markdown documents.
Definition: GraphViz.cs:61

Waher.Content.Markdown.GraphViz.GraphViz.Terminate
static async Task Terminate()
Terminates GraphViz processing.
Definition: GraphViz.cs:145

Waher.Content.Markdown.GraphViz.GraphViz.Init
static void Init(string ContentRootFolder)
Initializes the GraphViz-Markdown integration.
Definition: GraphViz.cs:91

Waher.Content.Markdown.Layout2D.XmlLayout
Class managing 2D XML Layout integration into Markdown documents.
Definition: XmlLayout.cs:44

Waher.Content.Markdown.Layout2D.XmlLayout.Init
static void Init(string ContentRootFolder)
Initializes the Layout2D-Markdown integration.
Definition: XmlLayout.cs:67

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

Waher.Content.Markdown.MarkdownCodec.IsRawEncodingAllowedLocked
static bool IsRawEncodingAllowedLocked
If the IsRawEncodingAllowed setting is locked.
Definition: MarkdownCodec.cs:41

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

Waher.Content.Markdown.MarkdownCodec.AllowRawEncoding
static void AllowRawEncoding(bool Allow, bool Lock)
If raw encoding of web script should be allowed.
Definition: MarkdownCodec.cs:24

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

Waher.Content.Markdown.MarkdownDocument.Settings
MarkdownSettings Settings
Markdown settings.
Definition: MarkdownDocument.cs:5998

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.Tag
object Tag
Property can be used to tag document with client-specific information.
Definition: MarkdownDocument.cs:6014

Waher.Content.Markdown.MarkdownDocument.Preprocess
static async Task< string > Preprocess(string Markdown, MarkdownSettings Settings, params Type[] TransparentExceptionTypes)
Preprocesses markdown text.
Definition: MarkdownDocument.cs:331

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.MarkdownSettings
Contains settings that the Markdown parser uses to customize its behavior.
Definition: MarkdownSettings.cs:22

Waher.Content.Markdown.MarkdownSettings.SetDefaultEmojiSource
static void SetDefaultEmojiSource(IEmojiSource EmojiSource, bool Lock)
Sets the default emoji source.
Definition: MarkdownSettings.cs:283

Waher.Content.Markdown.PlantUml.PlantUml
Class managing PlantUML integration into Markdown documents.
Definition: PlantUml.cs:56

Waher.Content.Markdown.PlantUml.PlantUml.Init
static void Init(string ContentRootFolder)
Initializes the PlantUML-Markdown integration.
Definition: PlantUml.cs:80

Waher.Content.Markdown.PlantUml.PlantUml.Terminate
static async Task Terminate()
Terminates PlantUML processing.
Definition: PlantUml.cs:131

Waher.Content.Markdown.Rendering.HtmlSettings
Contains settings that the HTML export uses to customize HTML output.
Definition: HtmlSettings.cs:7

Waher.Content.Markdown.Web.WebScript.WsCodec
Web Script encoder/decoder.
Definition: WsCodec.cs:15

Waher.Content.Markdown.Web.WebScript.WsCodec.IsRawEncodingAllowedLocked
static bool IsRawEncodingAllowedLocked
If the IsRawEncodingAllowed setting is locked.
Definition: WsCodec.cs:41

Waher.Content.Markdown.Web.WebScript.WsCodec.AllowRawEncoding
static void AllowRawEncoding(bool Allow, bool Lock)
If raw encoding of web script should be allowed.
Definition: WsCodec.cs:24

Waher.Content.Markdown.Web.WebScript.WsCodec.ContentType
const string ContentType
Markdown content type.
Definition: WsCodec.cs:53

Waher.Content.SystemFiles.FileSystem
Static class helping modules to find files installed on the system.
Definition: FileSystem.cs:12

Waher.Content.SystemFiles.FileSystem.GetFolders
static string[] GetFolders(Environment.SpecialFolder[] Folders, params string[] AppendWith)
Gets the physical locations of special folders.
Definition: FileSystem.cs:126

Waher.Content.SystemFiles.FileSystem.FindFiles
static string[] FindFiles(Environment.SpecialFolder[] Folders, string Pattern, bool IncludeSubfolders, bool BreakOnFirst)
Finds files in a set of folders, and optionally, their subfolders. This method only finds files in fo...
Definition: FileSystem.cs:22

Waher.Content.SystemFiles.FileSystem.FindLatestFile
static string FindLatestFile(Environment.SpecialFolder[] Folders, string Pattern, bool IncludeSubfolders)
Finds the latest file matching a search pattern, by searching in a set of folders,...
Definition: FileSystem.cs:179

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.AnnotateException
static XmlException AnnotateException(XmlException ex)
Creates a new XML Exception object, with reference to the source XML file, for information.
Definition: XML.cs:1762

Waher.Content.Xml.XML.ParseXml
static XmlDocument ParseXml(string Xml)
Parses an XML Document from its string representation.
Definition: XML.cs:713

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.Content.Zip.ObjectToZipConverter
Converts an object to a ZIP File.
Definition: ObjectToZipConverter.cs:14

Waher.Content.Zip.ObjectToZipConverter.ProtectContentType
static void ProtectContentType(string ContentType)
Protects a content type, so that it cannot be included in generated zip files by external parties thr...
Definition: ObjectToZipConverter.cs:22

Waher.Events.Event
Class representing an event.
Definition: Event.cs:11

Waher.Events.Event.Avoid
void Avoid(IEventSink EventSink)
If the event sink EventSink  should be avoided when logging the event.
Definition: Event.cs:190

Waher.Events.Event.Facility
string Facility
Facility can be either a facility in the network sense or in the system sense.
Definition: Event.cs:152

Waher.Events.Files.TextFileEventSink
Outputs sniffed data to a text file.
Definition: TextFileEventSink.cs:11

Waher.Events.Files.XmlFileEventSink
Outputs sniffed data to an XML file.
Definition: XmlFileEventSink.cs:14

Waher.Events.Filter.EventFilter
Filters incoming events and passes remaining events to a secondary event sink.
Definition: EventFilter.cs:11

Waher.Events.Filter.EventSinks
Sends logged events to a collection of event sinks.
Definition: EventSinks.cs:9

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.Sinks
static IEventSink[] Sinks
Registered sinks.
Definition: Log.cs:132

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.Critical
static void Critical(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs a critical event.
Definition: Log.cs:1027

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.Emergency
static void Emergency(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs an emergency event.
Definition: Log.cs:1447

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.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.Debug
static void Debug(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs a debug event.
Definition: Log.cs:228

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.Log.Event
static async void Event(Event Event)
Logs an event. It will be distributed to registered event sinks.
Definition: Log.cs:138

Waher.Events.LogObject.ObjectID
virtual string ObjectID
Object ID, used when logging events.
Definition: LogObject.cs:26

Waher.Events.MQTT.MqttEventSink
Event sink sending events to a topic on an MQTT server. Events are sent as XML fragments.
Definition: MqttEventSink.cs:24

Waher.Events.Persistence.PersistedEventLog
Creates an even sink that stores incoming (logged) events in the local object database,...
Definition: PersistedEventLog.cs:17

Waher.Events.Persistence.PersistedEventLog.Queue
override async Task Queue(Event Event)
Queues an event to be output.
Definition: PersistedEventLog.cs:274

Waher.Events.Pipe.PipeEventSink
Writes logged events to an operating system pipe, for inter-process communication.
Definition: PipeEventSink.cs:24

Waher.Events.Queue.EventQueue
Creates an even sink that queues incoming events in a local persisted queue, for processing by in ord...
Definition: EventQueue.cs:14

Waher.Events.Socket.SocketEventSink
Writes logged events to to a socket.
Definition: SocketEventSink.cs:23

Waher.Events.Syslog.SyslogEventSink
Event sink that sends events to a Syslog server using the Syslog protocol.
Definition: SyslogEventSink.cs:12

Waher.Events.WebHook.WebHookEventSink
Event sink sending events to a remote service using POST.
Definition: WebHookEventSink.cs:18

Waher.Events.XMPP.XmppEventSink
Event sink sending events to a destination over the XMPP network.
Definition: XmppEventSink.cs:20

Waher.Groups.GroupSource
Defines the Groups data source. This data source contains a tree structure of groups of nodes
Definition: GroupSource.cs:21

Waher.Groups.GroupSource.DeleteOldEvents
static async Task< int > DeleteOldEvents(TimeSpan MaxAge)
Deletes old data source events.
Definition: GroupSource.cs:290

Waher.IoTGateway.ClientEvents
The ClientEvents class allows applications to push information asynchronously to web clients connecte...
Definition: ClientEvents.cs:51

Waher.IoTGateway.ClientEvents.PushEvent
static Task< int > PushEvent(string[] TabIDs, string Type, object Data)
Puses an event to a set of Tabs, given their Tab IDs.
Definition: ClientEvents.cs:1397

Waher.IoTGateway.ClientEvents.GetTabIDs
static string[] GetTabIDs()
Gets all open Tab IDs.
Definition: ClientEvents.cs:1193

Waher.IoTGateway.ClientEventsWebSocket
Web-socket binding method for the ClientEvents class. It allows clients connect to the gateway using ...
Definition: ClientEventsWebSocket.cs:17

Waher.IoTGateway.Cssx.CssxDecoder
CSSX decoder.
Definition: CssxDecoder.cs:14

Waher.IoTGateway.Cssx.CssxDecoder.DefaultContentType
const string DefaultContentType
Default Content-Type for CSSX: text/x-cssx
Definition: CssxDecoder.cs:25

Waher.IoTGateway.Events.AlertNotifier
Event sink that forwards events as notification messages to administrators.
Definition: AlertNotifier.cs:15

Waher.IoTGateway.Exceptions.Analyze
Analyzes exceptions and extracts basic statistics.
Definition: Analyze.cs:14

Waher.IoTGateway.Exceptions.Analyze.Process
static void Process(string ExceptionFileName, string OutputFileName)
Analyzes exceptions and extracts basic statistics.
Definition: Analyze.cs:23

Waher.IoTGateway.Export.FolderCategory
Information about an exportable folder category
Definition: Export.cs:559

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.GetRegisteredFolders
static FolderCategory[] GetRegisteredFolders()
Gets registered exportable folders.
Definition: Export.cs:542

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

Waher.IoTGateway.Export.SetLastBackupAsync
static async Task SetLastBackupAsync(DateTime Value)
Set Timestamp of last backup.
Definition: Export.cs:505

Waher.IoTGateway.Export.GetKeepMonthsAsync
static async Task< long > GetKeepMonthsAsync()
For how many months the monthly backups are kept.
Definition: Export.cs:429

Waher.IoTGateway.Export.GetKeepYearsAsync
static async Task< long > GetKeepYearsAsync()
For how many years the yearly backups are kept.
Definition: Export.cs:455

Waher.IoTGateway.Export.GetLastBackupAsync
static async Task< DateTime > GetLastBackupAsync()
Get Timestamp of last backup.
Definition: Export.cs:494

Waher.IoTGateway.Export.GetKeepDaysAsync
static async Task< long > GetKeepDaysAsync()
For how many days backups are kept.
Definition: Export.cs:403

Waher.IoTGateway.Export.GetAutomaticBackupsAsync
static async Task< bool > GetAutomaticBackupsAsync()
If automatic backups are activated
Definition: Export.cs:377

Waher.IoTGateway.Export.GetBackupTimeAsync
static async Task< TimeSpan > GetBackupTimeAsync()
Time of day to start performing backups.
Definition: Export.cs:481

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

Waher.IoTGateway.Gateway.GetSettingsMenu
static WebMenuItem[] GetSettingsMenu(HttpRequest Request, string UserVariable)
Gets the settings menu.
Definition: Gateway.cs:5255

Waher.IoTGateway.Gateway.HttpxProxy
static HttpxProxy HttpxProxy
HTTPX Proxy resource
Definition: Gateway.cs:4128

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.CheckLocalLogin
static async Task CheckLocalLogin(HttpRequest Request)
Checks if a web request comes from the local host in the current session. If so, the user is automati...
Definition: Gateway.cs:3407

Waher.IoTGateway.Gateway.ProcessServiceConfigurationFile
static async Task< bool > ProcessServiceConfigurationFile(string ConfigurationFileName, bool OnlyIfChanged)
Processes a Service Configuration File. This method should be called for each service configuration f...
Definition: Gateway.cs:6114

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.NewMomentaryValues
static Task NewMomentaryValues(IEnumerable< Field > Values)
Reports newly measured values.
Definition: Gateway.cs:4400

Waher.IoTGateway.Gateway.RegisterHandler
static void RegisterHandler(Type PersonalEventType, EventHandlerAsync< PersonalEventNotificationEventArgs > Handler)
Registers an event handler of a specific type of personal events.
Definition: Gateway.cs:4436

Waher.IoTGateway.Gateway.FindFiles
static string[] FindFiles(string[] Folders, string Pattern, bool IncludeSubfolders, int MaxCount)
Finds files in a set of folders, and optionally, their subfolders. This method only finds files in fo...
Definition: Gateway.cs:5555

Waher.IoTGateway.Gateway.GetMultiFormatChatMessageXml
static string GetMultiFormatChatMessageXml(string Text, string Html, string Markdown)
Gets XML for a multi-formatted chat message.
Definition: Gateway.cs:4984

Waher.IoTGateway.Gateway.SafeDispose
static void SafeDispose(IDisposable Object)
Disposes an object, catching and logging any exceptions.
Definition: Gateway.cs:3045

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.AssertUserAuthenticated
static IUser AssertUserAuthenticated(HttpRequest Request, string Privilege)
Makes sure a request is being made from a session with a successful user login.
Definition: Gateway.cs:3868

Waher.IoTGateway.Gateway.LoggedIn
static RequiredPrivileges LoggedIn(string UserVariable, IAuthorization< HttpRequest > Authorization)
Authentication mechanism that makes sure the call is made from a session with a valid authenticated u...
Definition: Gateway.cs:3846

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

Waher.IoTGateway.Gateway.NextDouble
static double NextDouble()
Generates a new floating-point value between 0 and 1, using a cryptographic random number generator.
Definition: Gateway.cs:4288

Waher.IoTGateway.Gateway.AddWebSniffer
static string AddWebSniffer(string SnifferId, HttpRequest Request, ICommunicationLayer ComLayer, string UserVariable, params string[] Privileges)
Creates a web sniffer, and adds it to a sniffable object.
Definition: Gateway.cs:5812

Waher.IoTGateway.Gateway.WebApplicationFirewallLocalFileName
const string WebApplicationFirewallLocalFileName
WAF.xml
Definition: Gateway.cs:156

Waher.IoTGateway.Gateway.FindLatestFile
static string FindLatestFile(string[] Folders, string Pattern, int SubfolderDepth)
Finds the latest file matching a search pattern, by searching in a set of folders,...
Definition: Gateway.cs:5622

Waher.IoTGateway.Gateway.SendNotification
static Task SendNotification(PixelInformation Pixels)
Sends an image as a notification message to configured notification recipients.
Definition: Gateway.cs:4686

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

Waher.IoTGateway.Gateway.GetDatabaseProvider
static GetDatabaseProviderEventHandler GetDatabaseProvider
Event raised when the Gateway requires its database provider from the host.
Definition: Gateway.cs:2673

Waher.IoTGateway.Gateway.Socks5Proxy
static Socks5Proxy Socks5Proxy
SOCKS5 Proxy
Definition: Gateway.cs:4133

Waher.IoTGateway.Gateway.AddWebEventSink
static void AddWebEventSink(string SinkId, string PageResource, TimeSpan MaxLife, string UserVariable, params string[] Privileges)
Creates a web event sink, and registers it with Log.
Definition: Gateway.cs:5936

Waher.IoTGateway.Gateway.FirstChanceExceptions
static CommunicationLayer FirstChanceExceptions
Observable layer where first chance exceptions can be monitored.
Definition: Gateway.cs:2683

Waher.IoTGateway.Gateway.SendChatMessage
static Task SendChatMessage(string Markdown, string To, string MessageId)
Sends a chat message to a recipient.
Definition: Gateway.cs:4854

Waher.IoTGateway.Gateway.FindLatestFile
static string FindLatestFile(string[] Folders, string Pattern, bool IncludeSubfolders)
Finds the latest file matching a search pattern, by searching in a set of folders,...
Definition: Gateway.cs:5608

Waher.IoTGateway.Gateway.FindFiles
static string[] FindFiles(string[] Folders, string Pattern, int SubfolderDepth, int MaxCount)
Finds files in a set of folders, and optionally, their subfolders. This method only finds files in fo...
Definition: Gateway.cs:5569

Waher.IoTGateway.Gateway.SendNotification
static Task SendNotification(string Markdown, string MessageId)
Sends a notification message to configured notification recipients.
Definition: Gateway.cs:4705

Waher.IoTGateway.Gateway.SendChatMessageUpdate
static async Task SendChatMessageUpdate(string Markdown, string To, string MessageId, string ThreadId)
Sends a chat message update to a recipient.
Definition: Gateway.cs:4890

Waher.IoTGateway.Gateway.OnNewCertificate
static EventHandlerAsync< Events.CertificateEventArgs > OnNewCertificate
Event raised when a new server certificate has been generated.
Definition: Gateway.cs:2628

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

Waher.IoTGateway.Gateway.AddWebEventSink
static void AddWebEventSink(string SinkId, HttpRequest Request, TimeSpan MaxLife, string UserVariable, params string[] Privileges)
Creates a web event sink, and registers it with Log.
Definition: Gateway.cs:5916

Waher.IoTGateway.Gateway.HasNonceBeenUsed
static Task< bool > HasNonceBeenUsed(string Nonce)
Checks if a Nonce value has been used.
Definition: Gateway.cs:6342

Waher.IoTGateway.Gateway.SensorClient
static SensorClient SensorClient
XMPP Sensor Client.
Definition: Gateway.cs:4063

Waher.IoTGateway.Gateway.FindFiles
static string[] FindFiles(string[] Folders, string Pattern, bool IncludeSubfolders, bool BreakOnFirst)
Finds files in a set of folders, and optionally, their subfolders. This method only finds files in fo...
Definition: Gateway.cs:5541

Waher.IoTGateway.Gateway.Start
static Task< bool > Start(bool ConsoleOutput, bool LoopbackIntefaceAvailable)
Starts the gateway.
Definition: Gateway.cs:265

Waher.IoTGateway.Gateway.PetitionContract
static Task< bool > PetitionContract(string ContractId, string PetitionId, string Purpose, string Password, EventHandlerAsync< ContractPetitionResponseEventArgs > Callback, TimeSpan Timeout)
Petitions information about a smart contract from its owner.
Definition: Gateway.cs:5508

Waher.IoTGateway.Gateway.AssertUserAuthenticated
static IUser AssertUserAuthenticated(HttpRequest Request, string[] Privileges)
Makes sure a request is being made from a session with a successful user login.
Definition: Gateway.cs:3900

Waher.IoTGateway.Gateway.SendGroupChatMessageUpdate
static async Task SendGroupChatMessageUpdate(string Markdown, string To, string MessageId, string ThreadId)
Sends a group chat message update to a recipient.
Definition: Gateway.cs:4948

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.RuntimeFolder
static string RuntimeFolder
Runtime folder.
Definition: Gateway.cs:3137

Waher.IoTGateway.Gateway.ConfigFilePath
static string ConfigFilePath
Full path to Gateway.config file.
Definition: Gateway.cs:3181

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.GeoClient
static GeoClient GeoClient
XMPP Geo-spatial Publish/Subscribe Client, if such a compoent is available on the XMPP broker.
Definition: Gateway.cs:4103

Waher.IoTGateway.Gateway.Start
static Task< bool > Start(bool ConsoleOutput)
Starts the gateway.
Definition: Gateway.cs:254

Waher.IoTGateway.Gateway.Stop
static async Task Stop()
Stops the gateway.
Definition: Gateway.cs:2816

Waher.IoTGateway.Gateway.GetMultiFormatChatMessageXml
static async Task< string > GetMultiFormatChatMessageXml(string Markdown, bool TextVersion, bool HtmlVersion)
Gets XML for a multi-formatted chat message.
Definition: Gateway.cs:4971

Waher.IoTGateway.Gateway.SendChatMessage
static async Task SendChatMessage(string Markdown, string To, string MessageId, string ThreadId)
Sends a chat message to a recipient.
Definition: Gateway.cs:4866

Waher.IoTGateway.Gateway.AddWebSniffer
static string AddWebSniffer(string SnifferId, HttpRequest Request, TimeSpan MaxLife, BinaryPresentationMethod BinaryPresentationMethod, ICommunicationLayer ComLayer, string UserVariable, params string[] Privileges)
Creates a web sniffer, and adds it to a sniffable object.
Definition: Gateway.cs:5846

Waher.IoTGateway.Gateway.TryGetDefaultPage
static bool TryGetDefaultPage(HttpRequest Request, out string DefaultPage)
Tries to get the default page of a host.
Definition: Gateway.cs:3251

Waher.IoTGateway.Gateway.SynchronizationClient
static SynchronizationClient SynchronizationClient
XMPP Synchronization Client.
Definition: Gateway.cs:4078

Waher.IoTGateway.Gateway.PepClient
static PepClient PepClient
XMPP Personal Eventing Protocol (PEP) Client.
Definition: Gateway.cs:4083

Waher.IoTGateway.Gateway.NewMomentaryValues
static Task NewMomentaryValues(IThingReference Reference, IEnumerable< Field > Values)
Reports newly measured values.
Definition: Gateway.cs:4410

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.GatewayConfigNamespace
const string GatewayConfigNamespace
http://waher.se/Schema/GatewayConfiguration.xsd
Definition: Gateway.cs:166

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.GetProtocols
static string[] GetProtocols()
Gets the protocol names defined in the configuration file.
Definition: Gateway.cs:3215

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.AddWebEventSink
static void AddWebEventSink(string SinkId, HttpRequest Request, string UserVariable, params string[] Privileges)
Creates a web event sink, and registers it with Log.
Definition: Gateway.cs:5901

Waher.IoTGateway.Gateway.AddScriptResource
static async Task< bool > AddScriptResource(string ResourceName, ScriptNode Expression, string ReferenceFileName)
Adds a script resource to the web server hosted by the gateway.
Definition: Gateway.cs:5986

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.LoggedIn
static RequiredPrivileges LoggedIn(IAuthorization< HttpRequest > Authorization)
Authentication mechanism that makes sure the call is made from a session with a valid authenticated u...
Definition: Gateway.cs:3835

Waher.IoTGateway.Gateway.GetDataSources
static EventHandlerAsync< GetDataSourcesEventArgs > GetDataSources
Event raised when the Gateway requires a set of data sources to publish.
Definition: Gateway.cs:2678

Waher.IoTGateway.Gateway.AssertUserAuthenticated
static IUser AssertUserAuthenticated(Variables Session, string Privilege)
Makes sure a request is being made from a session with a successful user login.
Definition: Gateway.cs:3879

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

Waher.IoTGateway.Gateway.RequestContractSignature
static async Task RequestContractSignature(Contract Contract, string Role, string Purpose)
Requests the operator to sign a smart contract.
Definition: Gateway.cs:5326

Waher.IoTGateway.Gateway.NextBytes
static void NextBytes(byte[] Buffer)
Generates random bytes into an array.
Definition: Gateway.cs:4354

Waher.IoTGateway.Gateway.ContractsClient
static ContractsClient ContractsClient
XMPP Contracts Client, if such a compoent is available on the XMPP broker.
Definition: Gateway.cs:5299

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.LoggedIn
static RequiredPrivileges LoggedIn(string[] Privileges)
Authentication mechanism that makes sure the call is made from a session with a valid authenticated u...
Definition: Gateway.cs:3809

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.AddScriptResource
static async Task< bool > AddScriptResource(string ResourceName, Expression Expression, string ReferenceFileName)
Adds a script resource to the web server hosted by the gateway.
Definition: Gateway.cs:5967

Waher.IoTGateway.Gateway.GatewayConfigLocalName
const string GatewayConfigLocalName
GatewayConfiguration
Definition: Gateway.cs:161

Waher.IoTGateway.Gateway.SendGroupChatMessage
static Task SendGroupChatMessage(string Markdown, string To)
Sends a group chat message to a recipient.
Definition: Gateway.cs:4901

Waher.IoTGateway.Gateway.SendGroupChatMessage
static Task SendGroupChatMessage(string Markdown, string To, string MessageId)
Sends a group chat message to a recipient.
Definition: Gateway.cs:4912

Waher.IoTGateway.Gateway.CheckWAF
static async Task CheckWAF()
Checks the Web Application Firewall file and loads or reloads it if necessary.
Definition: Gateway.cs:1954

Waher.IoTGateway.Gateway.ComputeUserPasswordHash
static byte[] ComputeUserPasswordHash(string UserName, string Password)
Computes a hash digest based on a user name and a password, and the current domain.
Definition: Gateway.cs:2524

Waher.IoTGateway.Gateway.HttpxServer
static HttpxServer HttpxServer
HTTPX Server
Definition: Gateway.cs:4123

Waher.IoTGateway.Gateway.SendNotificationUpdate
static Task SendNotificationUpdate(string Markdown, string MessageId)
Sends a notification message to configured notification recipients.
Definition: Gateway.cs:4715

Waher.IoTGateway.Gateway.LoggedIn
static RequiredPrivileges LoggedIn(string UserVariable, string[] Privileges)
Authentication mechanism that makes sure the call is made from a session with a valid authenticated u...
Definition: Gateway.cs:3820

Waher.IoTGateway.Gateway.ThingRegistryClient
static ThingRegistryClient ThingRegistryClient
XMPP Thing Registry Client.
Definition: Gateway.cs:4043

Waher.IoTGateway.Gateway.PetitionLegalIdentity
static Task< bool > PetitionLegalIdentity(string LegalId, string PetitionId, string Purpose, EventHandlerAsync< LegalIdentityPetitionResponseEventArgs > Callback, TimeSpan Timeout, HttpRequest Request)
Petitions information about a legal identity from its owner.
Definition: Gateway.cs:5458

Waher.IoTGateway.Gateway.FindLatestFile
static string FindLatestFile(Environment.SpecialFolder[] Folders, string Pattern, bool IncludeSubfolders)
Finds the latest file matching a search pattern, by searching in a set of folders,...
Definition: Gateway.cs:5594

Waher.IoTGateway.Gateway.SendChatMessage
static Task SendChatMessage(string Markdown, string To)
Sends a chat message to a recipient.
Definition: Gateway.cs:4843

Waher.IoTGateway.Gateway.RemoveScriptResource
static Task< bool > RemoveScriptResource(string ResourceName)
Removes a script resource from the web server hosted by the gateway.
Definition: Gateway.cs:6003

Waher.IoTGateway.Gateway.TryGetDefaultPage
static bool TryGetDefaultPage(string Host, out string DefaultPage)
Tries to get the default page of a host.
Definition: Gateway.cs:3262

Waher.IoTGateway.Gateway.ConcentratorClient
static ConcentratorClient ConcentratorClient
XMPP Concentrator Client.
Definition: Gateway.cs:4073

Waher.IoTGateway.Gateway.FindFiles
static string[] FindFiles(Environment.SpecialFolder[] Folders, string Pattern, bool IncludeSubfolders, bool BreakOnFirst)
Finds files in a set of folders, and optionally, their subfolders. This method only finds files in fo...
Definition: Gateway.cs:5527

Waher.IoTGateway.Gateway.RegisterNonceValue
static Task RegisterNonceValue(string Nonce)
Registers a nonce value.
Definition: Gateway.cs:6351

Waher.IoTGateway.Gateway.SafeDispose
static async Task SafeDispose(IDisposableAsync Object)
Disposes an object, catching and logging any exceptions.
Definition: Gateway.cs:3064

Waher.IoTGateway.Gateway.UnregisterHandler
static bool UnregisterHandler(Type PersonalEventType, EventHandlerAsync< PersonalEventNotificationEventArgs > Handler)
Unregisters an event handler of a specific type of personal events.
Definition: Gateway.cs:4447

Waher.IoTGateway.Gateway.NextInteger
static int NextInteger(int Max)
Returns a non-negative random integer that is less than the specified maximum.
Definition: Gateway.cs:4311

Waher.IoTGateway.Gateway.SendChatMessageUpdate
static Task SendChatMessageUpdate(string Markdown, string To, string MessageId)
Sends a chat message update to a recipient.
Definition: Gateway.cs:4878

Waher.IoTGateway.Gateway.GetNotificationWebHooks
static CaseInsensitiveString[] GetNotificationWebHooks()
Returns configured notification webhooks.
Definition: Gateway.cs:4816

Waher.IoTGateway.Gateway.Start
static async Task< bool > Start(bool ConsoleOutput, bool LoopbackIntefaceAvailable, string InstanceName)
Starts the gateway.
Definition: Gateway.cs:277

Waher.IoTGateway.Gateway.StartTime
static DateTime StartTime
Timepoint of starting the gateway.
Definition: Gateway.cs:247

Waher.IoTGateway.Gateway.GetFolders
static string[] GetFolders(Environment.SpecialFolder[] Folders, params string[] AppendWith)
Gets the physical locations of special folders.
Definition: Gateway.cs:5580

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

Waher.IoTGateway.Gateway.NewMomentaryValues
static Task NewMomentaryValues(IThingReference Reference, params Field[] Values)
Reports newly measured values.
Definition: Gateway.cs:4391

Waher.IoTGateway.Gateway.AssertUserAuthenticated
static IUser AssertUserAuthenticated(Variables Session, string[] Privileges)
Makes sure a request is being made from a session with a successful user login.
Definition: Gateway.cs:3911

Waher.IoTGateway.Gateway.RegisterServiceCommand
static int RegisterServiceCommand(EventHandlerAsync Callback)
Registers an administrative service command.
Definition: Gateway.cs:4188

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

Waher.IoTGateway.Gateway.CoapEndpoint
static CoapEndpoint CoapEndpoint
CoAP Endpoint
Definition: Gateway.cs:4138

Waher.IoTGateway.Gateway.PetitionLegalIdentity
static Task< bool > PetitionLegalIdentity(string LegalId, string PetitionId, string Purpose, string Password, EventHandlerAsync< LegalIdentityPetitionResponseEventArgs > Callback, TimeSpan Timeout)
Petitions information about a legal identity from its owner.
Definition: Gateway.cs:5475

Waher.IoTGateway.Gateway.AppendMultiFormatChatMessageXml
static void AppendMultiFormatChatMessageXml(StringBuilder Xml, string Text, string Html, string Markdown)
Appends the XML for a multi-formatted chat message to a string being built.
Definition: Gateway.cs:4998

Waher.IoTGateway.Gateway.NextBytes
static void NextBytes(byte[] Buffer, int Offset, int Count)
Generates random bytes into an array.
Definition: Gateway.cs:4365

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

Waher.IoTGateway.Gateway.AddWebSniffer
static string AddWebSniffer(string SnifferId, string PageResource, TimeSpan MaxLife, BinaryPresentationMethod BinaryPresentationMethod, ICommunicationLayer ComLayer, string UserVariable, params string[] Privileges)
Creates a web sniffer, and adds it to a sniffable object.
Definition: Gateway.cs:5869

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

Waher.IoTGateway.Gateway.UnregisterServiceCommand
static bool UnregisterServiceCommand(EventHandlerAsync Callback)
Unregisters an administrative service command.
Definition: Gateway.cs:4211

Waher.IoTGateway.Gateway.GetUrl
static string GetUrl(string LocalResource, HttpServer Server)
Gets a URL for a resource.
Definition: Gateway.cs:5090

Waher.IoTGateway.Gateway.SendNotification
static Task SendNotification(string Markdown)
Sends a notification message to configured notification recipients.
Definition: Gateway.cs:4695

Waher.IoTGateway.Gateway.PetitionContract
static Task< bool > PetitionContract(string ContractId, string PetitionId, string Purpose, EventHandlerAsync< ContractPetitionResponseEventArgs > Callback, TimeSpan Timeout, HttpRequest Request)
Petitions information about a smart contract from its owner.
Definition: Gateway.cs:5491

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

Waher.IoTGateway.Gateway.SendGroupChatMessageUpdate
static Task SendGroupChatMessageUpdate(string Markdown, string To, string MessageId)
Sends a group chat message update to a recipient.
Definition: Gateway.cs:4936

Waher.IoTGateway.Gateway.ExecuteServiceCommand
static async Task< bool > ExecuteServiceCommand(int CommandNr)
Executes a service command.
Definition: Gateway.cs:4153

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.ControlClient
static ControlClient ControlClient
XMPP Control Client.
Definition: Gateway.cs:4068

Waher.IoTGateway.Gateway.AddWebSniffer
static string AddWebSniffer(string SnifferId, HttpRequest Request, BinaryPresentationMethod BinaryPresentationMethod, ICommunicationLayer ComLayer, string UserVariable, params string[] Privileges)
Creates a web sniffer, and adds it to a sniffable object.
Definition: Gateway.cs:5828

Waher.IoTGateway.Gateway.GetShortUrl
static string GetShortUrl(string Url, bool OneTimeUse)
Shortens a URL temporarily. Shortened URLs are available at most for 24 hours (if used) and 1h if not...
Definition: Gateway.cs:6293

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

Waher.IoTGateway.Gateway.MailClient
static MailClient MailClient
XMPP Mail Client, if support for mail-extensions is available on the XMPP broker.
Definition: Gateway.cs:4108

Waher.IoTGateway.Gateway.TryGetLocalResourceFileName
static bool TryGetLocalResourceFileName(string Resource, string Host, out string FileName)
Tries to get a file name for a resource, if local.
Definition: Gateway.cs:6305

Waher.IoTGateway.Gateway.SendGroupChatMessage
static async Task SendGroupChatMessage(string Markdown, string To, string MessageId, string ThreadId)
Sends a group chat message to a recipient.
Definition: Gateway.cs:4924

Waher.IoTGateway.Gateway.PublishPersonalEvent
static Task PublishPersonalEvent(IPersonalEvent PersonalEvent)
Publishes a personal event on the XMPP network.
Definition: Gateway.cs:4423

Waher.IoTGateway.Gateway.GatewayConfigLocalFileName
const string GatewayConfigLocalFileName
Gateway.config
Definition: Gateway.cs:151

Waher.IoTGateway.Gateway.NewMomentaryValues
static Task NewMomentaryValues(params Field[] Values)
Reports newly measured values.
Definition: Gateway.cs:4381

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.Password
string Password
Password for PFX file, if any.
Definition: DomainConfiguration.cs:225

Waher.IoTGateway.Setup.DomainConfiguration.PrivateKey
byte[] PrivateKey
Private Key
Definition: DomainConfiguration.cs:205

Waher.IoTGateway.Setup.DomainConfiguration.DynDnsInterval
int DynDnsInterval
Interval (in seconds) for checking if the IP address has changed.
Definition: DomainConfiguration.cs:290

Waher.IoTGateway.Setup.DomainConfiguration.AlternativeDomains
string[] AlternativeDomains
Alternative domain names
Definition: DomainConfiguration.cs:94

Waher.IoTGateway.Setup.DomainConfiguration.PFX
byte[] PFX
PFX container for certificate and private key, if available.
Definition: DomainConfiguration.cs:215

Waher.IoTGateway.Setup.DomainConfiguration.Certificate
byte[] Certificate
Certificate
Definition: DomainConfiguration.cs:195

Waher.IoTGateway.Setup.DomainConfiguration.UseDomainName
bool UseDomainName
If the server uses a domain name.
Definition: DomainConfiguration.cs:104

Waher.IoTGateway.Setup.DomainConfiguration.DynamicDns
bool DynamicDns
If the server uses a dynamic DNS service.
Definition: DomainConfiguration.cs:125

Waher.IoTGateway.Setup.DomainConfiguration.UseEncryption
bool UseEncryption
If the server uses server-side encryption.
Definition: DomainConfiguration.cs:135

Waher.IoTGateway.Setup.DomainConfiguration.Domain
string Domain
Principal domain name
Definition: DomainConfiguration.cs:84

Waher.IoTGateway.Setup.DomainConfiguration.HasCertificate
bool HasCertificate
If the configuration has a certificate.
Definition: DomainConfiguration.cs:373

Waher.IoTGateway.Setup.Legal.ContractSignatureRequest
Contains information about a contract signature request.
Definition: ContractSignatureRequest.cs:19

Waher.IoTGateway.Setup.Legal.ContractSignatureRequest.ObjectId
string ObjectId
Object ID
Definition: ContractSignatureRequest.cs:43

Waher.IoTGateway.Setup.Legal.ContractSignatureRequest.ContractId
string ContractId
Contract ID
Definition: ContractSignatureRequest.cs:112

Waher.IoTGateway.Setup.Legal.ContractSignatureRequest.SetContract
void SetContract(Contract Contract)
Sets a parsed contract.
Definition: ContractSignatureRequest.cs:68

Waher.IoTGateway.Setup.LegalIdentityConfiguration
Configures legal identity for the gateway.
Definition: LegalIdentityConfiguration.cs:33

Waher.IoTGateway.Setup.LegalIdentityConfiguration.PetitionLegalIdentity
Task< bool > PetitionLegalIdentity(string LegalId, string PetitionId, string Purpose, EventHandlerAsync< LegalIdentityPetitionResponseEventArgs > Callback, TimeSpan Timeout, HttpRequest Request)
Petitions information about a legal identity from its owner.
Definition: LegalIdentityConfiguration.cs:1434

Waher.IoTGateway.Setup.LegalIdentityConfiguration.PetitionContract
Task< bool > PetitionContract(string ContractId, string PetitionId, string Purpose, EventHandlerAsync< ContractPetitionResponseEventArgs > Callback, TimeSpan Timeout, HttpRequest Request)
Petitions information about a smart contract from its owner.
Definition: LegalIdentityConfiguration.cs:1509

Waher.IoTGateway.Setup.LegalIdentityConfiguration.Instance
static LegalIdentityConfiguration Instance
Instance of configuration object.
Definition: LegalIdentityConfiguration.cs:131

Waher.IoTGateway.Setup.LegalIdentityConfiguration.LatestApprovedLegalIdentityId
static string LatestApprovedLegalIdentityId
Latest approved Legal Identity ID.
Definition: LegalIdentityConfiguration.cs:1374

Waher.IoTGateway.Setup.NotificationConfiguration
Notification Configuration
Definition: NotificationConfiguration.cs:19

Waher.IoTGateway.Setup.NotificationConfiguration.Urls
CaseInsensitiveString[] Urls
Notification addresses.
Definition: NotificationConfiguration.cs:54

Waher.IoTGateway.Setup.NotificationConfiguration.Instance
static NotificationConfiguration Instance
Current instance of configuration.
Definition: NotificationConfiguration.cs:37

Waher.IoTGateway.Setup.NotificationConfiguration.Addresses
CaseInsensitiveString[] Addresses
Notification addresses.
Definition: NotificationConfiguration.cs:44

Waher.IoTGateway.Setup.SystemConfiguration
Abstract base class for system configurations.
Definition: SystemConfiguration.cs:20

Waher.IoTGateway.Setup.SystemConfiguration.InitSetup
virtual Task InitSetup(HttpServer WebServer)
Initializes the setup object.
Definition: SystemConfiguration.cs:118

Waher.IoTGateway.Setup.SystemConfiguration.Complete
bool Complete
If the configuration is complete.
Definition: SystemConfiguration.cs:45

Waher.IoTGateway.Setup.SystemConfiguration.Title
abstract Task< string > Title(Language Language)
Gets a title for the system configuration.

Waher.IoTGateway.Setup.SystemConfiguration.SetupConfiguration
virtual Task< bool > SetupConfiguration(HttpServer WebServer)
Waits for the user to provide configuration.
Definition: SystemConfiguration.cs:137

Waher.IoTGateway.Setup.SystemConfiguration.ConfigureSystem
abstract Task ConfigureSystem()
Is called during startup to configure the system.

Waher.IoTGateway.Setup.SystemConfiguration.Priority
abstract int Priority
Priority of the setting. Configurations are sorted in ascending order.
Definition: SystemConfiguration.cs:92

Waher.IoTGateway.Setup.SystemConfiguration.Resource
abstract string Resource
Resource to be redirected to, to perform the configuration.
Definition: SystemConfiguration.cs:84

Waher.IoTGateway.Setup.SystemConfiguration.SimplifiedConfiguration
virtual Task< bool > SimplifiedConfiguration()
Simplified configuration by configuring simple default values.
Definition: SystemConfiguration.cs:217

Waher.IoTGateway.Setup.SystemConfiguration.EnvironmentConfiguration
abstract Task< bool > EnvironmentConfiguration()
Environment configuration by configuring values available in environment variables.

Waher.IoTGateway.Setup.SystemConfiguration.UnregisterSetup
virtual Task UnregisterSetup(HttpServer WebServer)
Unregisters the setup object.
Definition: SystemConfiguration.cs:127

Waher.IoTGateway.Setup.SystemConfiguration.MakeCompleted
virtual Task MakeCompleted()
Sets the configuration task as completed.
Definition: SystemConfiguration.cs:187

Waher.IoTGateway.Setup.SystemConfiguration.DeferredConfiguration
virtual Task DeferredConfiguration(HttpServer WebServer)
Performs a deferred configuration. Deferred configurations are such that could not be performed durin...
Definition: SystemConfiguration.cs:514

Waher.IoTGateway.Setup.SystemConfiguration.SetStaticInstance
abstract void SetStaticInstance(ISystemConfiguration Configuration)
Sets the static instance of the configuration.

Waher.IoTGateway.Setup.SystemConfiguration.CleanupAfterConfiguration
virtual Task CleanupAfterConfiguration(HttpServer WebServer)
Cleans up after configuration has been performed.
Definition: SystemConfiguration.cs:150

Waher.IoTGateway.Setup.WebMenuItem
Represents an item in a web menu.
Definition: WebMenuItem.cs:11

Waher.IoTGateway.Setup.XmppConfiguration
XMPP Configuration
Definition: Registration.cs:7

Waher.IoTGateway.Setup.XmppConfiguration.LegalIdentities
string LegalIdentities
JID of legal identities component.
Definition: XmppConfiguration.cs:253

Waher.IoTGateway.Setup.XmppConfiguration.SoftwareUpdates
string SoftwareUpdates
JID of software updates component.
Definition: XmppConfiguration.cs:263

Waher.IoTGateway.Setup.XmppConfiguration.GetCredentials
XmppCredentials GetCredentials()
Gets connection credentials.
Definition: XmppConfiguration.cs:634

Waher.IoTGateway.Setup.XmppConfiguration.Geo
string Geo
JID of geo-spatial publish/subscribe component.
Definition: XmppConfiguration.cs:273

Waher.IoTGateway.Setup.XmppConfiguration.PubSub
string PubSub
JID of publish/subscribe component.
Definition: XmppConfiguration.cs:243

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

Waher.IoTGateway.Setup.XmppConfiguration.Host
string Host
Host to connect to
Definition: XmppConfiguration.cs:119

Waher.IoTGateway.Setup.XmppConfiguration.MultiUserChat
string MultiUserChat
JID of Multi-User Chat service.
Definition: XmppConfiguration.cs:233

Waher.IoTGateway.WebResources.Echo
Echoes what the client sends in.
Definition: Echo.cs:11

Waher.IoTGateway.WebResources.ExportFormats.ExportFormat
Abstract base class for export formats.
Definition: ExportFormat.cs:14

Waher.IoTGateway.WebResources.ExportFormats.ExportFormat.UpdateClientsFileUpdated
static void UpdateClientsFileUpdated(string FileName, long Length, DateTime Created)
Updates the status of a file on all pages viewing backup files
Definition: ExportFormat.cs:296

Waher.IoTGateway.WebResources.ExportFormats.ExportFormat.UpdateClientsFileDeleted
static void UpdateClientsFileDeleted(string FileName)
Removes a file from all pages viewing backup files
Definition: ExportFormat.cs:322

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.IoTGateway.WebResources.Login
Provides a resource that allows the caller to login to the gateway through a POST method call.
Definition: Login.cs:19

Waher.IoTGateway.WebResources.Login.AutoLoginVariableName
const string AutoLoginVariableName
Variable to indicate if the user was automatically logged in. Not accessible via script.
Definition: Login.cs:29

Waher.IoTGateway.WebResources.Logout
Logs the user out from the gateway.
Definition: Logout.cs:10

Waher.IoTGateway.WebResources.MasterJavascript
A resource that returns as a single JavaScript file, the following four files:
Definition: MasterJavascript.cs:23

Waher.IoTGateway.WebResources.ProposeContract
Proposes a new smart contract
Definition: ProposeContract.cs:18

Waher.IoTGateway.WebResources.StartExport
Starts data export
Definition: StartExport.cs:32

Waher.IoTGateway.WebResources.UrlShortener
Web Service for working with short URLs.
Definition: UrlShortener.cs:15

Waher.IoTGateway.WebResources.UrlShortener.GetShortUrl
static string GetShortUrl(string Url, bool OneTimeUse)
Shortens a URL temporarily. Shortened URLs are available at most for 24 hours (if used) and 1h if not...
Definition: UrlShortener.cs:150

Waher.IoTGateway.WebResources.WebEventSink
Sending events to the corresponding web page(s).
Definition: WebEventSink.cs:15

Waher.IoTGateway.WebResources.WebSniffer
Sending sniffer events to the corresponding web page(s).
Definition: WebSniffer.cs:22

Waher.IoTGateway.WebResources.WebSniffer.SnifferId
string SnifferId
Sniffer ID
Definition: WebSniffer.cs:79

Waher.Jobs.JobSource
Defines the Jobs data source. This data source contains a tree structure of jobs of nodes
Definition: JobSource.cs:20

Waher.Jobs.JobSource.DeleteOldEvents
static async Task< int > DeleteOldEvents(TimeSpan MaxAge)
Deletes old data source events.
Definition: JobSource.cs:287

Waher.Networking.CoAP.CoapEndpoint
CoAP client. CoAP is defined in RFC7252: https://tools.ietf.org/html/rfc7252
Definition: CoapEndpoint.cs:35

Waher.Networking.CommunicationLayer
Simple base class for classes implementing communication protocols.
Definition: CommunicationLayer.cs:25

Waher.Networking.CommunicationLayer.Exception
void Exception(Exception Exception)
Called to inform the viewer of an exception state.
Definition: CommunicationLayer.cs:513

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.CommunicationLayer.RemoveRange
Task RemoveRange(IEnumerable< ISniffer > Sniffers)
Removes a set of sniffers, if registered.
Definition: CommunicationLayer.cs:115

Waher.Networking.HTTP.Authentication.RequiredPrivileges
Represents an HTTP authentication scheme that embeds a collection of authentication schemes,...
Definition: RequiredPrivileges.cs:15

Waher.Networking.HTTP.Authentication.SessionAuthentication
Authentication mechanism that makes sure the user has an established session with the web server.
Definition: SessionAuthentication.cs:14

Waher.Networking.HTTP.Authentication.SessionAuthentication.DefaultUserVariable
const string DefaultUserVariable
Default user variable: User
Definition: SessionAuthentication.cs:18

Waher.Networking.HTTP.CustomErrorEventArgs
Event arguments for custom error content events.
Definition: CustomErrorEventArgs.cs:9

Waher.Networking.HTTP.CustomErrorEventArgs.SetContent
void SetContent(string ContentType, byte[] Content)
Sets custom content to return.
Definition: CustomErrorEventArgs.cs:72

Waher.Networking.HTTP.CustomErrorEventArgs.StatusCode
int StatusCode
Status code of error
Definition: CustomErrorEventArgs.cs:50

Waher.Networking.HTTP.CustomErrorEventArgs.Request
HttpRequest Request
Current request object.
Definition: CustomErrorEventArgs.cs:40

Waher.Networking.HTTP.CustomErrorEventArgs.ContentType
string ContentType
Content-Type of any content.
Definition: CustomErrorEventArgs.cs:60

Waher.Networking.HTTP.CustomErrorEventArgs.Content
byte[] Content
Any content.
Definition: CustomErrorEventArgs.cs:65

Waher.Networking.HTTP.CustomSniffersEventArgs
Event arguments for customizing sniffers based on remote endpoint.
Definition: CustomSniffersEventArgs.cs:10

Waher.Networking.HTTP.CustomSniffersEventArgs.Sniffers
ISniffer[] Sniffers
Sniffers to use for the connection.
Definition: CustomSniffersEventArgs.cs:32

Waher.Networking.HTTP.CustomSniffersEventArgs.RemoteEndpoint
string RemoteEndpoint
Remote Endpoint.
Definition: CustomSniffersEventArgs.cs:26

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.ForbiddenException.AccessDenied
static ForbiddenException AccessDenied(string ObjectId, string ActorId)
Returns a ForbiddenException object, and logs a entry in the event log about the event.
Definition: ForbiddenException.cs:111

Waher.Networking.HTTP.HeaderFields.HttpFieldAcceptEncoding
Accept-Encoding HTTP Field header. (RFC 2616, §14.3)
Definition: HttpFieldAcceptEncoding.cs:13

Waher.Networking.HTTP.HeaderFields.HttpFieldAcceptEncoding.ContentEncodingsReconfigured
static void ContentEncodingsReconfigured()
If Content-Encodings have been reconfigured.
Definition: HttpFieldAcceptEncoding.cs:67

Waher.Networking.HTTP.HeaderFields.HttpFieldAccept
Accept HTTP Field header. (RFC 2616, §14.1)
Definition: HttpFieldAccept.cs:10

Waher.Networking.HTTP.HeaderFields.HttpFieldAcceptRecords.IsAcceptable
bool IsAcceptable(string Alternative)
Checks if an alternative is acceptable to the client sending a request.
Definition: HttpFieldAcceptRecords.cs:151

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
Base class of all HTTP Exceptions.
Definition: HttpException.cs:14

Waher.Networking.HTTP.HttpField.Value
string Value
HTTP Field Value
Definition: HttpField.cs:31

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.AllowTypeConversion
void AllowTypeConversion(params string[] ContentTypes)
Enables content conversion on files in this folder, and its subfolders. If no content types are speci...
Definition: HttpFolderResource.cs:1492

Waher.Networking.HTTP.HttpFolderResource.AddDefaultResponseHeader
void AddDefaultResponseHeader(string Key, string Value)
Adds a default HTTP Response header that will be returned in responses for resources in the folder.
Definition: HttpFolderResource.cs:159

Waher.Networking.HTTP.HttpFolderResource.ProtectContentType
static void ProtectContentType(string ContentType)
Protects a content type, so that it cannot be retrieved in raw format by external parties through any...
Definition: HttpFolderResource.cs:133

Waher.Networking.HTTP.HttpRedirectionResource
An HTTP redirection resource. Incoming requests are redirected to another location.
Definition: HttpRedirectionResource.cs:11

Waher.Networking.HTTP.HttpRequestHeader.Host
HttpFieldHost Host
Host HTTP Field header. (RFC 2616, §14.23)
Definition: HttpRequestHeader.cs:379

Waher.Networking.HTTP.HttpRequestHeader.Accept
HttpFieldAccept Accept
Accept HTTP Field header. (RFC 2616, §14.1)
Definition: HttpRequestHeader.cs:330

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.HttpRequestHeader.ResourcePart
string ResourcePart
Contains original resource part of request.
Definition: HttpRequestHeader.cs:190

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.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.HttpResponse
Represets a response of an HTTP client request.
Definition: HttpResponse.cs:23

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.HttpReverseProxyResource
An HTTP Reverse proxy resource. Incoming requests are reverted to a another web server for processing...
Definition: HttpReverseProxyResource.cs:26

Waher.Networking.HTTP.HttpScriptResource
Publishes a web resource whose contents is produced by script.
Definition: HttpScriptResource.cs:21

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

Waher.Networking.HTTP.HttpServer.AddHttpsPorts
void AddHttpsPorts(params int[] HttpsPorts)
Opens additional HTTPS ports, if not already open.
Definition: HttpServer.cs:553

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

Waher.Networking.HTTP.HttpServer.RegisterVanityResource
void RegisterVanityResource(string RegexPattern, string MapTo)
Registers a vanity resource.
Definition: HttpServer.cs:2473

Waher.Networking.HTTP.HttpServer.ConfigureMutualTls
void ConfigureMutualTls(ClientCertificates ClientCertificates, bool TrustClientCertificates, bool LockSettings)
Configures Mutual-TLS capabilities of the server. Affects all connections, all resources.
Definition: HttpServer.cs:939

Waher.Networking.HTTP.HttpServer.UpdateCertificate
void UpdateCertificate(X509Certificate ServerCertificate)
Updates the server certificate
Definition: HttpServer.cs:927

Waher.Networking.HTTP.HttpServer.WebApplicationFirewall
IWebApplicationFirewall WebApplicationFirewall
Reference to Web Application Firewall (WAF) to help remove unwanted communication from the server
Definition: HttpServer.cs:1551

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.LoginAuditor
ILoginAuditor LoginAuditor
Reference to login-auditor to help remove malicious users from the server.
Definition: HttpServer.cs:1535

Waher.Networking.HTTP.HttpServer.LocalIpAddresses
IPAddress[] LocalIpAddresses
IP Addresses receiving requests on.
Definition: HttpServer.cs:779

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

Waher.Networking.HTTP.HttpServer.TryGetResource
bool TryGetResource(HttpRequest Request, out HttpResource Resource, out string SubPath)
Tries to get a resource from the server.
Definition: HttpServer.cs:1796

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

Waher.Networking.HTTP.HttpServer.TryGetFileName
bool TryGetFileName(string LocalUrl, out string FileName)
Tries to get the full path of a file-based resource.
Definition: HttpServer.cs:2427

Waher.Networking.HTTP.HttpServer.GetPorts
int[] GetPorts(bool Http, bool Https)
Gets open ports
Definition: HttpServer.cs:849

Waher.Networking.HTTP.HttpServer.OpenPorts
int[] OpenPorts
Ports successfully opened.
Definition: HttpServer.cs:763

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.HttpServer.NetworkChanged
async void NetworkChanged()
Adapts the server to changes in the network. This method can be called automatically by calling the c...
Definition: HttpServer.cs:285

Waher.Networking.HTTP.HttpServer.SetHttp2ConnectionSettings
void SetHttp2ConnectionSettings(int InitialStreamWindowSize, int InitialConnectionWindowSize, int MaxFrameSize, int MaxConcurrentStreams, int HeaderTableSize, bool EnablePush, bool NoRfc7540Priorities, bool Lock)
HTTP/2 connection settings (SETTINGS).
Definition: HttpServer.cs:1051

Waher.Networking.HTTP.HttpServer.UnregisterVanityResources
int UnregisterVanityResources(object Tag)
Unregisters vanity resources tagged with a specific object.
Definition: HttpServer.cs:2506

Waher.Networking.HTTP.HttpServer.RegisterDomainProxy
HttpResource RegisterDomainProxy(string LocalDomain, HttpReverseProxyResource DomainProxy)
Registers a domain proxy resource with the server.
Definition: HttpServer.cs:1590

Waher.Networking.HTTP.HttpServer.Add
override void Add(ISniffer Sniffer)
ICommunicationLayer.Add
Definition: HttpServer.cs:1460

Waher.Networking.HTTP.HttpServer.AddHttpPorts
void AddHttpPorts(params int[] HttpPorts)
Opens additional HTTP ports, if not already open.
Definition: HttpServer.cs:391

Waher.Networking.HTTP.Mcp.Model.Icon
An optionally-sized icon that can be displayed in a user interface.
Definition: Icon.cs:10

Waher.Networking.HTTP.Mcp.Model.Icons
Base interface to add icons property.
Definition: Icons.cs:11

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.OAuth.AuthorizationServerMetaData
Provides OAUTH authorization server meta-data, as defined in RFC 8414. https://datatracker....
Definition: AuthorizationServerMetaData.cs:15

Waher.Networking.HTTP.OAuth.OAuth2Environment
Manages the OAuth 2 environment.
Definition: OAuth2Environment.cs:20

Waher.Networking.HTTP.OAuth.OAuthAuthorizeResource
OAUTH authorize resource, as defined in RFC 6749. https://datatracker.ietf.org/doc/html/rfc6749
Definition: OAuthAuthorizeResource.cs:29

Waher.Networking.HTTP.OAuth.OAuthDeviceAuthorizationResource
OAUTH device authorization resource, as defined in RFC 8628. https://datatracker.ietf....
Definition: OAuthDeviceAuthorizationResource.cs:26

Waher.Networking.HTTP.OAuth.OAuthIntrospectionResource
OAUTH introspection resource, as defined in RFCs 7662. https://datatracker.ietf.org/doc/html/rfc7662
Definition: OAuthIntrospectionResource.cs:14

Waher.Networking.HTTP.OAuth.OAuthManagementResource
OAUTH client management resource, as defined in RFCs 7591. https://datatracker.ietf....
Definition: OAuthManagementResource.cs:18

Waher.Networking.HTTP.OAuth.OAuthRegistrationResource
OAUTH dynamic registration resource, as defined in RFCs 7591 and 7592. https://datatracker....
Definition: OAuthRegistrationResource.cs:24

Waher.Networking.HTTP.OAuth.OAuthTokenResource
OAUTH token resource, as defined in RFC 6749. https://datatracker.ietf.org/doc/html/rfc6749
Definition: OAuthTokenResource.cs:24

Waher.Networking.HTTP.OAuth.ProtectedResourceMetaData
Provides OAUTH resource meta-data, as defined in RFC 9728. https://datatracker.ietf....
Definition: ProtectedResourceMetaData.cs:15

Waher.Networking.HTTP.ProfilingEventArgs
Event arguments for profiling event handlers.
Definition: ProfilingEventArgs.cs:11

Waher.Networking.HTTP.ProfilingEventArgs.FlowControl
IFlowControl FlowControl
Flow control mechanism used.
Definition: ProfilingEventArgs.cs:31

Waher.Networking.HTTP.ProfilingEventArgs.Profiler
Profiler Profiler
Profiler for session.
Definition: ProfilingEventArgs.cs:26

Waher.Networking.HTTP.SeeOtherException
The response to the request can be found under a different URI and SHOULD be retrieved using a GET me...
Definition: SeeOtherException.cs:13

Waher.Networking.HTTP.ServiceUnavailableException
The server is currently unable to handle the request due to a temporary overloading or maintenance of...
Definition: ServiceUnavailableException.cs:11

Waher.Networking.HTTP.SessionVariables
Collection of session variables.
Definition: SessionVariables.cs:14

Waher.Networking.HTTP.SessionVariables.LockAsync
async Task LockAsync()
Locks the collection. The collection is by default thread safe. But if longer transactions require un...
Definition: SessionVariables.cs:136

Waher.Networking.HTTP.SessionVariables.Locked
bool Locked
If the session variables are currently locked.
Definition: SessionVariables.cs:100

Waher.Networking.HTTP.SessionVariables.TryGetVariable
override bool TryGetVariable(string Name, out Variable Variable)
Tries to get a variable object, given its name.
Definition: SessionVariables.cs:182

Waher.Networking.HTTP.SessionVariables.Release
void Release()
Releases the collection, previously locked through a call to LockAsync().
Definition: SessionVariables.cs:167

Waher.Networking.HTTP.TemporaryRedirectException
The requested resource resides temporarily under a different URI. Since the redirection MAY be altere...
Definition: TemporaryRedirectException.cs:11

Waher.Networking.MQTT.MqttClient
Manages an MQTT connection. Implements MQTT v3.1.1, as defined in http://docs.oasis-open....
Definition: MqttClient.cs:30

Waher.Networking.NetworkingModule
Module that controls the life cycle of communication.
Definition: NetworkingModule.cs:13

Waher.Networking.NetworkingModule.Stopping
static bool Stopping
If the system is stopping.
Definition: NetworkingModule.cs:71

Waher.Networking.PeerToPeer.InternetGatewayRegistrator
Manages registration of TCP and UDP ports in an Internet Gateway
Definition: InternetGatewayRegistrator.cs:19

Waher.Networking.PeerToPeer.InternetGatewayRegistrator.IsPublicAddress
static bool IsPublicAddress(IPAddress Address)
Checks if an IPv4 address is public.
Definition: InternetGatewayRegistrator.cs:113

Waher.Networking.Sniffers.ConsoleOutSniffer
Outputs sniffed data to the Console Output, serialized by ConsoleOut.
Definition: ConsoleOutSniffer.cs:14

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

Waher.Networking.Sniffers.XmlFileSnifferSet
Maintains a set of XML-file-based sniffers. File output is organized into subfolders of a given folde...
Definition: XmlFileSnifferSet.cs:11

Waher.Networking.XMPP.Avatar.AvatarClient
Provides help with managing avatars.
Definition: AvatarClient.cs:25

Waher.Networking.XMPP.Concentrator.ConcentratorClient
Implements an XMPP concentrator client interface.
Definition: ConcentratorClient.cs:28

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

Waher.Networking.XMPP.Concentrator.ConcentratorServer.DataSources
IDataSource[] DataSources
All data sources.
Definition: ConcentratorServer.cs:680

Waher.Networking.XMPP.Concentrator.ConcentratorServer.SensorServer
SensorServer SensorServer
Sensor server.
Definition: ConcentratorServer.cs:448

Waher.Networking.XMPP.Concentrator.ConcentratorServer.Create
static Task< ConcentratorServer > Create(XmppClient Client, params IDataSource[] DataSources)
Creates an XMPP concentrator server interface.
Definition: ConcentratorServer.cs:222

Waher.Networking.XMPP.Concentrator.ConcentratorServer.ControlServer
ControlServer ControlServer
Control server.
Definition: ConcentratorServer.cs:453

Waher.Networking.XMPP.Contracts.Contract
Contains the definition of a contract
Definition: Contract.cs:22

Waher.Networking.XMPP.Contracts.Contract.Provider
string Provider
JID of the Trust Provider hosting the contract
Definition: Contract.cs:84

Waher.Networking.XMPP.Contracts.Contract.Roles
Role[] Roles
Roles defined in the smart contract.
Definition: Contract.cs:240

Waher.Networking.XMPP.Contracts.Contract.ContractId
string ContractId
Contract identity
Definition: Contract.cs:65

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.LoadKeys
Task< bool > LoadKeys(bool CreateIfNone)
Loads keys from the underlying persistence layer.
Definition: ContractsClient.cs:438

Waher.Networking.XMPP.Contracts.ContractsClient.SetKeySettingsInstance
void SetKeySettingsInstance(string InstanceName, bool Locked)
Sets the key settings instance name.
Definition: ContractsClient.cs:1378

Waher.Networking.XMPP.Contracts.Role
Class defining a role
Definition: Role.cs:7

Waher.Networking.XMPP.Control.ControlClient
Implements an XMPP control client interface.
Definition: ControlClient.cs:22

Waher.Networking.XMPP.Events.AuthorityEventArgs
Event arguments for authority events, to associate a Bare JID with an authority that can authorize pr...
Definition: AuthorityEventArgs.cs:10

Waher.Networking.XMPP.Events.AuthorityEventArgs.Authority
IRequestOrigin Authority
Authority associated with Bare JID
Definition: AuthorityEventArgs.cs:28

Waher.Networking.XMPP.Events.AuthorityEventArgs.BareJid
string BareJid
Bare JID
Definition: AuthorityEventArgs.cs:23

Waher.Networking.XMPP.Events.ValidateSenderEventArgs
Event arguments for sender validation events.
Definition: ValidateSenderEventArgs.cs:10

Waher.Networking.XMPP.Events.ValidateSenderEventArgs.FromBareJID
string FromBareJID
Bare JID of resource sending the stanza.
Definition: ValidateSenderEventArgs.cs:67

Waher.Networking.XMPP.Events.ValidateSenderEventArgs.Reject
void Reject()
Called from an event handler to reject the sender.
Definition: ValidateSenderEventArgs.cs:90

Waher.Networking.XMPP.Events.ValidateSenderEventArgs.Stanza
XmlElement Stanza
The stanza.
Definition: ValidateSenderEventArgs.cs:49

Waher.Networking.XMPP.Events.ValidateSenderEventArgs.Accept
void Accept()
Called from an event handler to accept the sender.
Definition: ValidateSenderEventArgs.cs:82

Waher.Networking.XMPP.Geo.GeoClient
Adds support for geo-spatial publish/subscribe communication pattern to an XMPP client.
Definition: GeoClient.cs:20

Waher.Networking.XMPP.HTTPX.HttpxProxy
Implements a Proxy resource that allows Web clients to fetch HTTP-based resources over HTTPX.
Definition: HttpxProxy.cs:19

Waher.Networking.XMPP.HTTPX.HttpxServer
HTTPX server.
Definition: HttpxServer.cs:21

Waher.Networking.XMPP.InBandBytestreams.IbbClient
Class sending and receiving binary streams over XMPP using XEP-0047: In-band Bytestreams: https://xmp...
Definition: IbbClient.cs:20

Waher.Networking.XMPP.InBandBytestreams.IbbClient.IbbClient
IbbClient(XmppClient Client, int MaxBlockSize)
Class sending and receiving binary streams over XMPP using XEP-0047: In-band Bytestreams: https://xmp...
Definition: IbbClient.cs:37

Waher.Networking.XMPP.MUC.MultiUserChatClient
Client managing communication with a Multi-User-Chat service. https://xmpp.org/extensions/xep-0045....
Definition: MultiUserChatClient.cs:19

Waher.Networking.XMPP.Mail.MailClient
Client providing support for server mail-extension.
Definition: MailClient.cs:18

Waher.Networking.XMPP.Mail.MailEventArgs
Event arguments for mail message events
Definition: MailEventArgs.cs:11

Waher.Networking.XMPP.P2P.SOCKS5.Socks5Proxy
Class managing a SOCKS5 proxy associated with the current XMPP server.
Definition: Socks5Proxy.cs:19

Waher.Networking.XMPP.P2P.SOCKS5.Socks5Proxy.HasProxy
bool HasProxy
If a SOCKS5 proxy has been detected.
Definition: Socks5Proxy.cs:69

Waher.Networking.XMPP.P2P.SOCKS5.Socks5Proxy.StartSearch
Task StartSearch(EventHandlerAsync Callback)
Starts the search of SOCKS5 proxies.
Definition: Socks5Proxy.cs:90

Waher.Networking.XMPP.PEP.PepClient
Client managing the Personal Eventing Protocol (XEP-0163). https://xmpp.org/extensions/xep-0163....
Definition: PepClient.cs:19

Waher.Networking.XMPP.PEP.PepClient.Publish
Task Publish(string Node, EventHandlerAsync< ItemResultEventArgs > Callback, object State)
Publishes an item on a node.
Definition: PepClient.cs:110

Waher.Networking.XMPP.PEP.PepClient.RegisterHandler
void RegisterHandler(Type PersonalEventType, EventHandlerAsync< PersonalEventNotificationEventArgs > Handler)
Registers an event handler of a specific type of personal events.
Definition: PepClient.cs:345

Waher.Networking.XMPP.PEP.PepClient.PubSubClient
PubSubClient PubSubClient
PubSubClient used for the Personal Eventing Protocol. Use this client to perform administrative tasks...
Definition: PepClient.cs:95

Waher.Networking.XMPP.PEP.PepClient.UnregisterHandler
bool UnregisterHandler(Type PersonalEventType, EventHandlerAsync< PersonalEventNotificationEventArgs > Handler)
Unregisters an event handler of a specific type of personal events.
Definition: PepClient.cs:380

Waher.Networking.XMPP.PEP.PersonalEvent
Definition: PersonalEvent.cs:12

Waher.Networking.XMPP.Provisioning.Events.ClaimedEventArgs
Event argument base class for node information and JID events.
Definition: ClaimedEventArgs.cs:10

Waher.Networking.XMPP.Provisioning.Events.ClaimedEventArgs.IsPublic
bool IsPublic
If the device is considered a public device, meaning it's available in searches in the thing registry...
Definition: ClaimedEventArgs.cs:22

Waher.Networking.XMPP.Provisioning.Events.NodeEventArgs.Node
ThingReference Node
Node reference.
Definition: NodeEventArgs.cs:23

Waher.Networking.XMPP.Provisioning.Events.NodeJidEventArgs.JID
string JID
JID.
Definition: NodeJidEventArgs.cs:22

Waher.Networking.XMPP.Provisioning.MetaDataNumericTag
Meta-data numeric tag.
Definition: MetaDataNumericTag.cs:10

Waher.Networking.XMPP.Provisioning.MetaDataStringTag
Meta-data string tag.
Definition: MetaDataStringTag.cs:9

Waher.Networking.XMPP.Provisioning.MetaDataTag
Abstract base class for all meta-data tags.
Definition: MetaDataTag.cs:10

Waher.Networking.XMPP.Provisioning.ProvisioningClient
Implements an XMPP provisioning client interface.
Definition: ProvisioningClient.cs:37

Waher.Networking.XMPP.Provisioning.ProvisioningClient.OwnerJid
string OwnerJid
JID of owner, if known or available.
Definition: ProvisioningClient.cs:228

Waher.Networking.XMPP.Provisioning.RegistrationEventArgs
Event arguments for Registration callbacks.
Definition: RegistrationEventArgs.cs:9

Waher.Networking.XMPP.Provisioning.ThingRegistryClient
Implements an XMPP thing registry client interface.
Definition: ThingRegistryClient.cs:24

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.RegisterThing
Task RegisterThing(MetaDataTag[] MetaDataTags, EventHandlerAsync< RegistrationEventArgs > Callback, object State)
Registers a thing in the Thing Registry. Only things that does not have an owner can register with th...
Definition: ThingRegistryClient.cs:121

Waher.Networking.XMPP.PubSub.PubSubClient
Client managing communication with a Publish/Subscribe component. https://xmpp.org/extensions/xep-006...
Definition: PubSubClient.cs:20

Waher.Networking.XMPP.RosterItem
Maintains information about an item in the roster.
Definition: RosterItem.cs:75

Waher.Networking.XMPP.RosterItem.State
SubscriptionState State
roup Current subscription state.
Definition: RosterItem.cs:268

Waher.Networking.XMPP.Sensor.SensorClient
Implements an XMPP sensor client interface.
Definition: SensorClient.cs:21

Waher.Networking.XMPP.Sensor.SensorServer.NewMomentaryValues
Task NewMomentaryValues(params Field[] Values)
Reports newly measured values.
Definition: SensorServer.cs:1017

Waher.Networking.XMPP.Software.SoftwareUpdateClient
Implements an XMPP interface for remote software updates.
Definition: SoftwareUpdateClient.cs:23

Waher.Networking.XMPP.Synchronization.SynchronizationClient
Implements the clock synchronization extesion as defined by the Neuro-Foundation (neuro-foundation....
Definition: SynchronizationClient.cs:18

Waher.Networking.XMPP.XmppClient
Manages an XMPP client connection. Implements XMPP, as defined in https://tools.ietf....
Definition: XmppClient.cs:58

Waher.Networking.XMPP.XmppClient.State
XmppState State
Current state of connection.
Definition: XmppClient.cs:985

Waher.Networking.XMPP.XmppClient.OfflineAndDisposeAsync
Task OfflineAndDisposeAsync()
Sends an offline presence, and then disposes the object by calling DisposeAsync.
Definition: XmppClient.cs:1107

Waher.Networking.XMPP.XmppClient.SendMessage
Task SendMessage(MessageType Type, string To, string CustomXml, string Body, string Subject, string Language, string ThreadId, string ParentThreadId)
Sends a simple chat message
Definition: XmppClient.cs:5447

Waher.Networking.XMPP.XmppClient.NamespaceServiceDiscoveryInfo
const string NamespaceServiceDiscoveryInfo
http://jabber.org/protocol/disco#info
Definition: XmppClient.cs:117

Waher.Networking.XMPP.XmppClient.RequestPresenceSubscription
Task RequestPresenceSubscription(string BareJid)
Requests subscription of presence information from a contact.
Definition: XmppClient.cs:4969

Waher.Networking.XMPP.XmppClient.Reconnect
async Task Reconnect()
Reconnects a client after an error or if it's offline. Reconnecting, instead of creating a completely...
Definition: XmppClient.cs:1295

Waher.Networking.XMPP.XmppClient.BareJID
string BareJID
Bare JID
Definition: XmppClient.cs:3502

Waher.Networking.XMPP.XmppClient.Connect
Task Connect()
Connects the client.
Definition: XmppClient.cs:641

Waher.Networking.XMPP.XmppClient.Domain
string Domain
Current Domain.
Definition: XmppClient.cs:3492

Waher.Networking.XMPP.XmppClient.GetRosterItem
RosterItem GetRosterItem(string BareJID)
Gets a roster item.
Definition: XmppClient.cs:4571

Waher.Networking.XMPP.XmppCredentials
Class containing credentials for an XMPP client connection.
Definition: XmppCredentials.cs:15

Waher.Networking.XMPP.XmppCredentials.Events
string Events
JID of entity to whom events should be sent. Leave blank if events are not to be forwarded.
Definition: XmppCredentials.cs:113

Waher.Networking.XMPP.XmppCredentials.Sniffer
bool Sniffer
If a sniffer is to be used ('true' or 'false'). If 'true', network communication will be output to th...
Definition: XmppCredentials.cs:122

Waher.Networking.XMPP.XmppCredentials.ThingRegistry
string ThingRegistry
JID of Thing Registry to use. Leave blank if no thing registry is to be used.
Definition: XmppCredentials.cs:95

Waher.Networking.XMPP.XmppCredentials.Provisioning
string Provisioning
JID of Provisioning Server to use. Leave blank if no thing registry is to be used.
Definition: XmppCredentials.cs:104

Waher.Output.OutputSource
Defines the Output data source. This data source contains a tree structure of output of nodes
Definition: OutputSource.cs:20

Waher.Output.OutputSource.DeleteOldEvents
static async Task< int > DeleteOldEvents(TimeSpan MaxAge)
Deletes old data source events.
Definition: OutputSource.cs:287

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.LowerCase
string LowerCase
Lower-case representation of the case-insensitive string.
Definition: CaseInsensitiveString.cs:34

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.CollectionEventArgs.Collection
string Collection
Collection
Definition: CollectionEventArgs.cs:24

Waher.Persistence.CollectionRepairedEventArgs
Event arguments for collection repaired events.
Definition: CollectionRepairedEventArgs.cs:9

Waher.Persistence.CollectionRepairedEventArgs.Flagged
FlagSource[] Flagged
If the collection have been flagged as corrupt, and from what stack traces. Is null,...
Definition: CollectionRepairedEventArgs.cs:26

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.HasProvider
static bool HasProvider
If a database provider is registered.
Definition: Database.cs:81

Waher.Persistence.Database.Register
static void Register(IDatabaseProvider DatabaseProvider)
Registers a database provider for use from the static Database class, throughout the lifetime of the ...
Definition: Database.cs:33

Waher.Persistence.Database.Provider
static IDatabaseProvider Provider
Registered database provider.
Definition: Database.cs:59

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.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.FlagSource
Source of code flagging a collection for repair.
Definition: FlagSource.cs:9

Waher.Persistence.FlagSource.Count
int Count
Number of times the collection has been flagged from this source.
Definition: FlagSource.cs:41

Waher.Persistence.FlagSource.StackTrace
string StackTrace
Stack trace of source flagging the collection.
Definition: FlagSource.cs:35

Waher.Persistence.FlagSource.Reason
string Reason
Reason for flagging collection.
Definition: FlagSource.cs:30

Waher.Persistence.Ledger
Static interface for ledger persistence. In order to work, a ledger provider has to be assigned to it...
Definition: Ledger.cs:14

Waher.Persistence.Ledger.HasProvider
static bool HasProvider
If a ledger provider is registered.
Definition: Ledger.cs:105

Waher.Persistence.Ledger.Provider
static ILedgerProvider Provider
Registered ledger provider.
Definition: Ledger.cs:83

Waher.Processors.ProcessorSource
Defines the Processors data source. This data source contains a tree structure of processor of nodes
Definition: ProcessorSource.cs:20

Waher.Processors.ProcessorSource.DeleteOldEvents
static async Task< int > DeleteOldEvents(TimeSpan MaxAge)
Deletes old data source events.
Definition: ProcessorSource.cs:287

Waher.Reports.Files.ReportFilesFolder
Reports folder representing a folder on the file system containing file-based reports.
Definition: ReportFilesFolder.cs:9

Waher.Reports.ReportsDataSource
Defines the Reports data source. This data source contains a tree structure of reports published by d...
Definition: ReportsDataSource.cs:16

Waher.Reports.ReportsDataSource.RegisterRootNode
static async Task< bool > RegisterRootNode(ReportNode ReportRoot)
Registers a new report root node.
Definition: ReportsDataSource.cs:98

Waher.Reports.ReportsFolder
A folder of reports.
Definition: ReportsFolder.cs:10

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

Waher.Runtime.Cache.Cache.Ping
bool Ping(KeyType Key)
Pings an entry in the cache, to keep it from being removed.
Definition: Cache.cs:300

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.Collections.ChunkedList
A chunked list is a linked list of chunks of objects of type T .
Definition: ChunkedList.cs:54

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

Waher.Runtime.IO.Files.ReadAllTextAsync
static async Task< string > ReadAllTextAsync(string FileName)
Reads a text file asynchronously.
Definition: Files.cs:84

Waher.Runtime.IO.Files.WriteAllTextAsync
static Task WriteAllTextAsync(string FileName, string Text)
Creates a text file asynchronously.
Definition: Files.cs:95

Waher.Runtime.IO.Strings
Static class managing binary representations of strings.
Definition: Strings.cs:10

Waher.Runtime.IO.Strings.GetString
static string GetString(byte[] Data, int Offset, int Count, Encoding DefaultEncoding)
Gets a string from its binary representation, taking any Byte Order Mark (BOM) into account.
Definition: Strings.cs:148

Waher.Runtime.Inventory.DependencyOrder
Orders modules in dependency order.
Definition: DependencyOrder.cs:11

Waher.Runtime.Inventory.Loader.TypesLoader
Static class, loading and initializing assemblies dynamically.
Definition: TypesLoader.cs:14

Waher.Runtime.Inventory.Loader.TypesLoader.Initialize
static void Initialize()
Initializes the inventory engine, registering types and interfaces available in Types.
Definition: TypesLoader.cs:18

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.StartAllModules
static Task< bool > StartAllModules(int Timeout)
Starts all loaded modules.
Definition: Types.cs:458

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.TryGetModuleParameter
static bool TryGetModuleParameter(string Name, out object Value)
Tries to get a module parameter value.
Definition: Types.cs:607

Waher.Runtime.Inventory.Types.GetLoadedModules
static IModule[] GetLoadedModules()
Gets an array of loaded modules.
Definition: Types.cs:411

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.Inventory.Types.StopAllModules
static Task StopAllModules()
Stops all modules.
Definition: Types.cs:328

Waher.Runtime.Language.Language
Contains information about a language.
Definition: Language.cs:17

Waher.Runtime.Language.Language.Language
Language()
Contains information about a language.
Definition: Language.cs:31

Waher.Runtime.Language.Namespace
Contains information about a namespace in a language.
Definition: Namespace.cs:17

Waher.Runtime.Language.Translator
Basic access point for runtime language localization.
Definition: Translator.cs:16

Waher.Runtime.Language.Translator.SchemaRoot
const string SchemaRoot
Expected root in XML files.
Definition: Translator.cs:30

Waher.Runtime.Language.Translator.ImportAsync
static async Task ImportAsync(XmlReader Xml)
Imports language strings into the language database.
Definition: Translator.cs:236

Waher.Runtime.Language.Translator.SchemaResource
const string SchemaResource
Resource name of embedded schema file.
Definition: Translator.cs:20

Waher.Runtime.Language.Translator.SchemaNamespace
const string SchemaNamespace
Namespace of embedded schema file.
Definition: Translator.cs:25

Waher.Runtime.Profiling.Profiler
Class that keeps track of events and timing.
Definition: Profiler.cs:68

Waher.Runtime.Profiling.Profiler.Stop
void Stop()
Stops measuring time.
Definition: Profiler.cs:227

Waher.Runtime.Profiling.Profiler.CreateThread
ProfilerThread CreateThread(string Name, ProfilerThreadType Type)
Creates a new profiler thread.
Definition: Profiler.cs:128

Waher.Runtime.Profiling.Profiler.ExportPlantUml
string ExportPlantUml(TimeUnit TimeUnit)
Exports events to PlantUML.
Definition: Profiler.cs:530

Waher.Runtime.Profiling.Profiler.ElapsedSeconds
double ElapsedSeconds
Elapsed seconds since start.
Definition: Profiler.cs:241

Waher.Runtime.Profiling.Profiler.Start
void Start()
Starts measuring time.
Definition: Profiler.cs:217

Waher.Runtime.Profiling.ProfilerThread
Class that keeps track of events and timing for one thread.
Definition: ProfilerThread.cs:52

Waher.Runtime.Profiling.ProfilerThread.Start
void Start()
Processing starts.
Definition: ProfilerThread.cs:270

Waher.Runtime.Profiling.ProfilerThread.Exception
void Exception(System.Exception Exception)
Exception occurred
Definition: ProfilerThread.cs:252

Waher.Runtime.Profiling.ProfilerThread.Stop
void Stop()
Processing starts.
Definition: ProfilerThread.cs:280

Waher.Runtime.Profiling.ProfilerThread.Interval
void Interval(DateTime From, DateTime To, string Label)
Records an interval in the profiler thread.
Definition: ProfilerThread.cs:213

Waher.Runtime.Profiling.ProfilerThread.NewState
void NewState(string State)
Thread changes state.
Definition: ProfilerThread.cs:162

Waher.Runtime.ServiceRegistration.ServiceRegistrationClient
XMPP-based Service Registration Client.
Definition: ServiceRegistrationClient.cs:18

Waher.Runtime.ServiceRegistration.ServiceRegistrationClient.GetRegistrationTime
static async Task< DateTime?> GetRegistrationTime()
Gets the original registration time.
Definition: ServiceRegistrationClient.cs:219

Waher.Runtime.Settings.RuntimeSettings
Static class managing persistent settings.
Definition: RuntimeSettings.cs:17

Waher.Runtime.Settings.RuntimeSettings.Set
static bool Set(string Key, string Value)
Sets a string-valued setting.
Definition: RuntimeSettings.cs:59

Waher.Runtime.Settings.RuntimeSettings.GetWhereKeyLikeAsync
static Task< Dictionary< string, object > > GetWhereKeyLikeAsync(string Key, string Wildcard)
Gets available settings, matching a search filter.
Definition: RuntimeSettings.cs:835

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.DeleteAsync
static async Task< bool > DeleteAsync(string Key)
Deletes a runtime setting
Definition: RuntimeSettings.cs:759

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.Threading.MultiReadSingleWriteObject
Represents an object that allows single concurrent writers but multiple concurrent readers....
Definition: MultiReadSingleWriteObject.cs:15

Waher.Runtime.Threading.Sync.AsyncMutex
Asynchronous mutex class.
Definition: AsyncMutex.cs:11

Waher.Runtime.Threading.Sync.AsyncMutex.ReleaseMutex
async Task ReleaseMutex()
Releases the mutex earlier aquired via a call to WaitOne.
Definition: AsyncMutex.cs:200

Waher.Runtime.Threading.Sync.AsyncMutex.Dispose
void Dispose()
IDisposable.Dispose
Definition: AsyncMutex.cs:110

Waher.Runtime.Threading.Sync.AsyncMutex.WaitOne
Task< bool > WaitOne()
Waits for the Mutex to be free, and locks it.
Definition: AsyncMutex.cs:123

Waher.Runtime.Timing.Scheduler
Class that can be used to schedule events in time. It uses a timer to execute tasks at the appointed ...
Definition: Scheduler.cs:14

Waher.Runtime.Timing.Scheduler.Remove
bool Remove(DateTime When)
Removes an event scheduled for a given point in time.
Definition: Scheduler.cs:186

Waher.Runtime.Timing.Scheduler.Add
DateTime Add(DateTime When, Action< object > Callback, object State)
Adds an event.
Definition: Scheduler.cs:54

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

Waher.Script.Expression.Script
string Script
Original script string.
Definition: Expression.cs:207

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.Graphs.Graph
Base class for graphs.
Definition: Graph.cs:88

Waher.Script.Graphs.PixelInformation
Contains pixel information
Definition: PixelInformation.cs:9

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

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.TryGetVariable
virtual bool TryGetVariable(string Name, out Variable Variable)
Tries to get a variable object, given its name.
Definition: Variables.cs:56

Waher.Security.CallStack.UnauthorizedAccessEventArgs
Event arguments for the Assert.UnauthorizedAccess event.
Definition: UnauthorizedAccessEventArgs.cs:11

Waher.Security.CallStack.UnauthorizedAccessEventArgs.Assembly
Assembly Assembly
Assembly in which the type is defined.
Definition: UnauthorizedAccessEventArgs.cs:44

Waher.Security.CallStack.UnauthorizedAccessEventArgs.Method
MethodBase Method
Method being accessed.
Definition: UnauthorizedAccessEventArgs.cs:34

Waher.Security.CallStack.UnauthorizedAccessEventArgs.Trace
StackTrace Trace
StackTrace Trace
Definition: UnauthorizedAccessEventArgs.cs:49

Waher.Security.CallStack.UnauthorizedAccessEventArgs.Type
Type Type
Type on which the method is defined.
Definition: UnauthorizedAccessEventArgs.cs:39

Waher.Security.JWT.JwtFactory
A factory that can create and validate JWT tokens.
Definition: JwtFactory.cs:66

Waher.Security.JWT.JwtFactory.CreateHmacSha256
static JwtFactory CreateHmacSha256()
Creates a JWT factory that can create and validate JWT tokens using the HMAC-SHA256 algorithm.
Definition: JwtFactory.cs:123

Waher.Security.LoginMonitor.LoginAuditor
Class that monitors login events, and help applications determine malicious intent....
Definition: LoginAuditor.cs:26

Waher.Security.LoginMonitor.LoginAuditor.Success
static async void Success(string Message, string UserName, string RemoteEndPoint, string Protocol, params KeyValuePair< string, object >[] Tags)
Handles a successful login attempt.
Definition: LoginAuditor.cs:590

Waher.Security.LoginMonitor.LoginInterval
Number of failing login attempts possible during given time period.
Definition: LoginInterval.cs:10

Waher.Security.LoginMonitor.RemoteEndpoint
Login state information relating to a remote endpoint
Definition: RemoteEndpoint.cs:18

Waher.Security.LoginMonitor.RemoteEndpointIntervals
A set of intervals specific for a given endpoint.
Definition: RemoteEndpointIntervals.cs:10

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.SHA3_256
Implements the SHA3-256 hash function, as defined in section 6.1 in the NIST FIPS 202: https://nvlpub...
Definition: SHA3_256.cs:9

Waher.Security.Users.Privilege
Corresponds to a privilege in the system.
Definition: Privilege.cs:16

Waher.Security.Users.Privileges
Maintains the collection of all privileges in the system.
Definition: Privileges.cs:13

Waher.Security.Users.Privileges.LoadAll
static async Task LoadAll()
Loads all privileges
Definition: Privileges.cs:81

Waher.Security.Users.Roles
Maintains the collection of all roles in the system.
Definition: Roles.cs:14

Waher.Security.Users.Roles.LoadAll
static async Task LoadAll()
Loads all roles
Definition: Roles.cs:71

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.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.HashMethodLocked
static bool HashMethodLocked
If the Hash Method has been registered and locked.
Definition: Users.cs:150

Waher.Security.Users.Users.Register
static void Register(HashComputationMethod HashComputationMethod, string HashMethodTypeName, LoginAuditor LoginAuditor, bool Lock)
Registers a Hash Digest Computation Method.
Definition: Users.cs:116

Waher.Security.Users.Users.Source
static IUserSource Source
User source.
Definition: Users.cs:37

Waher.Security.WAF.WebApplicationFirewall
Web Application Firewall for HttpServer.
Definition: WebApplicationFirewall.cs:21

Waher.Security.WAF.WebApplicationFirewall.LoadFromFile
static WebApplicationFirewall LoadFromFile(string FileName, ILoginAuditor LoginAuditor, string AppDataFolder)
Loads a WAF definition from file.
Definition: WebApplicationFirewall.cs:102

Waher.Things.Authorities.MaximumAuthority
Origin of request has maximum authority.
Definition: MaximumAuthority.cs:7

Waher.Things.Authorities.ViewOnlyAuthority
Origin of request has view-only authority.
Definition: ViewOnlyAuthority.cs:9

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.Http.HttpModule.CheckLocalWebServerNode
static async Task CheckLocalWebServerNode()
Checks if the Local Web Server Node has been created.
Definition: HttpModule.cs:301

Waher.Things.Metering.GetQrCodeUrlEventArgs
Event arguments for events that request an URL to a QR code.
Definition: GetQrCodeUrlEventArgs.cs:9

Waher.Things.Metering.GetQrCodeUrlEventArgs.Text
string Text
Text to encode.
Definition: GetQrCodeUrlEventArgs.cs:26

Waher.Things.Metering.MeteringTopology
Defines the Metering Topology data source. This data source contains a tree structure of persistent r...
Definition: MeteringTopology.cs:28

Waher.Things.Metering.MeteringTopology.DeleteOldEvents
static async Task< int > DeleteOldEvents(TimeSpan MaxAge)
Deletes old data source events.
Definition: MeteringTopology.cs:295

Waher.Things.Metering.MeteringTopology.SourceID
const string SourceID
Source ID for the metering topology data source.
Definition: MeteringTopology.cs:32

Waher.Things.SensorData.Field
Base class for all sensor data fields.
Definition: Field.cs:20

Waher.Things.SourceEvents.GetDataSourcesEventArgs
Event arguments for events collecting data sources.
Definition: GetDataSourcesEventArgs.cs:10

Waher.Things.SourceEvents.GetDataSourcesEventArgs.Sources
IDataSource[] Sources
Added sources.
Definition: GetDataSourcesEventArgs.cs:48

Waher.Things.ThingReference.IsEmpty
bool IsEmpty
If the reference is an empty reference.
Definition: ThingReference.cs:116

Waher.Events.IDisposableAsync
Interface for asynchronously disposable objects.
Definition: IDisposableAsync.cs:10

Waher.Events.IDisposableAsync.DisposeAsync
Task DisposeAsync()
Disposes of the object, asynchronously.

Waher.Events.IEventSink
Interface for all event sinks.
Definition: IEventSink.cs:9

Waher.IoTGateway.Setup.ISystemConfiguration
Interface for system configurations. The gateway will scan all module for system configuration classe...
Definition: ISystemConfiguration.cs:13

Waher.Networking.HTTP.ContentEncodings.IContentEncoding
Interface for content encodings in HTTP transfers.
Definition: IContentEncoding.cs:10

Waher.Networking.HTTP.ContentEncodings.IContentEncoding.ConfigureSupport
void ConfigureSupport(bool Dynamic, bool Static)
Configures support for the algorithm.

Waher.Networking.ICommunicationLayer
Interface for observable classes implementing communication protocols.
Definition: ICommunicationLayer.cs:12

Waher.Networking.Sniffers.ISniffer
Interface for sniffers. Sniffers can be added to ICommunicationLayer classes to eavesdrop on communic...
Definition: ISniffer.cs:10

Waher.Networking.Sniffers.ISnifferSet
Interface for sets of sniffers.
Definition: ISnifferSet.cs:9

Waher.Networking.XMPP.PEP.IPersonalEvent
Interface for personal event objects.
Definition: IPersonalEvent.cs:11

Waher.Persistence.IDatabaseProvider
Interface for database providers that can be plugged into the static Database class.
Definition: IDatabaseProvider.cs:27

Waher.Persistence.IDatabaseProvider.Flush
Task Flush()
Persists any pending changes.

Waher.Persistence.IDatabaseProvider.Start
Task Start()
Called when processing starts.

Waher.Persistence.IDatabaseProvider.Stop
Task Stop()
Called when processing ends.

Waher.Persistence.ILedgerProvider.Start
Task Start()
Called when processing starts.

Waher.Persistence.IPersistentDictionary
Persistent dictionary that can contain more entries than possible in the internal memory.
Definition: IPersistentDictionary.cs:11

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.AddAsync
Task AddAsync(string key, object value)
Adds an element with the provided key and value to the System.Collections.Generic....

Waher.Runtime.Inventory.IModule
Interface for late-bound modules loaded at runtime.
Definition: IModule.cs:9

Waher.Security.IAuthorization
Basic authorization interface for objects of type T .
Definition: IAuthorization.cs:7

Waher.Security.ITlsCertificateEndpoint
Interface for Mutual TLS (mTLS) Clients or TLS servers.
Definition: ITlsCertificateEndpoint.cs:9

Waher.Security.IUser
Basic interface for a user.
Definition: IUser.cs:7

Waher.Things.IDataSource
Interface for datasources that are published through the concentrator interface.
Definition: IDataSource.cs:14

Waher.Things.IThingReference
Interface for thing references.
Definition: IThingReference.cs:18

_
Definition: ImplTypes.g.cs:58

System.Collections.Generic
Definition: ImplTypes.g.cs:4970

System.Net.Sockets
Definition: ImplTypes.g.cs:19120

System.Net
Definition: ImplTypes.g.cs:19120

System.Runtime.InteropServices
Definition: Adapters.g.cs:58

System.Security.Cryptography
Definition: SafeTypes.g.cs:3565

System
Definition: Adapters.g.cs:58

Waher.Content.Emoji.Emoji1
Definition: LocalEmojiFiles.cs:13

Waher.Content.Emoji.Emoji1.Emoji1SourceFileType
Emoji1SourceFileType
What source files to use when displaying emoji.
Definition: LocalEmojiFiles.cs:18

Waher.Content.Html
Definition: CDATA.cs:6

Waher.Content.Images
Definition: EXIF.cs:9

Waher.Content.Markdown.GraphViz
Definition: GraphViz.cs:30

Waher.Content.Markdown.Layout2D
Definition: Layout2DXmlToImageConverter.cs:19

Waher.Content.Markdown.PlantUml
Definition: PlantUml.cs:32

Waher.Content.Markdown.Rendering
Definition: GraphContent.cs:8

Waher.Content.Markdown.Web.WebScript
Definition: WsCodec.cs:10

Waher.Content.Markdown.Web
Definition: MarkdownToHtmlConverter.cs:17

Waher.Content.Markdown
Definition: ConsolidatedTable.cs:11

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.Zip
Definition: Crc32.cs:2

Waher.Content
Definition: Array.cs:6

Waher.Content.ToString
delegate string ToString(IElement Element)
Delegate for callback methods that convert an element value to a string.

Waher.Events.Files
Definition: EventExtensions.cs:9

Waher.Events.Filter
Definition: CustomEventFilter.cs:4

Waher.Events.Filter.FromEventLevel
FromEventLevel
Allows events from a certain level.
Definition: EventLevelFilter.cs:7

Waher.Events.MQTT
Definition: EventEventArgs.cs:5

Waher.Events.Persistence
Definition: PersistedEvent.cs:5

Waher.Events.Pipe
Definition: CustomFragmentEventArgs.cs:5

Waher.Events.Queue
Definition: EventQueue.cs:8

Waher.Events.Socket
Definition: CustomFragmentEventArgs.cs:5

Waher.Events.Syslog
Definition: SyslogClient.cs:16

Waher.Events.Syslog.SyslogEventSeparation
SyslogEventSeparation
How events are separated in the Syslog event stream.
Definition: SyslogEventSeparation.cs:7

Waher.Events.WebHook
Definition: WebHookEventSink.cs:13

Waher.Events.XMPP
Definition: EventEventArgs.cs:4

Waher.Events
Definition: ConsoleEventSink.cs:8

Waher.Events.EventHandlerAsync
delegate Task EventHandlerAsync(object Sender, EventArgs e)
Asynchronous version of EventArgs.

Waher.Events.EventLevel
EventLevel
Event level.
Definition: EventLevel.cs:7

Waher.Events.EventType
EventType
Type of event.
Definition: EventType.cs:7

Waher.Groups
Definition: MeteringGroup.cs:7

Waher.IoTGateway.Cssx
Definition: CssxDecoder.cs:9

Waher.IoTGateway.Events
Definition: AlertNotifier.cs:10

Waher.IoTGateway.Exceptions
Definition: Analyze.cs:9

Waher.IoTGateway.Setup.Legal
Definition: ContractSignatureRequest.cs:10

Waher.IoTGateway.Setup
Definition: App.xaml.cs:22

Waher.IoTGateway.WebResources.ExportFormats
Definition: BinaryExportFormat.cs:12

Waher.IoTGateway.WebResources
Definition: DeleteExport.cs:11

Waher.IoTGateway
Definition: App.xaml.cs:23

Waher.IoTGateway.GetRegistryMetaDataEventHandler
delegate Task< MetaDataTag[]> GetRegistryMetaDataEventHandler(MetaDataTag[] MetaData)
Delegate for events requesting meta data for registration.

Waher.IoTGateway.GetDatabaseProviderEventHandler
delegate Task< IDatabaseProvider > GetDatabaseProviderEventHandler(XmlElement Definition)
Delegate for callback methods used for the creation of database providers.

Waher.IoTGateway.RegistrationEventHandler
delegate Task RegistrationEventHandler(MetaDataTag[] MetaData, RegistrationEventArgs e)
Delegate for registration callback methods.

Waher.Jobs
Definition: GroupReference.cs:10

Waher.Networking.CoAP
Definition: CoapCode.cs:2

Waher.Networking.HTTP.Authentication
Definition: AnonymousAuthentication.cs:7

Waher.Networking.HTTP.ContentEncodings
Definition: DeflateContentEncoding.cs:5

Waher.Networking.HTTP.HeaderFields
Definition: AcceptRecord.cs:4

Waher.Networking.HTTP.Mcp.Model
Definition: Annotations.cs:6

Waher.Networking.HTTP.OAuth
Definition: AuthorizationServerMetaData.cs:9

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.MQTT
Definition: BinaryInput.cs:7

Waher.Networking.MQTT.MqttQualityOfService
MqttQualityOfService
MQTT Quality of Service level.
Definition: MqttQualityOfService.cs:11

Waher.Networking.PeerToPeer
Definition: GameDataEventArgs.cs:7

Waher.Networking.Sniffers
Definition: BinaryPresentationMethod.cs:2

Waher.Networking.Sniffers.LineEnding
LineEnding
Type of line ending.
Definition: LineEnding.cs:7

Waher.Networking.Sniffers.BinaryPresentationMethod
BinaryPresentationMethod
How binary data is to be presented.
Definition: BinaryPresentationMethod.cs:7

Waher.Networking.XMPP.Avatar
Definition: Avatar.cs:6

Waher.Networking.XMPP.Concentrator
Definition: ConcentratorClient.cs:20

Waher.Networking.XMPP.Contracts.EventArguments
Definition: ClientMessageEventArgs.cs:4

Waher.Networking.XMPP.Contracts
Definition: AltitudeUse.cs:2

Waher.Networking.XMPP.Control
Definition: ControlClient.cs:14

Waher.Networking.XMPP.Events
Definition: AuthorityEventArgs.cs:4

Waher.Networking.XMPP.Geo
Definition: GeoClient.cs:12

Waher.Networking.XMPP.HTTPX
Definition: Aes256Getter.cs:12

Waher.Networking.XMPP.MUC
Definition: Enumerations.cs:6

Waher.Networking.XMPP.Mail
Definition: EmbeddedObjectReference.cs:6

Waher.Networking.XMPP.P2P.SOCKS5
Definition: Command.cs:2

Waher.Networking.XMPP.PEP.Events
Definition: PersonalEventNotificationEventArgs.cs:4

Waher.Networking.XMPP.PEP
Definition: PersonalEventNotificationEventArgs.cs:4

Waher.Networking.XMPP.Provisioning.Events
Definition: CanControlEventArgs.cs:11

Waher.Networking.XMPP.Provisioning
Definition: CachedQuery.cs:5

Waher.Networking.XMPP.PubSub.Events
Definition: AffiliationNotificationEventArgs.cs:4

Waher.Networking.XMPP.PubSub
Definition: Affiliation.cs:2

Waher.Networking.XMPP.Sensor
Definition: ApprovedReadoutParameters.cs:5

Waher.Networking.XMPP.Software
Definition: PackageDeleteEventArgs.cs:4

Waher.Networking.XMPP.Synchronization
Definition: ClockSourceEventArgs.cs:4

Waher.Networking.XMPP
Definition: Avatar.cs:6

Waher.Networking.XMPP.QoSLevel
QoSLevel
Quality of Service Level for asynchronous messages. Support for QoS Levels must be supported by the r...
Definition: QoSLevel.cs:8

Waher.Networking.XMPP.SubscriptionState
SubscriptionState
State of a presence subscription.
Definition: RosterItem.cs:16

Waher.Networking.XMPP.MessageType
MessageType
Type of message received.
Definition: MessageType.cs:7

Waher.Networking.XMPP.XmppState
XmppState
State of XMPP connection.
Definition: XmppState.cs:7

Waher.Networking
Definition: Program.cs:9

Waher.Networking.ClientCertificates
ClientCertificates
Client Certificate Options
Definition: ClientCertificates.cs:7

Waher.Output
Definition: ISensorDataOutput.cs:6

Waher.Persistence.Filters
Definition: Filter.cs:2

Waher.Persistence
Definition: Bookmark.cs:4

Waher.Processors
Definition: ISensorDataProcessor.cs:6

Waher.Reports.Files
Definition: ExecuteReportFileCommand.cs:13

Waher.Reports
Definition: ExecuteReportFileCommand.cs:13

Waher.Runtime.Cache
Definition: Cache.cs:10

Waher.Runtime.Collections
Definition: ChunkedList.cs:9

Waher.Runtime.IO
Definition: Certificates.cs:7

Waher.Runtime.Inventory.Loader
Definition: TypesLoader.cs:9

Waher.Runtime.Inventory
Definition: TypesLoader.cs:9

Waher.Runtime.Language
Definition: ITranslator.cs:4

Waher.Runtime.Profiling
Definition: Benchmarker1D.cs:8

Waher.Runtime.Profiling.TimeUnit
TimeUnit
Options for presenting time in reports.
Definition: Profiler.cs:17

Waher.Runtime.Profiling.ProfilerThreadType
ProfilerThreadType
Type of profiler thread.
Definition: ProfilerThread.cs:16

Waher.Runtime.ServiceRegistration
Definition: Annotation.cs:6

Waher.Runtime.Settings
Definition: EnvironmentSettings.cs:7

Waher.Runtime.Threading.Sync
Definition: AsyncMutex.cs:6

Waher.Runtime.Threading
Definition: AsyncMutex.cs:6

Waher.Runtime.Timing
Definition: ScheduledEvent.cs:6

Waher.Script.Graphs
Definition: CanvasGraph.cs:12

Waher.Script.Model
Definition: BinaryBooleanOperator.cs:8

Waher.Script
Definition: App.xaml.cs:4

Waher.Security.CallStack
Definition: ApproveAssembly.cs:4

Waher.Security.JWT
Definition: AudienceEventArgs.cs:4

Waher.Security.LoginMonitor
Definition: AnnotateEndpointEventArgs.cs:6

Waher.Security.SHA3
Definition: Keccak1600.cs:6

Waher.Security.Users
Definition: LoginResult.cs:4

Waher.Security.WAF
Definition: IEndpointLocalization.cs:7

Waher.Security
Definition: AcmeAccount.cs:8

Waher.Things.Authorities
Definition: Authority.cs:4

Waher.Things.Http
Definition: ExternalWebNode.cs:8

Waher.Things.Metering
Definition: ClearMessages.cs:10

Waher.Things.SensorData
Definition: BooleanField.cs:6

Waher.Things.SourceEvents
Definition: GetDataSourcesEventArgs.cs:5

Waher.Things
Definition: AnalogInput.cs:15

Waher.Content.Duration
Represents a duration value, as defined by the xsd:duration data type: http://www....
Definition: Duration.cs:14

Waher.Content.Duration.Zero
static readonly Duration Zero
Zero value
Definition: Duration.cs:577