Inheritance: IDisposable
 public CouchbaseLiteMockTcpListener(ushort port)
 {
     _listener = new HttpListener();
     string prefix = String.Format("http://*:{0}/", port);
     _listener.Prefixes.Add(prefix);
     HttpListener.DefaultServerString = "Couchbase Lite " + Manager.VersionString;
 }
        public void Start(IEnumerable<string> urlPrefixes)
        {
            if (_listener == null)
                _listener = new HttpListener(new SocketSharpLogger(_logger));

            foreach (var prefix in urlPrefixes)
            {
                _logger.Info("Adding HttpListener prefix " + prefix);
                _listener.Prefixes.Add(prefix);
            }

            _listener.Start();

            Task.Factory.StartNew(Listen, TaskCreationOptions.LongRunning);
        }
        public void Start(IEnumerable <string> urlPrefixes)
        {
            if (_listener == null)
            {
                _listener = new WebSocketSharp.Net.HttpListener();
            }

            foreach (var prefix in urlPrefixes)
            {
                _logger.Info("Adding HttpListener prefix " + prefix);
                _listener.Prefixes.Add(prefix);
            }

            _listener.Start();

            Task.Factory.StartNew(Listen, TaskCreationOptions.LongRunning);
        }
        private HttpListener searchListener(Uri uri, out HttpListenerPrefix prefix)
        {
            prefix = null;
            if (uri == null)
            {
                return(null);
            }

            var host      = uri.Host;
            var port      = uri.Port;
            var path      = HttpUtility.UrlDecode(uri.AbsolutePath);
            var pathSlash = path[path.Length - 1] == '/' ? path : path + "/";

            HttpListener bestMatch = null;
            var          bestLen   = -1;

            if (host != null && host.Length > 0)
            {
                foreach (var pref in _prefixes.Keys)
                {
                    var ppath = pref.Path;
                    if (ppath.Length < bestLen)
                    {
                        continue;
                    }

                    if (pref.Host != host || pref.Port != port)
                    {
                        continue;
                    }

                    if (path.StartsWith(ppath) || pathSlash.StartsWith(ppath))
                    {
                        bestLen   = ppath.Length;
                        bestMatch = _prefixes[pref];
                        prefix    = pref;
                    }
                }

                if (bestLen != -1)
                {
                    return(bestMatch);
                }
            }

            var list = _unhandled;

            bestMatch = matchFromList(host, path, list, out prefix);
            if (path != pathSlash && bestMatch == null)
            {
                bestMatch = matchFromList(host, pathSlash, list, out prefix);
            }

            if (bestMatch != null)
            {
                return(bestMatch);
            }

            list      = _all;
            bestMatch = matchFromList(host, path, list, out prefix);
            if (path != pathSlash && bestMatch == null)
            {
                bestMatch = matchFromList(host, pathSlash, list, out prefix);
            }

            if (bestMatch != null)
            {
                return(bestMatch);
            }

            return(null);
        }
Example #5
0
        internal bool TrySearchHttpListener(Uri uri, out HttpListener listener)
        {
            listener = null;

            if (uri == null)
            {
                return(false);
            }

            var host = uri.Host;
            var dns  = Uri.CheckHostName(host) == UriHostNameType.Dns;
            var port = uri.Port.ToString();
            var path = HttpUtility.UrlDecode(uri.AbsolutePath);

            if (path[path.Length - 1] != '/')
            {
                path += "/";
            }

            if (host != null && host.Length > 0)
            {
                var prefs   = _prefixes;
                var bestLen = -1;

                foreach (var pref in prefs)
                {
                    if (dns)
                    {
                        var prefHost = pref.Host;
                        var prefDns  = Uri.CheckHostName(prefHost) == UriHostNameType.Dns;

                        if (prefDns)
                        {
                            if (prefHost != host)
                            {
                                continue;
                            }
                        }
                    }

                    if (pref.Port != port)
                    {
                        continue;
                    }

                    var prefPath = pref.Path;
                    var len      = prefPath.Length;

                    if (len < bestLen)
                    {
                        continue;
                    }

                    if (path.StartsWith(prefPath, StringComparison.Ordinal))
                    {
                        bestLen  = len;
                        listener = pref.Listener;
                    }
                }

                if (bestLen != -1)
                {
                    return(true);
                }
            }

            listener = searchHttpListenerFromSpecial(path, _unhandled);

            if (listener != null)
            {
                return(true);
            }

            listener = searchHttpListenerFromSpecial(path, _all);

            return(listener != null);
        }
