WebSocketClientResource.cs

using System;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Events;
using Waher.Networking.HTTP.WebSockets;
 
namespace Waher.Networking.XMPP.Server.WS
{
    public class WebSocketClientResource : WebSocketListener
    {
        private readonly XmppServer xmppServer;
 
        public WebSocketClientResource(XmppServer XmppServer, string ResourceName)
            : base(ResourceName, false, 1024 * 1024, 1024 * 1024, "xmpp")
        {
            this.xmppServer = XmppServer;
 
            this.Connected += this.WebSocketClientResource_Connected;
        }
 
        private Task WebSocketClientResource_Connected(object Sender, WebSocketEventArgs e)
        {
            e.Socket.Tag = new WebSocketSession(this, e.Socket, StripPort(e.Socket.HttpRequest.RemoteEndPoint), this.xmppServer)
            {
                streamId = this.xmppServer.GetRandomHexString(16)
            };
 
            e.Socket.Closed += this.Socket_Closed;
            e.Socket.TextReceived += this.Socket_TextReceived;
            e.Socket.Heartbeat += this.Socket_Heartbeat;
            e.Socket.Disposed += this.Socket_Disposed;
 
            return Task.CompletedTask;
        }
 
        private Task Socket_Heartbeat(object Sender, WebSocketEventArgs e)
        {
            WebSocketSession Session = (WebSocketSession)e.Socket.Tag;
            Session.TouchConnection();
            return Task.CompletedTask;
        }
 
        private async Task Socket_Disposed(object Sender, EventArgs e)
        {
            if (Sender is WebSocket WebSocket && WebSocket.Tag is WebSocketSession WebSocketSession)
                await WebSocketSession.DisposeAsync();
        }
 
        private void StreamError(WebSocketTextEventArgs e, string ErrorXml, WebSocketCloseStatus Code, string Reason)
        {
            WebSocketSession Session = (WebSocketSession)e.Socket.Tag;
 
            if (!Session.streamOpen)
                this.SendOpen(Session);
 
            e.Socket.Send("<error xmlns=\"http://etherx.jabber.org/streams\">" + 
                ErrorXml + "</error>");
 
            e.Socket.Close(Code, Reason);
        }
 
        private void StreamErrorInvalidXml(WebSocketTextEventArgs e)
        {
            this.StreamError(e, "<invalid-xml xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>", 
                WebSocketCloseStatus.NotAcceptable, "Invalid XML in request.");
        }
 
        private void StreamErrorHostUnknown(WebSocketTextEventArgs e)
        {
            this.StreamError(e, "<host-unknown xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>",
                WebSocketCloseStatus.NotAcceptable, "Host unknown.");
        }
 
        private Task SendOpen(WebSocketSession Session)
        {
            Session.streamOpen = true;
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<open xmlns=\"");
            Xml.Append(FramingNamespace);
            Xml.Append("\" from=\"");
            Xml.Append(Session.To);
            Xml.Append("\" id=\"");
            Xml.Append(Session.streamId);
            Xml.Append("\" xml:lang=\"en\" version=\"1.0\"/>");
 
            return Session.webSocket.Send(Xml.ToString());
        }
 
        private async Task Socket_TextReceived(object Sender, WebSocketTextEventArgs e)
        {
            try
            {
                WebSocketSession Session = (WebSocketSession)e.Socket.Tag;
 
                if (!Session.streamOpen)
                {
                    XmlDocument Doc = new XmlDocument()
                    {
                        PreserveWhitespace = true
                    };
                    XmlElement Body;
 
                    try
                    {
                        Doc.LoadXml(e.Payload);
                    }
                    catch (Exception)
                    {
                        this.StreamErrorInvalidXml(e);
                        return;
                    }
 
                    Body = Doc.DocumentElement;
                    if (Body is null)
                    {
                        this.StreamErrorInvalidXml(e);
                        return;
                    }
 
                    if (Body.LocalName != "open" || Body.NamespaceURI != FramingNamespace)
                    {
                        this.StreamErrorInvalidXml(e);
                        return;
                    }
 
                    foreach (XmlAttribute Attribute in Body.Attributes)
                    {
                        switch (Attribute.Name)
                        {
                            case "from":
                                Session.From = Attribute.Value;
                                break;
 
                            case "to":
                                Session.To = Attribute.Value;
                                break;
 
                            case "version":
                                if (!CommonTypes.TryParse(Attribute.Value, out double Version) || Version < 1.0)
                                {
                                    this.StreamErrorInvalidXml(e);
                                    return;
                                }
                                Session.Version = Version;
                                break;
 
                            case "xml:lang":
                                Session.Language = Attribute.Value;
                                break;
 
                            default:
                                break;
                        }
                    }
 
                    if (!this.xmppServer.IsServerDomain(Session.To, true) && 
                        (!string.IsNullOrEmpty(this.xmppServer.Domain) || 
                        !IPAddress.TryParse(Session.To, out IPAddress _)))
                    {
                        this.StreamErrorHostUnknown(e);
                        return;
                    }
 
                    await this.SendOpen(Session);
 
                    await Session.InitStream();
                }
                else
                    await Session.ProcessFragment(e.Payload);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async Task Socket_Closed(object Sender, WebSocketClosedEventArgs e)
        {
            if (e.Socket.Tag is WebSocketSession WebSocketSession)
                await WebSocketSession.DisposeAsync();
        }
 
        public const string FramingNamespace = "urn:ietf:params:xml:ns:xmpp-framing";
 
        private static string StripPort(string s)
        {
            int i = s.LastIndexOf(':');
            if (i < 0)
                return s;
            else
                return s.Substring(0, i);
        }
 
    }
}