WebSocketSession.cs

using System;
using System.Net.Security;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Events;
using Waher.Networking.HTTP.WebSockets;
using Waher.Networking.SASL;
using Waher.Networking.Sniffers;
using Waher.Persistence;
 
namespace Waher.Networking.XMPP.Server.WS
{
    public class WebSocketSession : ClientConnection
    {
        internal readonly WebSocketClientResource webSocketResource;
        internal WebSocket webSocket;
        private CaseInsensitiveString from;
        private CaseInsensitiveString to;
        private string language;
        private double version;
 
        private readonly string remoteEndpoint = string.Empty;
        internal string streamId = null;
        internal bool streamOpen = false;
 
        public WebSocketSession(WebSocketClientResource WebSocketResource, WebSocket WebSocket, string RemoteEndpoint,
            XmppServer Server, params ISniffer[] Sniffers)
            : base(Server, XmppConnectionState.StreamNegotiation, Sniffers)
        {
            this.webSocketResource = WebSocketResource;
            this.webSocket = WebSocket;
            this.remoteEndpoint = RemoteEndpoint;
        }
 
        public override string Binding => "Web-Socket";
 
        public double Version
        {
            get => this.version;
            internal set => this.version = value;
        }
 
        public CaseInsensitiveString From
        {
            get => this.from;
            internal set => this.from = value;
        }
 
        public CaseInsensitiveString To
        {
            get => this.to;
            internal set => this.to = value;
        }
 
        public string Language
        {
            get => this.language;
            internal set => this.language = value;
        }
 
        public bool IsBound
        {
            get => this.isBound;
            internal set => this.isBound = value;
        }
 
        public override string RemoteEndpoint => this.remoteEndpoint;
 
        public override string Protocol => "XMPP (WS)";
 
        public override async Task DisposeAsync()
        {
            if (!this.disposed)
            {
                await this.SetState(XmppConnectionState.Offline);
 
                if (this.isBound && !(this.Server is null))
                {
                    this.isBound = false;
                    await this.ProcessFragment("<presence type=\"unavailable\" xmlns=\"jabber:client\"/>");
                    this.Server?.ConnectionClosed(this);
                }
 
                this.webSocket?.Close();
                this.webSocket = null;
 
                await base.DisposeAsync();
            }
        }
 
        public override async Task<bool> BeginWrite(string Xml, EventHandlerAsync<DeliveryEventArgs> Callback, object State)
        {
            if (!this.disposed)
            {
                if (string.IsNullOrEmpty(Xml))
                    await Callback.Raise(this, new DeliveryEventArgs(State, true));
                else if (!(this.webSocket is null))
                {
                    await this.webSocket.Send(Xml, false, Callback, State);
                    await this.TransmitText(Xml);
                }
            }
 
            return true;
        }
 
        public override Task<bool> StreamError(string ErrorXml, string Reason)
        {
            return this.ToError("<error xmlns=\"http://etherx.jabber.org/streams\">" + ErrorXml + "</error>", Reason);
        }
 
        private async Task<bool> ToError(string ErrorXml, string Reason)
        {
            Log.Error("Terminating session. " + Reason, this.FullJid);
 
            if (string.IsNullOrEmpty(ErrorXml))
            {
                await this.SetState(XmppConnectionState.Error);
                await this.DisposeAsync();
 
                return false;
            }
            else
            {
                return await this.BeginWrite(ErrorXml, async (Sender, e) =>
                {
                    await this.SetState(XmppConnectionState.Error);
                    await this.DisposeAsync();
                }, null);
            }
        }
 