Example #6
0
        HttpListener SearchListener(Uri uri, out ListenerPrefix prefix)
        {
            prefix = null;
            if (uri == null)
            {
                return(null);
            }

            string host       = uri.Host;
            int    port       = uri.Port;
            string path       = HttpUtility.UrlDecode(uri.AbsolutePath);
            string path_slash = path [path.Length - 1] == '/' ? path : path + "/";

            HttpListener best_match  = null;
            int          best_length = -1;

            if (host != null && host != "")
            {
                var p_ro = prefixes;
                foreach (ListenerPrefix p in p_ro.Keys)
                {
                    string ppath = p.Path;
                    if (ppath.Length < best_length)
                    {
                        continue;
                    }

                    if (p.Host != host || p.Port != port)
                    {
                        continue;
                    }

                    if (path.StartsWith(ppath) || path_slash.StartsWith(ppath))
                    {
                        best_length = ppath.Length;
                        best_match  = p_ro [p];
                        prefix      = p;
                    }
                }
                if (best_length != -1)
                {
                    return(best_match);
                }
            }

            var list = unhandled;

            best_match = MatchFromList(host, path, list, out prefix);
            if (path != path_slash && best_match == null)
            {
                best_match = MatchFromList(host, path_slash, list, out prefix);
            }
            if (best_match != null)
            {
                return(best_match);
            }

            list       = all;
            best_match = MatchFromList(host, path, list, out prefix);
            if (path != path_slash && best_match == null)
            {
                best_match = MatchFromList(host, path_slash, list, out prefix);
            }
            if (best_match != null)
            {
                return(best_match);
            }

            return(null);
        }
 internal HttpListenerPrefixCollection(HttpListener listener)
 {
     _listener = listener;
     _prefixes = new List <string> ();
 }
Example #8
0
        void OnReadInternal(IAsyncResult ares)
        {
            timer.Change(Timeout.Infinite, Timeout.Infinite);
            int nread = -1;

            try
            {
                nread = stream.EndRead(ares);
                ms.Write(buffer, 0, nread);
                if (ms.Length > 32768)
                {
                    SendError("Bad request", 400);
                    Close(true);
                    return;
                }
            }
            catch
            {
                if (ms != null && ms.Length > 0)
                {
                    SendError();
                }
                if (sock != null)
                {
                    CloseSocket();
                    Unbind();
                }
                return;
            }

            if (nread == 0)
            {
                //if (ms.Length > 0)
                //	SendError (); // Why bother?
                CloseSocket();
                Unbind();
                return;
            }

            if (ProcessInput(ms))
            {
                if (!context.HaveError)
                {
                    context.Request.FinishInitialization();
                }

                if (context.HaveError)
                {
                    SendError();
                    Close(true);
                    return;
                }

                if (!epl.BindContext(context))
                {
                    SendError("Invalid host", 400);
                    Close(true);
                    return;
                }
                HttpListener listener = context.Listener;
                if (last_listener != listener)
                {
                    RemoveConnection();
                    listener.AddConnection(this);
                    last_listener = listener;
                }

                context_bound = true;
                listener.RegisterContext(context);
                return;
            }
            stream.BeginRead(buffer, 0, BufferSize, onread_cb, this);
        }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="manager">The manager to use for opening DBs, etc</param>
        /// <param name="port">The port to listen on</param>
        /// <param name="options">The options to use when configuring the listener</param>
        /// <param name="realm">The realm to use when sending challenges</param>
        /// <param name="sslCert">The certificate to use when serving the listener over https</param>
        public CouchbaseLiteTcpListener(Manager manager, ushort port, CouchbaseLiteTcpOptions options, string realm, X509Certificate2 sslCert)
        {
            _manager = manager;
            _listener = new HttpListener();
            _usesTLS = options.HasFlag(CouchbaseLiteTcpOptions.UseTLS);
            string prefix = _usesTLS ? String.Format("https://*:{0}/", port) :
                String.Format("http://*:{0}/", port);
            _listener.Prefixes.Add(prefix);
            _listener.AuthenticationSchemeSelector = SelectAuthScheme;
            HttpListener.DefaultServerString = "Couchbase Lite " + Manager.VersionString;
            _listener.Realm = realm;
            _allowsBasicAuth = options.HasFlag(CouchbaseLiteTcpOptions.AllowBasicAuth);

            _listener.UserCredentialsFinder = GetCredential;
            if (options.HasFlag(CouchbaseLiteTcpOptions.UseTLS)) {
                #if NET_3_5
                throw new InvalidOperationException("TLS Listener not supported on .NET 3.5");
                #else
                _listener.SslConfiguration.EnabledSslProtocols = SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12;
                _listener.SslConfiguration.ClientCertificateRequired = false;
                if (sslCert == null) {
                    Log.To.Listener.I(TAG, "Generating X509 certificate for listener...");
                    sslCert = X509Manager.GenerateTransientCertificate("Couchbase-P2P");
                }

                Log.To.Listener.I(TAG, "Using X509 certificate {0} (issued by {1})",
                    sslCert.Subject, sslCert.Issuer);
                _listener.SslConfiguration.ServerCertificate = sslCert;
                #endif
            }

            _listener.Log.Level = WebSocketSharp.LogLevel.Trace;
            _listener.Log.Output = (data, msg) =>
            {
                switch(data.Level) {
                    case WebSocketSharp.LogLevel.Fatal:
                        Log.To.Listener.E("HttpServer", data.Message);
                        break;
                    case WebSocketSharp.LogLevel.Error:
                    case WebSocketSharp.LogLevel.Warn:
                        Log.To.Listener.W("HttpServer", data.Message);
                        break;
                    case WebSocketSharp.LogLevel.Info:
                        Log.To.Listener.I("HttpServer", data.Message);
                        break;
                    case WebSocketSharp.LogLevel.Trace:
                    case WebSocketSharp.LogLevel.Debug:
                        Log.To.Listener.V("HttpServer", data.Message);
                        break;
                }
            };
        }