jellyfin/SocketHttpListener/Net/HttpListenerRequest.cs

using System;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using MediaBrowser.Model.Net;
using MediaBrowser.Model.Services;
using MediaBrowser.Model.Text;
using SocketHttpListener.Primitives;

namespace SocketHttpListener.Net
{
    public sealed class HttpListenerRequest
    {
        string[] accept_types;
        Encoding content_encoding;
        long content_length;
        bool cl_set;
        CookieCollection cookies;
        WebHeaderCollection headers;
        string method;
        Stream input_stream;
        Version version;
        QueryParamCollection query_string; // check if null is ok, check if read-only, check case-sensitiveness
        string raw_url;
        Uri url;
        Uri referrer;
        string[] user_languages;
        HttpListenerContext context;
        bool is_chunked;
        bool ka_set;
        bool? _keepAlive;

        private readonly ITextEncoding _textEncoding;

        internal HttpListenerRequest(HttpListenerContext context, ITextEncoding textEncoding)
        {
            this.context = context;
            _textEncoding = textEncoding;
            headers = new WebHeaderCollection();
            version = HttpVersion.Version10;
        }

        static char[] separators = new char[] { ' ' };

        internal void SetRequestLine(string req)
        {
            string[] parts = req.Split(separators, 3);
            if (parts.Length != 3)
            {
                context.ErrorMessage = "Invalid request line (parts).";
                return;
            }

            method = parts[0];
            foreach (char c in method)
            {
                int ic = (int)c;

                if ((ic >= 'A' && ic <= 'Z') ||
                    (ic > 32 && c < 127 && c != '(' && c != ')' && c != '<' &&
                     c != '<' && c != '>' && c != '@' && c != ',' && c != ';' &&
                     c != ':' && c != '\\' && c != '"' && c != '/' && c != '[' &&
                     c != ']' && c != '?' && c != '=' && c != '{' && c != '}'))
                    continue;

                context.ErrorMessage = "(Invalid verb)";
                return;
            }

            raw_url = parts[1];
            if (parts[2].Length != 8 || !parts[2].StartsWith("HTTP/"))
            {
                context.ErrorMessage = "Invalid request line (version).";
                return;
            }

            try
            {
                version = new Version(parts[2].Substring(5));
                if (version.Major < 1)
                    throw new Exception();
            }
            catch
            {
                context.ErrorMessage = "Invalid request line (version).";
                return;
            }
        }

        void CreateQueryString(string query)
        {
            if (query == null || query.Length == 0)
            {
                query_string = new QueryParamCollection();
                return;
            }

            query_string = new QueryParamCollection();
            if (query[0] == '?')
                query = query.Substring(1);
            string[] components = query.Split('&');
            foreach (string kv in components)
            {
                int pos = kv.IndexOf('=');
                if (pos == -1)
                {
                    query_string.Add(null, WebUtility.UrlDecode(kv));
                }
                else
                {
                    string key = WebUtility.UrlDecode(kv.Substring(0, pos));
                    string val = WebUtility.UrlDecode(kv.Substring(pos + 1));

                    query_string.Add(key, val);
                }
            }
        }

