BoshWebClientResource.cs

using System;
using System.Net.Security;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Runtime.Cache;
using Waher.Runtime.IO;
using Waher.Persistence;
 
namespace Waher.Networking.XMPP.Server.BOSH
{
    public class BoshWebClientResource : HttpAsynchronousResource, IHttpPostMethod, IHttpGetMethod
    {
        private const int MaxSecondsIdle = 90;
 
        private readonly static Cache<string, BoshSession> sessions = GetCache();
 
        private readonly XmppServer xmppServer;
        private readonly HttpServer httpServer;
 
        public BoshWebClientResource(XmppServer XmppServer, HttpServer HttpServer, string ResourceName)
            : base(ResourceName)
        {
            this.xmppServer = XmppServer;
            this.httpServer = HttpServer;
        }
 
        private static Cache<string, BoshSession> GetCache()
        {
            Cache<string, BoshSession> Result = new Cache<string, BoshSession>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromSeconds(MaxSecondsIdle), true);
 
            Result.Removed += Result_Removed;
 
            return Result;
        }
 
        private static async Task Result_Removed(object Sender, CacheItemEventArgs<string, BoshSession> e)
        {
            try
            {
                e.Value.Removed = true;
                await e.Value.DisposeAsync();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public const string HttpBindNamespace = "http://jabber.org/protocol/httpbind";
 
        public bool AllowsPOST => true;
 
        public bool AllowsGET => true;
 
        public override bool HandlesSubPaths => true;
 
        public override bool UserSessions => false;
 
        public Task GET(HttpRequest Request, HttpResponse Response)
        {
            string Xml = System.Web.HttpUtility.UrlDecode(Request.Header.QueryString);
            if (string.IsNullOrEmpty(Xml))
                throw new BadRequestException();
 
            Response.SetHeader("Cache-Control", "max-age=0, no-cache, no-store");
 
            this.Process(Xml, Request, Response);
 
            return Task.CompletedTask;
        }
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            // Content type in request header cannot be trusted. Content should be assumed to be UTF-8 encoded XML.
 
            long l = Request.DataStream.Length;
            if (l > int.MaxValue)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            int Len = (int)l;
            byte[] Data = new byte[Len];
            Request.DataStream.Position = 0;
            Request.DataStream.ReadAll(Data, 0, Len);
            
            string Xml = Encoding.UTF8.GetString(Data);
            this.Process(Xml, Request, Response);
        }
 
        private async void Process(string Xml, HttpRequest Request, HttpResponse Response)
        {
            try
            {
                await this.ProcessFragment(Xml, Request, Response);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async Task<bool> ProcessFragment(string Xml, HttpRequest Request, HttpResponse Response)
        {
            string Name;
            int i, c;
            int State = 5;
            int Depth = 0;
            int Delta;
            int Start = 0;
            char ch;
            bool HasNamespace = false;
 
            c = Xml.Length;
            for (i = 0; i < c; i++)
            {
                ch = Xml[i];
 
                switch (State)
                {
                    case 5: // Waiting for start element.
                        if (ch == '<')
                            State++;
                        break;
 
                    case 6: // Second character in tag
                        if (ch == '/')
                            State++;
                        else if (ch == '!')
                            State = 13;
                        else
                            State += 2;
                        break;
 
                    case 7: // Waiting for end of closing tag
                        if (ch == '>')
                        {
                            Depth--;
                            if (Depth < 0)
                            {
                                await this.BoshError(Response, "Invalid Request");
                                return false;
                            }
                            else
                                State = 5;
                        }
                        break;
 
                    case 8: // Wait for end of start tag
                        if (ch == '>' || ch == '/')
                        {
                            if (Depth == 1 && !HasNamespace)
                            {
                                Name = " xmlns='" + XmppClientConnection.C2SNamespace + "'";
                                Xml = Xml.Insert(i, Name);
                                Delta = Name.Length;
                                i += Delta;
                                c += Delta;
                            }
 
                            if (ch == '>')
                            {
                                Depth++;
                                State = 5;
                            }
                            else
                                State++;
                        }
                        else if (ch <= ' ')
                        {
                            State += 2;
                            Start = i + 1;
                            HasNamespace = false;
                        }
                        break;
 
                    case 9: // Check for end of childless tag.
                        if (ch == '>')
                            State = 5;
                        else
                            State--;
                        break;
 
                    case 10:    // Check for attributes.
                        if (ch == '>' || ch == '/')
                        {
                            if (Depth == 1 && !HasNamespace)
                            {
                                Name = " xmlns='" + XmppClientConnection.C2SNamespace + "'";
                                Xml = Xml.Insert(i, Name);
                                Delta = Name.Length;
                                i += Delta;
                                c += Delta;
                            }
 
                            if (ch == '>')
                            {
                                Depth++;
                                State = 5;
                            }
                            else
                                State--;
                        }
                        else if (ch == '"')
                            State++;
                        else if (ch == '\'')
                            State += 2;
                        else if (ch == '=')
                        {
                            if (Depth == 1)
                            {
                                Name = Xml[Start..i];
                                if (Name == "xmlns")
                                    HasNamespace = true;
                            }
                        }
                        else if (ch <= ' ')
                            Start = i + 1;
                        break;
 
                    case 11:    // Double quote attribute.
                        if (ch == '"')
                            State--;
                        break;
 
                    case 12:    // Single quote attribute.
                        if (ch == '\'')
                            State -= 2;
                        break;
 
                    case 13:    // Third character in start of comment
                        if (ch == '-')
                            State++;
                        else if (ch == '[')
                            State = 18;
                        else
                        {
                            await this.BoshError(Response, "Invalid Request");
                            return false;
                        }
                        break;
 
                    case 14:    // Fourth character in start of comment
                        if (ch == '-')
                            State++;
                        else
                        {
                            await this.BoshError(Response, "Invalid Request");
                            return false;
                        }
                        break;
 
                    case 15:    // In comment
                        if (ch == '-')
                            State++;
                        break;
 
                    case 16:    // Second character in end of comment
                        if (ch == '-')
                            State++;
                        else
                            State--;
                        break;
 
                    case 17:    // Third character in end of comment
                        if (ch == '>')
                            State = 5;
                        else
                            State -= 2;
                        break;
 
                    case 18:    // Fourth character in start of CDATA
                        if (ch == 'C')
                            State++;
                        else
                        {
                            await this.BoshError(Response, "Invalid Request");
                            return false;
                        }
                        break;
 
                    case 19:    // Fifth character in start of CDATA
                        if (ch == 'D')
                            State++;
                        else
                        {
                            await this.BoshError(Response, "Invalid Request");
                            return false;
                        }
                        break;
 
                    case 20:    // Sixth character in start of CDATA
                        if (ch == 'A')
                            State++;
                        else
                        {
                            await this.BoshError(Response, "Invalid Request");
                            return false;
                        }
                        break;
 
                    case 21:    // Seventh character in start of CDATA
                        if (ch == 'T')
                            State++;
                        else
                        {
                            await this.BoshError(Response, "Invalid Request");
                            return false;
                        }
                        break;
 
                    case 22:    // Eighth character in start of CDATA
                        if (ch == 'A')
                            State++;
                        else
                        {
                            await this.BoshError(Response, "Invalid Request");
                            return false;
                        }
                        break;
 
                    case 23:    // Ninth character in start of CDATA
                        if (ch == '[')
                            State++;
                        else
                        {
                            await this.BoshError(Response, "Invalid Request");
                            return false;
                        }
                        break;
 
                    case 24:    // In CDATA
                        if (ch == ']')
                            State++;
                        break;
 
                    case 25:    // Second character in end of CDATA
                        if (ch == ']')
                            State++;
                        else
                            State--;
                        break;
 
                    case 26:    // Third character in end of CDATA
                        if (ch == '>')
                            State = 5;
                        else if (ch != ']')
                            State -= 2;
                        break;
 
                    default:
                        break;
                }
            }
 
            XmlDocument Doc;
            XmlElement Body;
 
            try
            {
                Doc = XML.ParseXml(Xml, true);
            }
            catch (Exception)
            {
                throw new BadRequestException();
            }
 
            Body = Doc.DocumentElement;
            if (Body is null || Body.LocalName != "body" || Body.NamespaceURI != HttpBindNamespace)
                throw new BadRequestException();
 
            string ContentType = "text/xml; charset=utf-8";
            string Language = "en";
            CaseInsensitiveString From = null;
            CaseInsensitiveString To = null;
            string Sid = null;
            string Key = null;
            string NewKey = null;
            string Echo = null;
            double Version = double.MaxValue;
            long? Rid = null;
            long? Ack = null;
            int Hold = 1;
            int WaitSeconds = 30;
            bool Secure = false;
            bool Terminate = false;
 
            foreach (XmlAttribute Attribute in Body.Attributes)
            {
                switch (Attribute.Name)
                {
                    case "content":
                        ContentType = Attribute.Value;
                        break;
 
                    case "from":
                        From = Attribute.Value;
                        break;
 
                    case "hold":
                        if (!int.TryParse(Attribute.Value, out Hold) || Hold < 0)
                            throw new BadRequestException();
 
                        if (Hold > 5)
                            Hold = 5;
                        break;
 
                    case "rid":
                        if (!long.TryParse(Attribute.Value, out long l) || l < 0)
                            throw new BadRequestException();
                        Rid = l;
                        break;
 
                    case "sid":
                        Sid = Attribute.Value;
                        break;
 
                    case "to":
                        To = Attribute.Value;
                        break;
 
                    case "route":
                        // Ignore.
                        break;
 
                    case "ver":
                        if (!CommonTypes.TryParse(Attribute.Value, out Version) || Version < 1.0)
                            throw new BadRequestException();
                        break;
 
                    case "wait":
                        if (!int.TryParse(Attribute.Value, out WaitSeconds) || Hold <= 0)
                            throw new BadRequestException();
                        break;
 
                    case "ack":
                        if (!long.TryParse(Attribute.Value, out l))
                            throw new BadRequestException();
                        else
                            Ack = l;
                        break;
 
                    case "secure":
                        if (!CommonTypes.TryParse(Attribute.Value, out Secure))
                            throw new BadRequestException();
                        break;
 
                    case "xml:lang":
                        Language = Attribute.Value;
                        break;
 
                    case "type":
                        if (Attribute.Value == "terminate")
                            Terminate = true;
                        break;
 
                    case "key":
                        Key = Attribute.Value;
                        break;
 
                    case "newkey":
                        NewKey = Attribute.Value;
                        break;
 
                    case "echo":
                        Echo = Attribute.Value;
                        break;
 
                    default:
                        break;
                }
            }
 
            Response.ContentType = ContentType;
 
            if (Version > 1.11)
                Version = 1.11;
 
            StringBuilder sb = new StringBuilder();
            BoshSession Session;
 
            if (string.IsNullOrEmpty(Sid))
            {
                if (string.IsNullOrEmpty(To) || !this.xmppServer.IsServerDomain(To, true) || !(Key is null))
                    throw new BadRequestException();
 
                // TODO: Check against spam. Restrict number of active sessions allowed per remote IP
 
                do
                {
                    Sid = this.xmppServer.GetRandomHexString(16);
                }
                while (sessions.ContainsKey(Sid));
 
                if (WaitSeconds > MaxSecondsIdle)
                    WaitSeconds = MaxSecondsIdle;
 
                int PollingSeconds = Math.Min(5, WaitSeconds);
                int Requests = Hold + 1;
 
                Session = new BoshSession(this, Sid, Rid, Version, From, To, Language, Hold, WaitSeconds, PollingSeconds, Requests,
                    Ack.HasValue && Ack.Value != 0, Secure, Request.RemoteEndPoint.RemovePortNumber(), NewKey, this.xmppServer);
                sessions.Add(Sid, Session);
 
                sb.Append("<body wait='");
                sb.Append(WaitSeconds.ToString());
                sb.Append("' inactivity='");
                sb.Append(Math.Max(WaitSeconds / 2, 1).ToString());
                sb.Append("' polling='");
                sb.Append(PollingSeconds.ToString());
                sb.Append("' requests='");
                sb.Append(Requests.ToString());
                sb.Append("' hold='");
                sb.Append(Hold.ToString());
 
                if (Ack.HasValue && Ack.Value != 0 && Rid.HasValue)
                {
                    sb.Append("' ack='");
                    sb.Append(Rid.Value.ToString());
                    Session.RidReturnedLocked(Rid.Value);
                }
 
                // TODO: 'accept' attribute for content encodings.
 
                sb.Append("' sid='");
                sb.Append(XML.Encode(Sid));
                sb.Append("' ver='");
                sb.Append(CommonTypes.Encode(Version));
                sb.Append("' from='");
                sb.Append(XML.Encode(To));
 
                if (!string.IsNullOrEmpty(Echo))
                {
                    sb.Append("' echo='");
                    sb.Append(XML.Encode(Echo));
                }
 
                sb.Append("' xmlns='");
                sb.Append(HttpBindNamespace);
                sb.Append("' xmlns:stream='");
                sb.Append(XmppClientConnection.StreamNamespace);
                sb.Append("'>");
 
                await Session.InitStream(sb, Response.ClientConnection.Stream as SslStream);
 
                sb.Append("</body>");
 
                await this.Return(Response, sb.ToString());
            }
            else
            {
                if (!sessions.TryGetValue(Sid, out Session))
                    throw new NotFoundException();
 
                if (Session.RemoteEndPoint != Request.RemoteEndPoint.RemovePortNumber())
                    throw new ForbiddenException(Request, "Invalid remote endpoint (BOSH)");
 
                if (Session.State == XmppConnectionState.Active && !this.xmppServer.TouchClientConnection(Session.FullJid))
                    throw new NotFoundException();
 
                bool KeyOk;
 
                if (Rid.HasValue)
                    KeyOk = await Session.ProcessStanzasInOrder(Rid.Value, Body, Response.ClientConnection.Stream, Key);
                else
                {
                    KeyOk = Session.CheckNextKey(Key);
                    if (KeyOk)
                        await Session.ProcessStanzas(Body, Response.ClientConnection.Stream);
                }
 
                if (!KeyOk)
                {
                    await this.BoshError(Response, "item-not-found");
                    return false;
                }
 
                if (!(NewKey is null))
                    Session.Key = NewKey;
 
                if (Terminate)
                {
                    Session.Terminated = true;
 
                    foreach (XmlNode N in Body.ChildNodes)
                    {
                        if (N is XmlElement E && E.LocalName == "presence" && XML.Attribute(E, "type") == "unavailable")
                            Session.IsBound = false;
                    }
 
                    await Session.DisposeAsync();
                    return false;
                }
 
                if (Session.Terminated)
                    await Session.DisposeAsync();
                else
                    await Session.RegisterForResponse(XmppServer.Scheduler, Rid, Response, Echo);
            }
 
            return true;
        }
 
        internal Task BoshError(HttpResponse Response, string Condition)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<body type='terminate");
 
            if (!string.IsNullOrEmpty(Condition))
            {
                Xml.Append("' condition='");
                Xml.Append(Condition);
            }
 
            Xml.Append("' xmlns='");
            Xml.Append(HttpBindNamespace);
            Xml.Append("'/>");
 
            return this.Return(Response, Xml.ToString());
        }
 
        internal static void Remove(BoshSession Session)
        {
            sessions.Remove(Session.Sid);
        }
 
        internal async Task Return(HttpResponse Response, string Xml)
        {
            byte[] Bin = Encoding.UTF8.GetBytes(Xml);
 
            Response.ContentLength = Bin.Length;    // Avoid chunked service. (XEP-0124, §5).
 
            try
            {
                await Response.Write(true, Bin);
                await Response.SendResponse();
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message, this.ResourceName, Response.Request.RemoteEndPoint);
                this.httpServer.RequestResponded(Response.Request, 500);
            }
        }
 
    }
}