        internal void TouchConnection()
        {
            try
            {
                if (!string.IsNullOrEmpty(this.fullJid))
                    this.server.TouchClientConnection(this.fullJid);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        internal async Task<bool> ProcessFragment(string Xml)
        {
            XmlDocument Doc;
 
            try
            {
                if (!string.IsNullOrEmpty(this.fullJid))
                    this.server.TouchClientConnection(this.fullJid);
 
                await this.ReceiveText(Xml);
 
                if (Xml.StartsWith("</"))
                {
                    await this.Information("Terminating session on client request.");
 
                    return await this.BeginWrite("</stream:stream>", async (Sender, e) =>
                    {
                        await this.SetState(XmppConnectionState.Offline);
                        await this.DisposeAsync();
                    }, null);
                }
                else
                {
                    Doc = new XmlDocument()
                    {
                        PreserveWhitespace = true
                    };
                    Doc.LoadXml("<stream:stream xmlns:stream=\"http://etherx.jabber.org/streams\" xmlns=\"jabber:client\">" +
                        Xml + "</stream:stream>");
 
                    XmlElement Root = Doc.DocumentElement;
                    XmlElement StanzaElement = null;
 
                    foreach (XmlNode N in Root.ChildNodes)
                    {
                        if (N is XmlElement E)
                        {
                            StanzaElement = E;
                            break;
                        }
                    }
 
                    if (!(StanzaElement is null))
                    {
                        Stanza Stanza = new Stanza(Root, StanzaElement, StanzaElement.InnerXml);
                        return await this.ProcessStanza(Stanza);
                    }
                }
            }
            catch (Exception ex)
            {
                await this.Exception(ex);
                return await this.StreamError("<bad-format xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", ex.Message);
            }
 
            return true;
        }
 
        protected override SslStream GetSslStream()
        {
            return this.webSocket.ClientConnection.Stream as SslStream;
        }
 
        protected override async Task<bool> ProcessBindingSpecificStanza(Stanza Stanza, XmlElement StanzaElement)
        {
            switch (StanzaElement.LocalName)
            {
                case "open":
                    if (StanzaElement.NamespaceURI != WebSocketClientResource.FramingNamespace)
                        return await this.StreamErrorInvalidNamespace();
 
                    await this.InitStream();
                    break;
 
                case "close":
                    if (StanzaElement.NamespaceURI != WebSocketClientResource.FramingNamespace)
                        return await this.StreamErrorInvalidNamespace();
 
                    string Tx = "<close xmlns='" + WebSocketClientResource.FramingNamespace + "'/>";
 
                    this.webSocket?.Send(Tx, false, async (Sender, e) =>
                    {
                        await this.DisposeAsync();
                    }, null);
 
                    await this.TransmitText(Tx);
                    break;
 
                default:
                    if (!await this.StreamError("<unsupported-stanza-type xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", "Unsupported stanza: " + StanzaElement.LocalName))
                        return false;
                    break;
            }
 
            return true;
        }
 
        internal async Task InitStream()
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append("<features xmlns=\"http://etherx.jabber.org/streams\">");
 
            if (!this.isAuthenticated)
            {
                await this.SetState(XmppConnectionState.Authenticating);
 
                sb.Append("<mechanisms xmlns='" + XmppServer.SaslNamespace + "'>");
 
                SslStream SslStream = this.webSocket.ClientConnection.Stream as SslStream;
                foreach (IAuthenticationMechanism Mechanism in XmppServer.mechanisms)
                {
                    if (Mechanism.Allowed(SslStream))
                    {
                        sb.Append("<mechanism>");
                        sb.Append(Mechanism.Name);
                        sb.Append("</mechanism>");
                    }
                }
 
                sb.Append("</mechanisms>");
 
                if (await this.server.CanRegister(this))
                    sb.Append("<register xmlns='http://jabber.org/features/iq-register'/>");
            }
            else if (!this.isBound)
            {
                await this.SetState(XmppConnectionState.Binding);
 
                sb.Append("<bind xmlns='" + XmppClientConnection.BindNamespace + "'/>");
                sb.Append("<session xmlns='urn:ietf:params:xml:ns:xmpp-session'/>");
            }
 
            sb.Append("</features>");
 
            string Tx = sb.ToString();
            await this.webSocket.Send(Tx);
            await this.TransmitText(Tx);
        }
 
        public override bool CheckLive()
        {
            return !this.disposed && this.State != XmppConnectionState.Error && this.State != XmppConnectionState.Offline && this.webSocket.CheckLive();
        }
 
    }
}