        internal void FinishInitialization()
        {
            string host = UserHostName;
            if (version > HttpVersion.Version10 && (host == null || host.Length == 0))
            {
                context.ErrorMessage = "Invalid host name";
                return;
            }

            string path;
            Uri raw_uri = null;
            if (MaybeUri(raw_url.ToLowerInvariant()) && Uri.TryCreate(raw_url, UriKind.Absolute, out raw_uri))
                path = raw_uri.PathAndQuery;
            else
                path = raw_url;

            if ((host == null || host.Length == 0))
                host = UserHostAddress;

            if (raw_uri != null)
                host = raw_uri.Host;

            int colon = host.LastIndexOf(':');
            if (colon >= 0)
                host = host.Substring(0, colon);

            string base_uri = String.Format("{0}://{1}:{2}",
                (IsSecureConnection) ? (IsWebSocketRequest ? "wss" : "https") : (IsWebSocketRequest ? "ws" : "http"),
                                host, LocalEndPoint.Port);

            if (!Uri.TryCreate(base_uri + path, UriKind.Absolute, out url))
            {
                context.ErrorMessage = WebUtility.HtmlEncode("Invalid url: " + base_uri + path);
                return; return;
            }

            CreateQueryString(url.Query);

            if (version >= HttpVersion.Version11)
            {
                string t_encoding = Headers["Transfer-Encoding"];
                is_chunked = (t_encoding != null && String.Compare(t_encoding, "chunked", StringComparison.OrdinalIgnoreCase) == 0);
                // 'identity' is not valid!
                if (t_encoding != null && !is_chunked)
                {
                    context.Connection.SendError(null, 501);
                    return;
                }
            }

            if (!is_chunked && !cl_set)
            {
                if (String.Compare(method, "POST", StringComparison.OrdinalIgnoreCase) == 0 ||
                    String.Compare(method, "PUT", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    context.Connection.SendError(null, 411);
                    return;
                }
            }

            if (String.Compare(Headers["Expect"], "100-continue", StringComparison.OrdinalIgnoreCase) == 0)
            {
                var output = (HttpResponseStream)context.Connection.GetResponseStream(true);

                var _100continue = _textEncoding.GetASCIIEncoding().GetBytes("HTTP/1.1 100 Continue\r\n\r\n");

                output.InternalWrite(_100continue, 0, _100continue.Length);
            }
        }

        static bool MaybeUri(string s)
        {
            int p = s.IndexOf(':');
            if (p == -1)
                return false;

            if (p >= 10)
                return false;

            return IsPredefinedScheme(s.Substring(0, p));
        }

        //
        // Using a simple block of if's is twice as slow as the compiler generated
        // switch statement.   But using this tuned code is faster than the
        // compiler generated code, with a million loops on x86-64:
        //
        // With "http": .10 vs .51 (first check)
        // with "https": .16 vs .51 (second check)
        // with "foo": .22 vs .31 (never found)
        // with "mailto": .12 vs .51  (last check)
        //
        //
        static bool IsPredefinedScheme(string scheme)
        {
            if (scheme == null || scheme.Length < 3)
                return false;

            char c = scheme[0];
            if (c == 'h')
                return (scheme == "http" || scheme == "https");
            if (c == 'f')
                return (scheme == "file" || scheme == "ftp");

            if (c == 'n')
            {
                c = scheme[1];
                if (c == 'e')
                    return (scheme == "news" || scheme == "net.pipe" || scheme == "net.tcp");
                if (scheme == "nntp")
                    return true;
                return false;
            }
            if ((c == 'g' && scheme == "gopher") || (c == 'm' && scheme == "mailto"))
                return true;

            return false;
        }

        internal static string Unquote(String str)
        {
            int start = str.IndexOf('\"');
            int end = str.LastIndexOf('\"');
            if (start >= 0 && end >= 0)
                str = str.Substring(start + 1, end - 1);
            return str.Trim();
        }

        internal void AddHeader(string header)
        {
            int colon = header.IndexOf(':');
            if (colon == -1 || colon == 0)
            {
                context.ErrorMessage = "Bad Request";
                context.ErrorStatus = 400;
                return;
            }

            string name = header.Substring(0, colon).Trim();
            string val = header.Substring(colon + 1).Trim();
            string lower = name.ToLowerInvariant();
            headers.SetInternal(name, val);
            switch (lower)
            {
                case "accept-language":
                    user_languages = val.Split(','); // yes, only split with a ','
                    break;
                case "accept":
                    accept_types = val.Split(','); // yes, only split with a ','
                    break;
                case "content-length":
                    try
                    {
                        //TODO: max. content_length?
                        content_length = Int64.Parse(val.Trim());
                        if (content_length < 0)
                            context.ErrorMessage = "Invalid Content-Length.";
                        cl_set = true;
                    }
                    catch
                    {
                        context.ErrorMessage = "Invalid Content-Length.";
                    }

                    break;
                case "content-type":
                    {
                        var contents = val.Split(';');
                        foreach (var content in contents)
                        {
                            var tmp = content.Trim();
                            if (tmp.StartsWith("charset"))
                            {
                                var charset = tmp.GetValue("=");
                                if (charset != null && charset.Length > 0)
                                {
                                    try
                                    {

                                        // Support upnp/dlna devices - CONTENT-TYPE: text/xml ; charset="utf-8"\r\n
                                        charset = charset.Trim('"');
                                        var index = charset.IndexOf('"');
                                        if (index != -1) charset = charset.Substring(0, index);

                                        content_encoding = Encoding.GetEncoding(charset);
                                    }
                                    catch
                                    {
                                        context.ErrorMessage = "Invalid Content-Type header: " + charset;
                                    }
                                }

                                break;
                            }
                        }
                    }
                    break;
                case "referer":
                    try
                    {
                        referrer = new Uri(val);
                    }
                    catch
                    {
                        referrer = new Uri("http://someone.is.screwing.with.the.headers.com/");
                    }
                    break;
                case "cookie":
                    if (cookies == null)
                        cookies = new CookieCollection();

                    string[] cookieStrings = val.Split(new char[] { ',', ';' });
                    Cookie current = null;
                    int version = 0;
                    foreach (string cookieString in cookieStrings)
                    {
                        string str = cookieString.Trim();
                        if (str.Length == 0)
                            continue;
                        if (str.StartsWith("$Version"))
                        {
                            version = Int32.Parse(Unquote(str.Substring(str.IndexOf('=') + 1)));
                        }
                        else if (str.StartsWith("$Path"))
                        {
                            if (current != null)
                                current.Path = str.Substring(str.IndexOf('=') + 1).Trim();
                        }
                        else if (str.StartsWith("$Domain"))
                        {
                            if (current != null)
                                current.Domain = str.Substring(str.IndexOf('=') + 1).Trim();
                        }
                        else if (str.StartsWith("$Port"))
                        {
                            if (current != null)
                                current.Port = str.Substring(str.IndexOf('=') + 1).Trim();
                        }
                        else
                        {
                            if (current != null)
                            {
                                cookies.Add(current);
                            }
                            current = new Cookie();
                            int idx = str.IndexOf('=');
                            if (idx > 0)
                            {
                                current.Name = str.Substring(0, idx).Trim();
                                current.Value = str.Substring(idx + 1).Trim();
                            }
                            else
                            {
                                current.Name = str.Trim();
                                current.Value = String.Empty;
                            }
                            current.Version = version;
                        }
                    }
                    if (current != null)
                    {
                        cookies.Add(current);
                    }
                    break;
            }
        }

        // returns true is the stream could be reused.
        internal bool FlushInput()
        {
            if (!HasEntityBody)
                return true;

            int length = 2048;
            if (content_length > 0)
                length = (int)Math.Min(content_length, (long)length);

            byte[] bytes = new byte[length];
            while (true)
            {
                // TODO: test if MS has a timeout when doing this
                try
                {
                    var task = InputStream.ReadAsync(bytes, 0, length);
                    var result = Task.WaitAll(new [] { task }, 1000);
                    if (!result)
                    {
                        return false;
                    }
                    if (task.Result <= 0)
                    {
                        return true;
                    }
                }
                catch (ObjectDisposedException e)
                {
                    input_stream = null;
                    return true;
                }
                catch
                {
                    return false;
                }
            }
        }

        public string[] AcceptTypes
        {
            get { return accept_types; }
        }

        public int ClientCertificateError
        {
            get
            {
                HttpConnection cnc = context.Connection;
                //if (cnc.ClientCertificate == null)
                //    throw new InvalidOperationException("No client certificate");
                //int[] errors = cnc.ClientCertificateErrors;
                //if (errors != null && errors.Length > 0)
                //    return errors[0];
                return 0;
            }
        }

        public Encoding ContentEncoding
        {
            get
            {
                if (content_encoding == null)
                    content_encoding = _textEncoding.GetDefaultEncoding();
                return content_encoding;
            }
        }

        public long ContentLength64
        {
            get { return is_chunked ? -1 : content_length; }
        }

        public string ContentType
        {
            get { return headers["content-type"]; }
        }

        public CookieCollection Cookies
        {
            get
            {
                // TODO: check if the collection is read-only
                if (cookies == null)
                    cookies = new CookieCollection();
                return cookies;
            }
        }

        public bool HasEntityBody
        {
            get { return (content_length > 0 || is_chunked); }
        }

        public QueryParamCollection Headers
        {
            get { return headers; }
        }

        public string HttpMethod
        {
            get { return method; }
        }

        public Stream InputStream
        {
            get
            {
                if (input_stream == null)
                {
                    if (is_chunked || content_length > 0)
                        input_stream = context.Connection.GetRequestStream(is_chunked, content_length);
                    else
                        input_stream = Stream.Null;
                }

                return input_stream;
            }
        }

        public bool IsAuthenticated
        {
            get { return false; }
        }

        public bool IsLocal
        {
            get { return RemoteEndPoint.IpAddress.Equals(IpAddressInfo.Loopback) || RemoteEndPoint.IpAddress.Equals(IpAddressInfo.IPv6Loopback) || LocalEndPoint.IpAddress.Equals(RemoteEndPoint.IpAddress); }
        }

        public bool IsSecureConnection
        {
            get { return context.Connection.IsSecure; }
        }

        public bool KeepAlive
        {
            get
            {
                if (!_keepAlive.HasValue)
                {
                    string header = Headers["Proxy-Connection"];
                    if (string.IsNullOrEmpty(header))
                    {
                        header = Headers["Connection"];
                    }
                    if (string.IsNullOrEmpty(header))
                    {
                        if (ProtocolVersion >= HttpVersion.Version11)
                        {
                            _keepAlive = true;
                        }
                        else
                        {
                            header = Headers["Keep-Alive"];
                            _keepAlive = !string.IsNullOrEmpty(header);
                        }
                    }
                    else
                    {
                        header = header.ToLower(CultureInfo.InvariantCulture);
                        _keepAlive =
                            header.IndexOf("close", StringComparison.OrdinalIgnoreCase) < 0 ||
                            header.IndexOf("keep-alive", StringComparison.OrdinalIgnoreCase) >= 0;
                    }
                }

                return _keepAlive.Value;
            }
        }

        public IpEndPointInfo LocalEndPoint
        {
            get { return context.Connection.LocalEndPoint; }
        }

        public Version ProtocolVersion
        {
            get { return version; }
        }

        public QueryParamCollection QueryString
        {
            get { return query_string; }
        }

        public string RawUrl
        {
            get { return raw_url; }
        }

        public IpEndPointInfo RemoteEndPoint
        {
            get { return context.Connection.RemoteEndPoint; }
        }

        public Guid RequestTraceIdentifier
        {
            get { return Guid.Empty; }
        }

        public Uri Url
        {
            get { return url; }
        }

        public Uri UrlReferrer
        {
            get { return referrer; }
        }

        public string UserAgent
        {
            get { return headers["user-agent"]; }
        }

        public string UserHostAddress
        {
            get { return LocalEndPoint.ToString(); }
        }

        public string UserHostName
        {
            get { return headers["host"]; }
        }

        public string[] UserLanguages
        {
            get { return user_languages; }
        }

        public string ServiceName
        {
            get
            {
                return null;
            }
        }

        private bool _websocketRequestWasSet;
        private bool _websocketRequest;

        /// <summary>
        /// Gets a value indicating whether the request is a WebSocket connection request.
        /// </summary>
        /// <value>
        /// <c>true</c> if the request is a WebSocket connection request; otherwise, <c>false</c>.
        /// </value>
        public bool IsWebSocketRequest
        {
            get
            {
                if (!_websocketRequestWasSet)
                {
                    _websocketRequest = method == "GET" &&
                                        version > HttpVersion.Version10 &&
                                        headers.Contains("Upgrade", "websocket") &&
                                        headers.Contains("Connection", "Upgrade");

                    _websocketRequestWasSet = true;
                }

                return _websocketRequest;
            }
        }

        public Task<ICertificate> GetClientCertificateAsync()
        {
            return Task.FromResult<ICertificate>(null);
        }
    }
}